@0xpolygonid/js-sdk 1.30.0 → 1.31.1

package/dist/node/cjs/credentials/credential-wallet.js

@@ -196,7 +196,7 @@ class CredentialWallet {
             }
             return { cred, revStatus };
         }
-        throw new Error('all claims are revoked');
+        throw new Error(verifiable_1.VerifiableConstants.ERRORS.CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED);
     }
 }
 exports.CredentialWallet = CredentialWallet;

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

@@ -4,6 +4,7 @@ exports.verifyExpiresTime = exports.packMetadatas = exports.calcChallengeAuthV2
 const js_crypto_1 = require("@iden3/js-crypto");
 const types_1 = require("../types");
 const utils_1 = require("../../utils");
+const verifiable_1 = require("../../verifiable");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const constants_1 = require("../constants");
 const ethers_1 = require("ethers");
@@ -55,34 +56,60 @@ const processZeroKnowledgeProofRequests = async (to, requests, from, proofServic
     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}`);
+        let zkpRes;
+        try {
+            const isCircuitSupported = opts.supportedCircuits.includes(proofReq.circuitId);
+            if (!isCircuitSupported) {
+                if (proofReq.optional) {
+                    continue;
+                }
+                throw new Error(`Circuit ${proofReq.circuitId} is not allowed`);
             }
-            const combinedQuery = combinedQueryData.query;
-            if (!groupedCredentialsCache.has(groupId)) {
-                const credWithRevStatus = await proofService.findCredentialByProofQuery(to, combinedQueryData.query);
-                if (!credWithRevStatus.cred) {
-                    throw new Error(`Credential not found for query ${JSON.stringify(combinedQuery)}`);
+            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(to, combinedQueryData.query);
+                    if (!credWithRevStatus.cred) {
+                        if (proofReq.optional) {
+                            continue;
+                        }
+                        throw new Error(verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY +
+                            `${JSON.stringify(combinedQuery)}`);
+                    }
+                    groupedCredentialsCache.set(groupId, credWithRevStatus);
                 }
-                groupedCredentialsCache.set(groupId, credWithRevStatus);
             }
+            const credWithRevStatus = groupedCredentialsCache.get(groupId);
+            zkpRes = await proofService.generateProof(proofReq, to, {
+                verifierDid: from,
+                challenge: opts.challenge,
+                skipRevocation: Boolean(query.skipClaimRevocationCheck),
+                credential: credWithRevStatus?.cred,
+                credentialRevocationStatus: credWithRevStatus?.revStatus,
+                linkNonce: combinedQueryData?.linkNonce ? BigInt(combinedQueryData.linkNonce) : undefined
+            });
+        }
+        catch (error) {
+            const expectedErrors = [
+                verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE,
+                verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY,
+                verifiable_1.VerifiableConstants.ERRORS.CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED
+            ];
+            // handle only errors in case credential is not found and it is optional proof request - otherwise throw
+            if (error instanceof Error &&
+                (expectedErrors.includes(error.message) ||
+                    error.message.includes(verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY)) &&
+                proofReq.optional) {
+                continue;
+            }
+            throw error;
         }
-        const credWithRevStatus = groupedCredentialsCache.get(groupId);
-        const zkpRes = await proofService.generateProof(proofReq, to, {
-            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/cjs/identity/identity-wallet.js

@@ -229,7 +229,7 @@ class IdentityWallet {
         let credential;
         const ethSigner = opts.ethSigner;
         if (opts.createBjjCredential && !ethSigner) {
-            throw new Error('Ethereum signer is required to create Ethereum identities in order to transit state');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_SIGNER_IS_REQUIRED);
         }
         const currentState = js_merkletree_1.ZERO_HASH; // In Ethereum identities we don't have an initial state with the auth credential
         const didType = (0, js_iden3_core_1.buildDIDType)(opts.method || js_iden3_core_1.DidMethod.Iden3, opts.blockchain || js_iden3_core_1.Blockchain.Polygon, opts.networkId || js_iden3_core_1.NetworkId.Amoy);
@@ -267,7 +267,7 @@ class IdentityWallet {
         }
         const profile = await this._storage.identity.getProfileById(did.string());
         if (!profile) {
-            throw new Error('profile or identity not found');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_PROFILE_OR_IDENTITY_NOT_FOUND);
         }
         return { nonce: profile.nonce, genesisDID: js_iden3_core_1.DID.parse(profile.genesisIdentifier) };
     }
@@ -277,7 +277,7 @@ class IdentityWallet {
         const identityProfiles = await this._storage.identity.getProfilesByGenesisIdentifier(did.string());
         const existingProfile = identityProfiles.find((p) => p.nonce == nonce || p.verifier == verifier);
         if (existingProfile) {
-            throw new Error('profile with given nonce or verifier already exists');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_PROFILE_ALREADY_EXISTS);
         }
         await this._storage.identity.saveProfile({
             id: profileDID.string(),
@@ -426,11 +426,11 @@ class IdentityWallet {
         const coreClaimHash = js_crypto_1.poseidon.hash([hi, hv]);
         const signature = await this.signChallenge(coreClaimHash, issuerAuthBJJCredential);
         if (!issuerAuthBJJCredential.proof) {
-            throw new Error('issuer auth credential must have proof');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_ANY_PROOF);
         }
         const mtpAuthBJJProof = issuerAuthBJJCredential.getIden3SparseMerkleTreeProof();
         if (!mtpAuthBJJProof) {
-            throw new Error('mtp is required for auth bjj key to issue new credentials');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_MTP_PROOF);
         }
         const sigProof = new verifiable_1.BJJSignatureProof2021({
             issuerData: {
@@ -470,7 +470,7 @@ class IdentityWallet {
         const issuerTree = await this.getDIDTreeModel(issuerDID);
         const coreClaim = await this.getCoreClaimFromCredential(credential);
         if (!coreClaim) {
-            throw new Error('credential must have coreClaim representation in proofs');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_ANY_PROOF);
         }
         const nonce = coreClaim.getRevocationNonce();
         await issuerTree.revocationTree.add(nonce, BigInt(0));
@@ -493,7 +493,7 @@ class IdentityWallet {
             // credential must have a bjj signature proof
             const coreClaim = credential.getCoreClaimFromProof(verifiable_1.ProofType.BJJSignature);
             if (!coreClaim) {
-                throw new Error('credential must have coreClaim representation in the signature proof');
+                throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF);
             }
             await this._storage.mt.addToMerkleTree(issuerDID.string(), storage_1.MerkleTreeType.Claims, coreClaim.hIndex(), coreClaim.hValue());
         }
@@ -525,7 +525,7 @@ class IdentityWallet {
             const coreClaim = credential.getCoreClaimFromProof(verifiable_1.ProofType.BJJSignature) ||
                 (await credential.toCoreClaim(opts));
             if (!coreClaim) {
-                throw new Error('credential must have coreClaim representation in the signature proof');
+                throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF);
             }
             const mtpWithProof = await this.generateCoreClaimMtp(issuerDID, coreClaim, treeState);
             const mtpProof = new verifiable_1.Iden3SparseMerkleTreeProof({
@@ -595,10 +595,10 @@ class IdentityWallet {
         if (coreClaimFromMtpProof &&
             coreClaimFromSigProof &&
             coreClaimFromMtpProof.hex() !== coreClaimFromSigProof.hex()) {
-            throw new Error('core claim representations is set in both proofs but they are not equal');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_MISMATCH);
         }
         if (!coreClaimFromMtpProof && !coreClaimFromSigProof) {
-            throw new Error('core claim is not set in credential proofs');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_IS_NOT_SET);
         }
         //eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
         const coreClaim = coreClaimFromMtpProof ?? coreClaimFromSigProof;
@@ -607,7 +607,7 @@ class IdentityWallet {
     async findOwnedCredentialsByDID(did, query) {
         const credentials = await this._credentialWallet.findByQuery(query);
         if (!credentials.length) {
-            throw new Error(`no credential satisfied query`);
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY);
         }
         const { genesisDID } = await this.getGenesisDIDMetadata(did);
         const profiles = await this.getProfilesByDID(genesisDID);
@@ -647,7 +647,7 @@ class IdentityWallet {
         let txId;
         if (!isEthIdentity) {
             if (!prover) {
-                throw new Error('prover is required to generate proofs for non ethereum identities');
+                throw new Error(verifiable_1.VerifiableConstants.ERRORS.ID_WALLET_PROVER_IS_REQUIRED);
             }
             // generate the proof
             const authInfo = await this._inputsGenerator.prepareAuthBJJCredential(did, oldTreeState);

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

@@ -76,7 +76,8 @@ class ProofService {
             credentialWithRevStatus = { cred: opts.credential, revStatus };
         }
         if (!credentialWithRevStatus.cred) {
-            throw new Error(`credential not found for query ${JSON.stringify(proofReq.query)}`);
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY +
+                ` ${JSON.stringify(proofReq.query)}`);
         }
         const credentialCoreClaim = await this._identityWallet.getCoreClaimFromCredential(credentialWithRevStatus.cred);
         const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(identifier);
@@ -88,11 +89,11 @@ class ProofService {
         const subjectDID = js_iden3_core_1.DID.parse(preparedCredential.credential.credentialSubject['id']);
         const { nonce: credentialSubjectProfileNonce, genesisDID: subjectGenesisDID } = await this._identityWallet.getGenesisDIDMetadata(subjectDID);
         if (subjectGenesisDID.string() !== genesisDID.string()) {
-            throw new Error('subject and auth profiles are not derived from the same did');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_PROFILE_GENESIS_DID_MISMATCH);
         }
         const propertiesMetadata = (0, common_1.parseCredentialSubject)(proofReq.query.credentialSubject);
         if (!propertiesMetadata.length) {
-            throw new Error('no queries in zkp request');
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_NO_QUERIES_IN_ZKP_REQUEST);
         }
         const mtPosition = preparedCredential.credentialCoreClaim.getMerklizedPosition();
         let mk;
@@ -276,7 +277,7 @@ class ProofService {
     async findCredentialByProofQuery(did, query) {
         const credentials = await this._identityWallet.findOwnedCredentialsByDID(did, query);
         if (!credentials.length) {
-            throw new Error(`no credentials belong to did or its profiles`);
+            throw new Error(verifiable_1.VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE);
         }
         //  For EQ / IN / NIN / LT / GT operations selective if credential satisfies query - we can get any.
         // TODO: choose credential for selective credentials

package/dist/node/cjs/proof/verifiers/query.js

@@ -1,12 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fieldValueFromVerifiablePresentation = exports.validateEmptyCredentialSubjectNoopNativeSupport = exports.validateDisclosureNativeSDSupport = exports.validateDisclosureV2Circuit = exports.validateOperators = exports.validateEmptyCredentialSubjectV2Circuit = exports.verifyFieldValueInclusionNativeExistsSupport = exports.verifyFieldValueInclusionV2 = exports.checkCircuitOperator = exports.checkCircuitQueriesLength = exports.checkQueryRequest = void 0;
+exports.calculateMultiRequestId = exports.calculateRequestId = exports.calculateGroupId = exports.fieldValueFromVerifiablePresentation = exports.validateEmptyCredentialSubjectNoopNativeSupport = exports.validateDisclosureNativeSDSupport = exports.validateDisclosureV2Circuit = exports.validateOperators = exports.validateEmptyCredentialSubjectV2Circuit = exports.verifyFieldValueInclusionNativeExistsSupport = exports.verifyFieldValueInclusionV2 = exports.checkCircuitOperator = exports.checkCircuitQueriesLength = exports.checkQueryRequest = void 0;
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const js_jsonld_merklization_1 = require("@iden3/js-jsonld-merklization");
 const utils_1 = require("../../utils");
 const comparer_1 = require("../../circuits/comparer");
 const verifiable_1 = require("../../verifiable");
 const provers_1 = require("../provers");
+const ethers_1 = require("ethers");
 const defaultProofGenerationDelayOpts = 24 * 60 * 60 * 1000; // 24 hours
 async function checkQueryRequest(query, queriesMetadata, ldContext, outputs, circuitId, schemaLoader, opts) {
     // validate issuer
@@ -211,3 +212,26 @@ const fieldValueFromVerifiablePresentation = async (fieldName, verifiablePresent
     return await value.mtEntry();
 };
 exports.fieldValueFromVerifiablePresentation = fieldValueFromVerifiablePresentation;
+function calculateGroupId(requestIds) {
+    const types = Array(requestIds.length).fill('uint256');
+    const groupID = BigInt(ethers_1.ethers.keccak256(ethers_1.ethers.solidityPacked(types, requestIds))) &
+        // It should fit in a field number in the circuit (max 253 bits). With this we truncate to 252 bits for the group ID
+        BigInt('0x0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF');
+    return groupID;
+}
+exports.calculateGroupId = calculateGroupId;
+function calculateRequestId(requestParams, creatorAddress) {
+    // 0x0000000000000000FFFF...FF. Reserved first 8 bytes for the request Id type and future use
+    // 0x00010000000000000000...00. First 2 bytes for the request Id type
+    //    - 0x0000... for old request Ids with uint64
+    //    - 0x0001... for new request Ids with uint256
+    const requestId = (BigInt(ethers_1.ethers.keccak256(ethers_1.ethers.solidityPacked(['bytes', 'address'], [requestParams, creatorAddress]))) &
+        BigInt('0x0000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')) +
+        BigInt('0x0001000000000000000000000000000000000000000000000000000000000000');
+    return requestId;
+}
+exports.calculateRequestId = calculateRequestId;
+function calculateMultiRequestId(requestIds, groupIds, creatorAddress) {
+    return BigInt(ethers_1.ethers.keccak256(ethers_1.ethers.solidityPacked(['uint256[]', 'uint256[]', 'address'], [requestIds, groupIds, creatorAddress])));
+}
+exports.calculateMultiRequestId = calculateMultiRequestId;

package/dist/node/cjs/schema-processor/json/validator.js

@@ -44,6 +44,7 @@ class JsonSchemaValidator {
         validator = ajv ?? defaultJSONSchemaValidator;
         if (validator.formats && !Object.keys(validator.formats).length) {
             (0, ajv_formats_1.default)(validator);
+            addCustomFormats(validator);
         }
         const validate = (schema.$id ? validator.getSchema(schema.$id) : undefined) || validator.compile(schema);
         const valid = validate(data);
@@ -55,3 +56,13 @@ class JsonSchemaValidator {
     }
 }
 exports.JsonSchemaValidator = JsonSchemaValidator;
+function addCustomFormats(validator) {
+    validator.addFormat('positive-integer', {
+        type: 'string',
+        validate: (positiveIntegerStr) => /^[1-9]\d*$/.test(positiveIntegerStr)
+    });
+    validator.addFormat('non-negative-integer', {
+        type: 'string',
+        validate: (nonNegativeIntegerStr) => /^(0|[1-9]\d*)$/.test(nonNegativeIntegerStr)
+    });
+}

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

@@ -8,7 +8,26 @@ exports.VerifiableConstants = Object.freeze({
         CONTEXT_TYPE_IS_EMPTY: 'ctxType is empty',
         // ErrStateNotFound issuer state is genesis state.
         IDENTITY_DOES_NOT_EXIST: 'Identity does not exist',
-        NO_AUTH_CRED_FOUND: 'no auth credentials found'
+        NO_AUTH_CRED_FOUND: 'no auth credentials found',
+        // identity wallet
+        ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY: 'no credential satisfied query',
+        ID_WALLET_SIGNER_IS_REQUIRED: 'Ethereum signer is required to create Ethereum identities in order to transit state',
+        ID_WALLET_PROVER_IS_REQUIRED: 'prover is required to generate proofs for non ethereum identities',
+        ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF: 'credential must have coreClaim representation in the signature proof',
+        ID_WALLET_CORE_CLAIM_REQUIRED_IN_ANY_PROOF: 'credential must have coreClaim representation in proofs',
+        ID_WALLET_CORE_CLAIM_MISMATCH: 'core claim representations is set in both proofs but they are not equal',
+        ID_WALLET_CORE_CLAIM_IS_NOT_SET: 'core claim is not set in credential proofs',
+        ID_WALLET_PROFILE_OR_IDENTITY_NOT_FOUND: 'profile or identity not found',
+        ID_WALLET_PROFILE_ALREADY_EXISTS: 'profile with given nonce or verifier already exists',
+        ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_ANY_PROOF: 'issuer auth credential must have proof',
+        ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_MTP_PROOF: 'mtp is required for auth bjj key to issue new credentials',
+        // proof service
+        PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE: 'no credentials belong to did or its profiles',
+        PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY: 'credential not found for query',
+        PROOF_SERVICE_PROFILE_GENESIS_DID_MISMATCH: 'subject and auth profiles are not derived from the same did',
+        PROOF_SERVICE_NO_QUERIES_IN_ZKP_REQUEST: 'no queries in zkp request',
+        // credential wallet
+        CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED: 'all claims are revoked'
     },
     CREDENTIAL_TYPE: {
         // VerifiableCredential is a W3C verifiable credential type

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

@@ -47,12 +47,12 @@ const createVerifiablePresentation = (context, tp, credential, queries) => {
     }
     const skeleton = {
         '@context': baseContext,
-        '@type': constants_1.VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_PRESENTATION,
+        type: constants_1.VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_PRESENTATION,
         verifiableCredential: {
             '@context': ldContext,
-            '@type': vcTypes,
+            type: vcTypes,
             credentialSubject: {
-                '@type': tp
+                type: tp
             }
         }
     };

package/dist/node/esm/credentials/credential-wallet.js

@@ -170,6 +170,6 @@ export class CredentialWallet {
             }
             return { cred, revStatus };
         }
-        throw new Error('all claims are revoked');
+        throw new Error(VerifiableConstants.ERRORS.CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED);
     }
 }

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

@@ -1,6 +1,7 @@
 import { getRandomBytes } from '@iden3/js-crypto';
 import { AuthMethod } from '../types';
 import { mergeObjects } from '../../utils';
+import { VerifiableConstants } from '../../verifiable';
 import { getUnixTimestamp } from '@iden3/js-iden3-core';
 import { AcceptJwsAlgorithms, defaultAcceptProfile, MediaType } from '../constants';
 import { ethers } from 'ethers';
@@ -52,34 +53,60 @@ export const processZeroKnowledgeProofRequests = async (to, requests, from, proo
     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}`);
