@0xpolygonid/js-sdk 1.30.0 → 1.31.3

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DisplayMethodType = exports.PaymentFeatures = exports.SupportedCurrencies = exports.SupportedPaymentProofType = exports.PaymentType = exports.PaymentRequestDataType = exports.RefreshServiceType = exports.SubjectPosition = exports.MerklizedRootPosition = exports.ProofPurpose = exports.CredentialStatusType = exports.ProofType = exports.VerifiableConstants = void 0;
+exports.DEFAULT_CACHE_MAX_SIZE = exports.DisplayMethodType = exports.PaymentFeatures = exports.SupportedCurrencies = exports.SupportedPaymentProofType = exports.PaymentType = exports.PaymentRequestDataType = exports.RefreshServiceType = exports.SubjectPosition = exports.MerklizedRootPosition = exports.ProofPurpose = exports.CredentialStatusType = exports.ProofType = exports.VerifiableConstants = void 0;
 /** Verifiable constants */
 exports.VerifiableConstants = Object.freeze({
     ERRORS: {
@@ -8,7 +8,27 @@ 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_PROFILE_ALREADY_EXISTS_VERIFIER_TAGS: 'profile with given verifier and tags 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
@@ -181,3 +201,7 @@ var DisplayMethodType;
 (function (DisplayMethodType) {
     DisplayMethodType["Iden3BasicDisplayMethodV1"] = "Iden3BasicDisplayMethodV1";
 })(DisplayMethodType = exports.DisplayMethodType || (exports.DisplayMethodType = {}));
+/**
+ * Default cache max size for in-memory cache
+ */
+exports.DEFAULT_CACHE_MAX_SIZE = 10000;

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/credentials/status/on-chain-revocation.js

@@ -1,5 +1,5 @@
 import { OnChainRevocationStorage } from '../../storage/blockchain/onchain-revocation';
-import { DID, getChainId } from '@iden3/js-iden3-core';
+import { DID } from '@iden3/js-iden3-core';
 import { VerifiableConstants } from '../../verifiable/constants';
 import { isGenesisState } from '../../utils';
 import { EthStateStorage } from '../../storage/blockchain/state';
@@ -18,8 +18,9 @@ export class OnChainResolver {
      * @public
      * @param {Array<EthConnectionConfig>} _configs - list of ethereum network connections
      */
-    constructor(_configs) {
+    constructor(_configs, _opts) {
         this._configs = _configs;
+        this._stateStorage = new EthStateStorage(_configs, _opts?.stateStorageOptions);
     }
     /**
      * resolve is a method to resolve a credential status from the blockchain.
@@ -50,8 +51,7 @@ export class OnChainResolver {
         const issuerId = DID.idFromDID(issuer);
         let latestIssuerState;
         try {
-            const ethStorage = this._getStateStorageForIssuer(issuerId);
-            const latestStateInfo = await ethStorage.getLatestStateById(issuerId.bigInt());
+            const latestStateInfo = await this._stateStorage.getLatestStateById(issuerId.bigInt());
             if (!latestStateInfo.state) {
                 throw new Error('state contract returned empty state');
             }
@@ -117,13 +117,6 @@ export class OnChainResolver {
         }
         return network;
     }
-    // TODO: is dirty hack for mock in tests.
-    // need to pass to constructor list of state stores not list of network configs
-    _getStateStorageForIssuer(issuerId) {
-        const issuerChainId = getChainId(DID.blockchainFromId(issuerId), DID.networkIdFromId(issuerId));
-        const ethStorage = new EthStateStorage(this.networkByChainId(issuerChainId));
-        return ethStorage;
-    }
     _getOnChainRevocationStorageForIssuer(chainId, contractAddress) {
         const networkConfig = this.networkByChainId(chainId);
         const onChainCaller = new OnChainRevocationStorage(networkConfig, contractAddress);

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,23 +241,28 @@ 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) };
     }
     /** {@inheritDoc IIdentityWallet.createProfile} */
-    async createProfile(did, nonce, verifier) {
+    async createProfile(did, nonce, verifier, tags) {
         const profileDID = generateProfileDID(did, nonce);
         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');
+        const profilesForTagAndVerifier = await this._storage.identity.getProfilesByVerifier(verifier, tags);
+        if (profilesForTagAndVerifier.length) {
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROFILE_ALREADY_EXISTS_VERIFIER_TAGS);
+        }
+        const existingProfileWithNonce = identityProfiles.find((p) => p.nonce == nonce);
+        if (existingProfileWithNonce) {
+            throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROFILE_ALREADY_EXISTS);
         }
         await this._storage.identity.saveProfile({
             id: profileDID.string(),
             nonce,
             genesisIdentifier: did.string(),
-            verifier
+            verifier,
+            tags
         });
         return profileDID;
     }
@@ -276,9 +281,17 @@ export class IdentityWallet {
         const key = await this._kms.createKeyFromSeed(keyType, getRandomBytes(32));
         return key;
     }
+    /**
+     * @deprecated The method should not be used. It returns only one profile per verifier, which can potentially restrict business use cases
+     * {@inheritDoc IIdentityWallet.getProfileByVerifier}
+     */
     async getProfileByVerifier(verifier) {
         return this._storage.identity.getProfileByVerifier(verifier);
     }
+    /** {@inheritDoc IIdentityWallet.getProfilesByVerifier} */
+    async getProfilesByVerifier(verifier, tags) {
+        return this._storage.identity.getProfilesByVerifier(verifier, tags);
+    }
     /** {@inheritDoc IIdentityWallet.getDIDTreeModel} */
     async getDIDTreeModel(did) {
         const didStr = did.string();
@@ -400,11 +413,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 +457,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 +480,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 +512,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 +582,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 +594,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 +634,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)
+    });
+}

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

@@ -1,7 +1,6 @@
 import { JsonRpcProvider, Contract, ethers } from 'ethers';
 import { AuthMethod, processProofResponse } from '../../iden3comm';
 import abi from './abi/ZkpVerifier.json';
-//import { UniversalVerifier } from '@iden3/universal-verifier-v2-abi';
 import { IVerifierABI } from '@iden3/universal-verifier-v2-abi';
 import { TransactionService } from '../../blockchain';
 import { BytesHelper, chainIDfromDID, DID, Id } from '@iden3/js-iden3-core';

package/dist/node/esm/storage/blockchain/state.js

@@ -5,6 +5,9 @@ import abi from './abi/State.json';
 import { DID, getChainId, Id } from '@iden3/js-iden3-core';
 import { TransactionService } from '../../blockchain';
 import { prepareZkpProof } from './common';
+import { createInMemoryCache } from '../memory';
+import { PROTOCOL_CONSTANTS } from '../../iden3comm';
+import { DEFAULT_CACHE_MAX_SIZE } from '../../verifiable';
 export /** @type {EthConnectionConfig} - default configuration for EthConnectionConfig */ const defaultEthConnectionConfig = {
     url: 'http://localhost:8545',
     defaultGasLimit: 600000,
@@ -30,15 +33,71 @@ export class EthStateStorage {
      * Creates an instance of EthStateStorage.
      * @param {EthConnectionConfig} [ethConfig=defaultEthConnectionConfig]
      */
-    constructor(ethConfig) {
+    constructor(ethConfig, options) {
         this.ethConfig = ethConfig;
+        this._disableCache = false;
         const config = Array.isArray(ethConfig) ? ethConfig[0] : ethConfig;
         this.provider = new JsonRpcProvider(config.url);
         this.stateContract = new Contract(config.contractAddress, abi, this.provider);
         this._transactionService = new TransactionService(this.getRpcProvider());
+        // Store cache options for later use
+        this._latestStateCacheOptions = {
+            ttl: options?.latestStateCacheOptions?.ttl ?? PROTOCOL_CONSTANTS.DEFAULT_PROOF_VERIFY_DELAY / 2,
+            maxSize: options?.latestStateCacheOptions?.maxSize ?? DEFAULT_CACHE_MAX_SIZE
+        };
+        this._stateCacheOptions = {
+            notReplacedTtl: options?.stateCacheOptions?.notReplacedTtl ??
+                PROTOCOL_CONSTANTS.DEFAULT_PROOF_VERIFY_DELAY / 2,
+            replacedTtl: options?.stateCacheOptions?.replacedTtl ?? PROTOCOL_CONSTANTS.DEFAULT_PROOF_VERIFY_DELAY,
+            maxSize: options?.stateCacheOptions?.maxSize ?? DEFAULT_CACHE_MAX_SIZE
+        };
+        this._rootCacheOptions = {
+            replacedTtl: options?.rootCacheOptions?.replacedTtl ?? PROTOCOL_CONSTANTS.DEFAULT_AUTH_VERIFY_DELAY,
+            notReplacedTtl: options?.rootCacheOptions?.notReplacedTtl ??
+                PROTOCOL_CONSTANTS.DEFAULT_AUTH_VERIFY_DELAY / 2,
+            maxSize: options?.rootCacheOptions?.maxSize ?? DEFAULT_CACHE_MAX_SIZE
+        };
+        this._gistProofCacheOptions = {
+            ttl: PROTOCOL_CONSTANTS.DEFAULT_AUTH_VERIFY_DELAY / 2,
+            maxSize: options?.gistProofCacheOptions?.maxSize ?? DEFAULT_CACHE_MAX_SIZE
+        };
+        // Initialize cache instances
+        this._latestStateResolveCache =
+            options?.latestStateCacheOptions?.cache ??
+                createInMemoryCache({
+                    maxSize: this._latestStateCacheOptions.maxSize,
+                    ttl: this._latestStateCacheOptions.ttl
+                });
+        this._stateResolveCache =
+            options?.stateCacheOptions?.cache ??
+                createInMemoryCache({
+                    maxSize: this._stateCacheOptions.maxSize,
+                    ttl: this._stateCacheOptions.replacedTtl
+                });
+        this._rootResolveCache =
+            options?.rootCacheOptions?.cache ??
+                createInMemoryCache({
+                    maxSize: this._rootCacheOptions.maxSize,
+                    ttl: this._rootCacheOptions.replacedTtl
+                });
+        this._gistProofResolveCache =
+            options?.gistProofCacheOptions?.cache ??
+                createInMemoryCache({
+                    maxSize: this._gistProofCacheOptions.maxSize,
+                    ttl: this._gistProofCacheOptions.ttl
+                });
+        this._disableCache = options?.disableCache ?? false;
     }
     /** {@inheritdoc IStateStorage.getLatestStateById} */
     async getLatestStateById(id) {
+        const cacheKey = this.getLatestStateCacheKey(id);
+        if (!this._disableCache) {
+            // Check cache first
+            const cachedResult = await this._latestStateResolveCache?.get(cacheKey);
+            if (cachedResult) {
+                return cachedResult;
+            }
+        }
         const { stateContract } = this.getStateContractAndProviderForId(id);
         const rawData = await stateContract.getStateInfoById(id);
         const stateInfo = {
@@ -50,10 +109,20 @@ export class EthStateStorage {
             createdAtBlock: BigInt(rawData[5]),
             replacedAtBlock: BigInt(rawData[6])
         };
+        !this._disableCache &&
+            (await this._latestStateResolveCache?.set(cacheKey, stateInfo, this._latestStateCacheOptions.ttl));
         return stateInfo;
     }
     /** {@inheritdoc IStateStorage.getStateInfoByIdAndState} */
     async getStateInfoByIdAndState(id, state) {
+        const cacheKey = this.getStateCacheKey(id, state);
+        if (!this._disableCache) {
+            // Check cache first
+            const cachedResult = await this._stateResolveCache?.get(cacheKey);
+            if (cachedResult) {
+                return cachedResult;
+            }
+        }
         const { stateContract } = this.getStateContractAndProviderForId(id);
         const rawData = await stateContract.getStateInfoByIdAndState(id, state);
         const stateInfo = {
@@ -65,6 +134,10 @@ export class EthStateStorage {
             createdAtBlock: BigInt(rawData[5]),
             replacedAtBlock: BigInt(rawData[6])
         };
+        const ttl = stateInfo.replacedAtTimestamp === 0n
+            ? this._stateCacheOptions.notReplacedTtl
+            : this._stateCacheOptions.replacedTtl;
+        !this._disableCache && (await this._stateResolveCache?.set(cacheKey, stateInfo, ttl));
         return stateInfo;
     }
     /** {@inheritdoc IStateStorage.publishState} */
@@ -137,9 +210,17 @@ export class EthStateStorage {
     }
     /** {@inheritdoc IStateStorage.getGISTProof} */
     async getGISTProof(id) {
+        const cacheKey = this.getGistProofCacheKey(id);
+        if (!this._disableCache) {
+            // Check cache first
+            const cachedResult = await this._gistProofResolveCache?.get(cacheKey);
+            if (cachedResult) {
+                return cachedResult;
+            }
+        }
         const { stateContract } = this.getStateContractAndProviderForId(id);
         const data = await stateContract.getGISTProof(id);
-        return {
+        const stateProof = {
             root: BigInt(data.root.toString()),
             existence: data.existence,
             siblings: data.siblings?.map((sibling) => BigInt(sibling.toString())),
@@ -149,12 +230,23 @@ export class EthStateStorage {
             auxIndex: BigInt(data.auxIndex.toString()),
             auxValue: BigInt(data.auxValue.toString())
         };
+        !this._disableCache &&
+            (await this._gistProofResolveCache?.set(cacheKey, stateProof, this._gistProofCacheOptions.ttl));
+        return stateProof;
     }
     /** {@inheritdoc IStateStorage.getGISTRootInfo} */
     async getGISTRootInfo(root, id) {
+        const cacheKey = this.getRootCacheKey(root);
+        if (!this._disableCache) {
+            // Check cache first
+            const cachedResult = await this._rootResolveCache?.get(cacheKey);
+            if (cachedResult) {
+                return cachedResult;
+            }
+        }
         const { stateContract } = this.getStateContractAndProviderForId(id);
         const data = await stateContract.getGISTRootInfo(root);
-        return {
+        const rootInfo = {
             root: BigInt(data.root.toString()),
             replacedByRoot: BigInt(data.replacedByRoot.toString()),
             createdAtTimestamp: BigInt(data.createdAtTimestamp.toString()),
@@ -162,11 +254,24 @@ export class EthStateStorage {
             createdAtBlock: BigInt(data.createdAtBlock.toString()),
             replacedAtBlock: BigInt(data.replacedAtBlock.toString())
         };
+        const ttl = rootInfo.replacedAtTimestamp == 0n
+            ? this._rootCacheOptions.notReplacedTtl
+            : this._rootCacheOptions.replacedTtl;
+        !this._disableCache && (await this._rootResolveCache?.set(cacheKey, rootInfo, ttl));
+        return rootInfo;
     }
     /** {@inheritdoc IStateStorage.getRpcProvider} */
     getRpcProvider() {
         return this.provider;
     }
+    /** enable caching */
+    enableCache() {
+        this._disableCache = false;
+    }
+    /** disable caching */
+    disableCache() {
+        this._disableCache = true;
+    }
     getStateContractAndProviderForId(id) {
         const idTyped = Id.fromBigInt(id);
         const chainId = getChainId(DID.blockchainFromId(idTyped), DID.networkIdFromId(idTyped));
@@ -183,4 +288,16 @@ export class EthStateStorage {
         }
         return network;
     }
+    getGistProofCacheKey(id) {
+        return `gist-${id.toString()}`;
+    }
+    getLatestStateCacheKey(id) {
+        return `latest-${id.toString()}`;
+    }
+    getStateCacheKey(id, state) {
+        return `${id.toString()}-${state.toString()}`;
+    }
+    getRootCacheKey(root) {
+        return root.toString();
+    }
 }