+        let zkpRes;
+        try {
+            const isCircuitSupported = opts.supportedCircuits.includes(proofReq.circuitId);
+            if (!isCircuitSupported) {
+                if (proofReq.optional) {
+                    continue;
+                }
+                throw new Error(`Circuit ${proofReq.circuitId} is not allowed`);
             }
-            const combinedQuery = combinedQueryData.query;
-            if (!groupedCredentialsCache.has(groupId)) {
-                const credWithRevStatus = await proofService.findCredentialByProofQuery(to, combinedQueryData.query);
-                if (!credWithRevStatus.cred) {
-                    throw new Error(`Credential not found for query ${JSON.stringify(combinedQuery)}`);
+            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(to, combinedQueryData.query);
+                    if (!credWithRevStatus.cred) {
+                        if (proofReq.optional) {
+                            continue;
+                        }
+                        throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY +
+                            `${JSON.stringify(combinedQuery)}`);
+                    }
+                    groupedCredentialsCache.set(groupId, credWithRevStatus);
                 }
-                groupedCredentialsCache.set(groupId, credWithRevStatus);
             }
+            const credWithRevStatus = groupedCredentialsCache.get(groupId);
+            zkpRes = await proofService.generateProof(proofReq, to, {
+                verifierDid: from,
+                challenge: opts.challenge,
+                skipRevocation: Boolean(query.skipClaimRevocationCheck),
+                credential: credWithRevStatus?.cred,
+                credentialRevocationStatus: credWithRevStatus?.revStatus,
+                linkNonce: combinedQueryData?.linkNonce ? BigInt(combinedQueryData.linkNonce) : undefined
+            });
+        }
+        catch (error) {
+            const expectedErrors = [
+                VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE,
+                VerifiableConstants.ERRORS.ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY,
+                VerifiableConstants.ERRORS.CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED
+            ];
+            // handle only errors in case credential is not found and it is optional proof request - otherwise throw
+            if (error instanceof Error &&
+                (expectedErrors.includes(error.message) ||
+                    error.message.includes(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY)) &&
+                proofReq.optional) {
+                continue;
+            }
+            throw error;
         }
-        const credWithRevStatus = groupedCredentialsCache.get(groupId);
-        const zkpRes = await proofService.generateProof(proofReq, to, {
-            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/identity/identity-wallet.js

@@ -203,7 +203,7 @@ export class IdentityWallet {
         let credential;
         const ethSigner = opts.ethSigner;
         if (opts.createBjjCredential && !ethSigner) {
-            throw new Error('Ethereum signer is required to create Ethereum identities in order to transit state');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_SIGNER_IS_REQUIRED);
         }
         const currentState = ZERO_HASH; // In Ethereum identities we don't have an initial state with the auth credential
         const didType = buildDIDType(opts.method || DidMethod.Iden3, opts.blockchain || Blockchain.Polygon, opts.networkId || NetworkId.Amoy);
@@ -241,7 +241,7 @@ export class IdentityWallet {
         }
         const profile = await this._storage.identity.getProfileById(did.string());
         if (!profile) {
-            throw new Error('profile or identity not found');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROFILE_OR_IDENTITY_NOT_FOUND);
         }
         return { nonce: profile.nonce, genesisDID: DID.parse(profile.genesisIdentifier) };
     }
@@ -251,7 +251,7 @@ export class IdentityWallet {
         const identityProfiles = await this._storage.identity.getProfilesByGenesisIdentifier(did.string());
         const existingProfile = identityProfiles.find((p) => p.nonce == nonce || p.verifier == verifier);
         if (existingProfile) {
-            throw new Error('profile with given nonce or verifier already exists');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROFILE_ALREADY_EXISTS);
         }
         await this._storage.identity.saveProfile({
             id: profileDID.string(),
@@ -400,11 +400,11 @@ export class IdentityWallet {
         const coreClaimHash = poseidon.hash([hi, hv]);
         const signature = await this.signChallenge(coreClaimHash, issuerAuthBJJCredential);
         if (!issuerAuthBJJCredential.proof) {
-            throw new Error('issuer auth credential must have proof');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_ANY_PROOF);
         }
         const mtpAuthBJJProof = issuerAuthBJJCredential.getIden3SparseMerkleTreeProof();
         if (!mtpAuthBJJProof) {
-            throw new Error('mtp is required for auth bjj key to issue new credentials');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_MTP_PROOF);
         }
         const sigProof = new BJJSignatureProof2021({
             issuerData: {
@@ -444,7 +444,7 @@ export class IdentityWallet {
         const issuerTree = await this.getDIDTreeModel(issuerDID);
         const coreClaim = await this.getCoreClaimFromCredential(credential);
         if (!coreClaim) {
-            throw new Error('credential must have coreClaim representation in proofs');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_ANY_PROOF);
         }
         const nonce = coreClaim.getRevocationNonce();
         await issuerTree.revocationTree.add(nonce, BigInt(0));
@@ -467,7 +467,7 @@ export class IdentityWallet {
             // credential must have a bjj signature proof
             const coreClaim = credential.getCoreClaimFromProof(ProofType.BJJSignature);
             if (!coreClaim) {
-                throw new Error('credential must have coreClaim representation in the signature proof');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF);
             }
             await this._storage.mt.addToMerkleTree(issuerDID.string(), MerkleTreeType.Claims, coreClaim.hIndex(), coreClaim.hValue());
         }
@@ -499,7 +499,7 @@ export class IdentityWallet {
             const coreClaim = credential.getCoreClaimFromProof(ProofType.BJJSignature) ||
                 (await credential.toCoreClaim(opts));
             if (!coreClaim) {
-                throw new Error('credential must have coreClaim representation in the signature proof');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF);
             }
             const mtpWithProof = await this.generateCoreClaimMtp(issuerDID, coreClaim, treeState);
             const mtpProof = new Iden3SparseMerkleTreeProof({
@@ -569,10 +569,10 @@ export class IdentityWallet {
         if (coreClaimFromMtpProof &&
             coreClaimFromSigProof &&
             coreClaimFromMtpProof.hex() !== coreClaimFromSigProof.hex()) {
-            throw new Error('core claim representations is set in both proofs but they are not equal');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_MISMATCH);
         }
         if (!coreClaimFromMtpProof && !coreClaimFromSigProof) {
-            throw new Error('core claim is not set in credential proofs');
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_IS_NOT_SET);
         }
         //eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
         const coreClaim = coreClaimFromMtpProof ?? coreClaimFromSigProof;
@@ -581,7 +581,7 @@ export class IdentityWallet {
     async findOwnedCredentialsByDID(did, query) {
         const credentials = await this._credentialWallet.findByQuery(query);
         if (!credentials.length) {
-            throw new Error(`no credential satisfied query`);
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY);
         }
         const { genesisDID } = await this.getGenesisDIDMetadata(did);
         const profiles = await this.getProfilesByDID(genesisDID);
@@ -621,7 +621,7 @@ export class IdentityWallet {
         let txId;
         if (!isEthIdentity) {
             if (!prover) {
-                throw new Error('prover is required to generate proofs for non ethereum identities');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROVER_IS_REQUIRED);
             }
             // generate the proof
             const authInfo = await this._inputsGenerator.prepareAuthBJJCredential(did, oldTreeState);

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

@@ -1,6 +1,6 @@
 import { BytesHelper, DID, MerklizedRootPosition, getDateFromUnixTimestamp } from '@iden3/js-iden3-core';
 import { AuthV2Inputs, AuthV2PubSignals, CircuitId, Operators, Query, ValueProof } from '../circuits';
-import { createVerifiablePresentation } from '../verifiable';
+import { createVerifiablePresentation, VerifiableConstants } from '../verifiable';
 import { parseCredentialSubject, parseQueryMetadata, toGISTProof, transformQueryValueToBigInts } from './common';
 import { NativeProver } from './provers/prover';
 import { getDocumentLoader } from '@iden3/js-jsonld-merklization';
@@ -73,7 +73,8 @@ export class ProofService {
             credentialWithRevStatus = { cred: opts.credential, revStatus };
         }
         if (!credentialWithRevStatus.cred) {
-            throw new Error(`credential not found for query ${JSON.stringify(proofReq.query)}`);
+            throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY +
+                ` ${JSON.stringify(proofReq.query)}`);
         }
         const credentialCoreClaim = await this._identityWallet.getCoreClaimFromCredential(credentialWithRevStatus.cred);
         const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(identifier);
@@ -85,11 +86,11 @@ export class ProofService {
         const subjectDID = DID.parse(preparedCredential.credential.credentialSubject['id']);
         const { nonce: credentialSubjectProfileNonce, genesisDID: subjectGenesisDID } = await this._identityWallet.getGenesisDIDMetadata(subjectDID);
         if (subjectGenesisDID.string() !== genesisDID.string()) {
-            throw new Error('subject and auth profiles are not derived from the same did');
+            throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_PROFILE_GENESIS_DID_MISMATCH);
         }
         const propertiesMetadata = parseCredentialSubject(proofReq.query.credentialSubject);
         if (!propertiesMetadata.length) {
-            throw new Error('no queries in zkp request');
+            throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_QUERIES_IN_ZKP_REQUEST);
         }
         const mtPosition = preparedCredential.credentialCoreClaim.getMerklizedPosition();
         let mk;
@@ -273,7 +274,7 @@ export class ProofService {
     async findCredentialByProofQuery(did, query) {
         const credentials = await this._identityWallet.findOwnedCredentialsByDID(did, query);
         if (!credentials.length) {
-            throw new Error(`no credentials belong to did or its profiles`);
+            throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE);
         }
         //  For EQ / IN / NIN / LT / GT operations selective if credential satisfies query - we can get any.
         // TODO: choose credential for selective credentials

package/dist/node/esm/proof/verifiers/query.js

@@ -4,6 +4,7 @@ import { byteEncoder } from '../../utils';
 import { getOperatorNameByValue, Operators, QueryOperators } from '../../circuits/comparer';
 import { calculateCoreSchemaHash, VerifiableConstants } from '../../verifiable';
 import { circuitValidator } from '../provers';
+import { ethers } from 'ethers';
 const defaultProofGenerationDelayOpts = 24 * 60 * 60 * 1000; // 24 hours
 export async function checkQueryRequest(query, queriesMetadata, ldContext, outputs, circuitId, schemaLoader, opts) {
     // validate issuer
@@ -197,3 +198,23 @@ export const fieldValueFromVerifiablePresentation = async (fieldName, verifiable
     }
     return await value.mtEntry();
 };
+export function calculateGroupId(requestIds) {
+    const types = Array(requestIds.length).fill('uint256');
+    const groupID = BigInt(ethers.keccak256(ethers.solidityPacked(types, requestIds))) &
+        // It should fit in a field number in the circuit (max 253 bits). With this we truncate to 252 bits for the group ID
+        BigInt('0x0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF');
+    return groupID;
+}
+export function calculateRequestId(requestParams, creatorAddress) {
+    // 0x0000000000000000FFFF...FF. Reserved first 8 bytes for the request Id type and future use
+    // 0x00010000000000000000...00. First 2 bytes for the request Id type
+    //    - 0x0000... for old request Ids with uint64
+    //    - 0x0001... for new request Ids with uint256
+    const requestId = (BigInt(ethers.keccak256(ethers.solidityPacked(['bytes', 'address'], [requestParams, creatorAddress]))) &
+        BigInt('0x0000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')) +
+        BigInt('0x0001000000000000000000000000000000000000000000000000000000000000');
+    return requestId;
+}
+export function calculateMultiRequestId(requestIds, groupIds, creatorAddress) {
+    return BigInt(ethers.keccak256(ethers.solidityPacked(['uint256[]', 'uint256[]', 'address'], [requestIds, groupIds, creatorAddress])));
+}

package/dist/node/esm/schema-processor/json/validator.js

@@ -38,6 +38,7 @@ export class JsonSchemaValidator {
         validator = ajv ?? defaultJSONSchemaValidator;
         if (validator.formats && !Object.keys(validator.formats).length) {
             addFormats(validator);
+            addCustomFormats(validator);
         }
         const validate = (schema.$id ? validator.getSchema(schema.$id) : undefined) || validator.compile(schema);
         const valid = validate(data);
@@ -48,3 +49,13 @@ export class JsonSchemaValidator {
         return true;
     }
 }
+function addCustomFormats(validator) {
+    validator.addFormat('positive-integer', {
+        type: 'string',
+        validate: (positiveIntegerStr) => /^[1-9]\d*$/.test(positiveIntegerStr)
+    });
+    validator.addFormat('non-negative-integer', {
+        type: 'string',
+        validate: (nonNegativeIntegerStr) => /^(0|[1-9]\d*)$/.test(nonNegativeIntegerStr)
+    });
+}