@0xpolygonid/js-sdk 1.5.1 → 1.6.0

package/dist/browser/umd/index.js

@@ -13760,6 +13760,54 @@ var PolygonIdSdk = (function (exports) {
         return b$5.encodeString(b);
     }
 
+    function mergeObjects(credSubject, otherCredSubject) {
+        let result = {};
+        const credSubjectKeys = Object.keys(credSubject);
+        for (const key of credSubjectKeys) {
+            if (typeof otherCredSubject[key] !== 'undefined') {
+                if (typeof credSubject[key] !== 'object' && typeof otherCredSubject[key] !== 'object') {
+                    throw new Error('Invalid query');
+                }
+                const subjectProperty = credSubject[key];
+                const otherSubjectProperty = otherCredSubject[key];
+                const propertyOperators = Object.keys(subjectProperty);
+                const subjectPropertyResult = {};
+                for (const operatorKey of propertyOperators) {
+                    if (typeof otherSubjectProperty[operatorKey] !== 'undefined') {
+                        const operatorValue1 = subjectProperty[operatorKey];
+                        const operatorValue2 = otherSubjectProperty[operatorKey];
+                        subjectPropertyResult[operatorKey] = [
+                            ...new Set([
+                                ...(subjectPropertyResult[operatorKey] ?? []),
+                                operatorValue1,
+                                ...(Array.isArray(operatorValue2) ? operatorValue2 : [operatorValue2])
+                            ])
+                        ];
+                    }
+                    else {
+                        subjectPropertyResult[operatorKey] = subjectProperty[operatorKey];
+                    }
+                }
+                result[key] = {
+                    ...otherCredSubject[key],
+                    ...subjectPropertyResult
+                };
+            }
+        }
+        // Add remaining keys from obj2
+        result = { ...credSubject, ...otherCredSubject, ...result };
+        return result;
+    }
+
+    const buildVerifierId = (address, info) => {
+        address = address.replace('0x', '');
+        const ethAddrBytes = b$5.decodeString(address);
+        const ethAddr = ethAddrBytes.slice(0, 20);
+        const genesis = O$2(ethAddr);
+        const tp = P$2(info.method, info.blockchain, info.networkId);
+        return new k$2(tp, genesis);
+    };
+
     /**
      * Provider for Sec256p1 keys256p1
      * @public
@@ -14182,6 +14230,7 @@ var PolygonIdSdk = (function (exports) {
                 mtp: this.mtp.toJSON()
             };
         }
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         static fromJSON(obj) {
             let mtp;
             if (obj?.mtp?.notEmpties && obj?.mtp?.depth && obj?.mtp?.siblings) {
@@ -14260,6 +14309,7 @@ var PolygonIdSdk = (function (exports) {
          * fromJSON is a method to deserialize BJJSignatureProof2021 from json
          * @param obj
          */
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         static fromJSON(obj) {
             return new BJJSignatureProof2021({
                 issuerData: {
@@ -14547,19 +14597,23 @@ var PolygonIdSdk = (function (exports) {
         }
         return value.toString();
     };
-    const buildQueryPath = async (contextURL, contextType, field, opts) => {
-        let resp;
-        try {
-            resp = await (await fetch(contextURL)).json();
+    const buildFieldPath = async (ldSchema, contextType, field, opts) => {
+        let path = new lf();
+        if (field) {
+            path = await lf.getContextPathKey(ldSchema, contextType, field, opts);
         }
-        catch (error) {
-            throw new Error(`context not found: ${error.message}`);
-        }
-        const path = await lf.getContextPathKey(JSON.stringify(resp), contextType, field, opts);
         path.prepend([VerifiableConstants.CREDENTIAL_SUBJECT_PATH]);
         return path;
     };
-    const createVerifiablePresentation = (context, tp, path, value) => {
+    const findValue = (fieldName, credential) => {
+        const [first, ...rest] = fieldName.split('.');
+        let v = credential.credentialSubject[first];
+        for (const part of rest) {
+            v = v[part];
+        }
+        return v;
+    };
+    const createVerifiablePresentation = (context, tp, credential, queries) => {
         const baseContext = [VerifiableConstants.JSONLD_SCHEMA.W3C_CREDENTIAL_2018];
         const ldContext = baseContext[0] === context ? baseContext : [...baseContext, context];
         const vc = VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_CREDENTIAL;
@@ -14567,36 +14621,33 @@ var PolygonIdSdk = (function (exports) {
         if (tp !== vc) {
             vcTypes.push(tp);
         }
-        const [first, ...rest] = path.split('.');
-        const obj = rest.reduceRight((acc, key) => ({ [key]: acc }), value);
-        return {
+        const skeleton = {
             '@context': baseContext,
             '@type': VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_PRESENTATION,
             verifiableCredential: {
                 '@context': ldContext,
                 '@type': vcTypes,
                 credentialSubject: {
-                    '@type': tp,
-                    [first]: obj
+                    '@type': tp
                 }
             }
         };
-    };
-    const verifiablePresentationFromCred = async (w3cCred, requestObj, field, opts) => {
-        const mz = await w3cCred.merklize(opts);
-        const request = requestObj;
-        const contextType = stringByPath(request, 'type');
-        const hasher = mz.hasher;
-        const contextURL = stringByPath(request, 'context');
-        const path = await buildQueryPath(contextURL, contextType, field, opts);
-        const dataType = await mz.jsonLDType(path);
-        const rawValue = mz.rawValue(path);
-        const { value } = await mz.proof(path);
-        const vp = createVerifiablePresentation(contextURL, contextType, field, rawValue);
-        if (!value) {
-            throw new Error(`can't merklize verifiable presentation`);
-        }
-        return { vp, mzValue: value, dataType, hasher };
+        let result = {};
+        for (const query of queries) {
+            const parts = query.fieldName.split('.');
+            const current = parts.reduceRight((acc, part) => {
+                if (result[part]) {
+                    return { [part]: { ...result[part], ...acc } };
+                }
+                return { [part]: acc };
+            }, findValue(query.fieldName, credential));
+            result = { ...result, ...current };
+        }
+        skeleton.verifiableCredential.credentialSubject = {
+            ...skeleton.verifiableCredential.credentialSubject,
+            ...result
+        };
+        return skeleton;
     };
 
     /** DIDDocumentJSONSchema is a basic schema of did document */
@@ -27671,6 +27722,13 @@ var PolygonIdSdk = (function (exports) {
             const ldCtx = await jsonld.processContext(context.getInitialContext({}), credential['@context'], opts);
             return Parser.getSerializationAttrFromParsedContext(ldCtx, tp);
         }
+        // Get `iden3_serialization` attr definition from context document either using
+        // type name like DeliverAddressMultiTestForked or by type id like
+        // urn:uuid:ac2ede19-b3b9-454d-b1a9-a7b3d5763100.
+        static async getSerializationAttrFromContext(context$1, opts, tp) {
+            const ldCtx = await jsonld.processContext(context.getInitialContext({}), context$1, opts);
+            return Parser.getSerializationAttrFromParsedContext(ldCtx, tp);
+        }
         static async getSerializationAttrFromParsedContext(ldCtx, tp) {
             const termDef = ldCtx.mappings;
             if (!termDef) {
@@ -36939,6 +36997,7 @@ var PolygonIdSdk = (function (exports) {
             const validate = (schema.$id ? validator.getSchema(schema.$id) : undefined) || validator.compile(schema);
             const valid = validate(data);
             if (!valid) {
+                // TODO: extract correct error messages
                 throw new Error(validate.errors?.map((e) => e.message).join(', '));
             }
             return true;
@@ -55288,7 +55347,7 @@ var PolygonIdSdk = (function (exports) {
     const defaultMTLevels = 40; // max MT levels, default value for identity circuits
     const defaultValueArraySize = 64; // max value array size, default value for identity circuits
     const defaultMTLevelsOnChain = 64; // max MT levels on chain, default value for identity circuits
-    const defaultMTLevelsClaimsMerklization = 32; // max MT levels of JSON-LD merklization on claim
+    const defaultMTLevelsClaim = 32; // max MT levels of JSON-LD merklization on claim
     const ErrorEmptyAuthClaimProof = 'empty auth claim mtp proof';
     const ErrorEmptyAuthClaimNonRevProof = 'empty auth claim non-revocation mtp proof';
     const ErrorEmptyChallengeSignature = 'empty challenge signature';
@@ -55314,14 +55373,12 @@ var PolygonIdSdk = (function (exports) {
             return this.mtLevel ? this.mtLevel : defaultMTLevels;
         }
         /**
-         *  getMTLevel max circuit MT levels
+         *  GetMTLevelsClaim max jsonld Claim levels
          *
          * @returns number
          */
-        getMTLevelsClaimMerklization() {
-            return this.mtLevelClaimsMerklization
-                ? this.mtLevelClaimsMerklization
-                : defaultMTLevelsClaimsMerklization;
+        getMTLevelsClaim() {
+            return this.mtLevelClaim ? this.mtLevelClaim : defaultMTLevelsClaim;
         }
         /**
          * GetValueArrSize return size of circuits value array size
@@ -55465,6 +55522,21 @@ var PolygonIdSdk = (function (exports) {
         return result;
     }
 
+    /**
+     * Represents the XSD namespace and its corresponding data types.
+     */
+    exports.XSDNS = void 0;
+    (function (XSDNS) {
+        XSDNS["Boolean"] = "http://www.w3.org/2001/XMLSchema#boolean";
+        XSDNS["Integer"] = "http://www.w3.org/2001/XMLSchema#integer";
+        XSDNS["NonNegativeInteger"] = "http://www.w3.org/2001/XMLSchema#nonNegativeInteger";
+        XSDNS["NonPositiveInteger"] = "http://www.w3.org/2001/XMLSchema#nonPositiveInteger";
+        XSDNS["NegativeInteger"] = "http://www.w3.org/2001/XMLSchema#negativeInteger";
+        XSDNS["PositiveInteger"] = "http://www.w3.org/2001/XMLSchema#positiveInteger";
+        XSDNS["DateTime"] = "http://www.w3.org/2001/XMLSchema#dateTime";
+        XSDNS["Double"] = "http://www.w3.org/2001/XMLSchema#double";
+        XSDNS["String"] = "http://www.w3.org/2001/XMLSchema#string";
+    })(exports.XSDNS || (exports.XSDNS = {}));
     /**
      * List of available operators.
      *
@@ -55479,6 +55551,11 @@ var PolygonIdSdk = (function (exports) {
         Operators[Operators["IN"] = 4] = "IN";
         Operators[Operators["NIN"] = 5] = "NIN";
         Operators[Operators["NE"] = 6] = "NE";
+        Operators[Operators["LTE"] = 7] = "LTE";
+        Operators[Operators["GTE"] = 8] = "GTE";
+        Operators[Operators["BETWEEN"] = 9] = "BETWEEN";
+        Operators[Operators["SD"] = 16] = "SD";
+        Operators[Operators["NULLIFY"] = 17] = "NULLIFY";
     })(exports.Operators || (exports.Operators = {}));
     /** QueryOperators represents operators for atomic circuits */
     const QueryOperators = {
@@ -55488,7 +55565,41 @@ var PolygonIdSdk = (function (exports) {
         $gt: exports.Operators.GT,
         $in: exports.Operators.IN,
         $nin: exports.Operators.NIN,
-        $ne: exports.Operators.NE
+        $ne: exports.Operators.NE,
+        $lte: exports.Operators.LTE,
+        $gte: exports.Operators.GTE,
+        $between: exports.Operators.BETWEEN,
+        $sd: exports.Operators.SD,
+        $nullify: exports.Operators.NULLIFY
+    };
+    const allOperations = Object.values(QueryOperators);
+    const availableTypesOperators = new Map([
+        [exports.XSDNS.Boolean, [QueryOperators.$eq, QueryOperators.$ne]],
+        [exports.XSDNS.Integer, allOperations],
+        [exports.XSDNS.NonNegativeInteger, allOperations],
+        [exports.XSDNS.PositiveInteger, allOperations],
+        [exports.XSDNS.Double, [QueryOperators.$eq, QueryOperators.$ne, QueryOperators.$in, QueryOperators.$nin]],
+        [exports.XSDNS.String, [QueryOperators.$eq, QueryOperators.$ne, QueryOperators.$in, QueryOperators.$nin]],
+        [exports.XSDNS.DateTime, allOperations]
+    ]);
+    /**
+     * Checks if the given operation is valid for the specified datatype.
+     * @param datatype - The datatype to check the operation for.
+     * @param op - The operation to check.
+     * @returns True if the operation is valid, false otherwise.
+     */
+    const isValidOperation = (datatype, op) => {
+        if (op === exports.Operators.NOOP) {
+            return true;
+        }
+        if (!availableTypesOperators.has(datatype)) {
+            return false;
+        }
+        const ops = availableTypesOperators.get(datatype);
+        if (!ops) {
+            return false;
+        }
+        return ops.includes(op);
     };
     /**
      * Scalar is used to compare two scalar value.
@@ -55600,7 +55711,9 @@ var PolygonIdSdk = (function (exports) {
          *
          */
         validate() {
-            if (this.operator !== QueryOperators.$noop && this.values?.some((v) => typeof v !== 'bigint'))
+            if (this.operator !== QueryOperators.$noop &&
+                this.operator !== QueryOperators.$sd &&
+                this.values?.some((v) => typeof v !== 'bigint'))
                 throw new Error(exports.CircuitError.EmptyQueryValue);
         }
     }
@@ -55623,6 +55736,26 @@ var PolygonIdSdk = (function (exports) {
         CircuitId["AtomicQuerySigV2"] = "credentialAtomicQuerySigV2";
         // AtomicQuerySigOnChain is a type for credentialAtomicQuerySigOnChain.circom
         CircuitId["AtomicQuerySigV2OnChain"] = "credentialAtomicQuerySigV2OnChain";
+        /**
+         * @beta
+         */
+        // AtomicQueryV3CircuitID is a type for credentialAtomicQueryV3.circom
+        CircuitId["AtomicQueryV3"] = "credentialAtomicQueryV3-beta.0";
+        /**
+         * @beta
+         */
+        // AtomicQueryV3OnChainCircuitID is a type for credentialAtomicQueryV3OnChain.circom
+        CircuitId["AtomicQueryV3OnChain"] = "credentialAtomicQueryV3OnChain-beta.0";
+        /**
+         * @beta
+         */
+        // LinkedNullifier is a type for linkedNullifier.circom
+        CircuitId["LinkedNullifier"] = "linkedNullifier-beta.0";
+        /**
+         * @beta
+         */
+        // LinkedMultiQuery is a type for linkedMultiQuery.circom
+        CircuitId["LinkedMultiQuery10"] = "linkedMultiQuery10-beta.0";
     })(exports.CircuitId || (exports.CircuitId = {}));
     /**
      * Claim structure for circuit inputs
@@ -55656,7 +55789,9 @@ var PolygonIdSdk = (function (exports) {
         CircuitError["EmptyId"] = "empty Id";
         CircuitError["EmptyChallenge"] = "empty challenge";
         CircuitError["EmptyGISTProof"] = "empty GIST merkle tree proof";
+        CircuitError["EmptyTreeState"] = "empty tree state";
         CircuitError["EmptyRequestID"] = "empty request ID";
+        CircuitError["InvalidProofType"] = "invalid proof type";
     })(exports.CircuitError || (exports.CircuitError = {}));
     /**
      * ValueProof represents a Merkle Proof for a value stored as MT
@@ -55745,7 +55880,7 @@ var PolygonIdSdk = (function (exports) {
                     .toString(),
                 issuerClaimNonRevState: this.claim.nonRevProof?.treeState?.state?.bigInt().toString(),
                 claimSchema: this.claim.claim?.getSchemaHash().bigInt().toString(),
-                claimPathMtp: prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaimMerklization()),
+                claimPathMtp: prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaim()),
                 claimPathValue: valueProof.value.toString(),
                 operator: this.query.operator,
                 slotIndex: this.query.slotIndex,
@@ -55926,7 +56061,7 @@ var PolygonIdSdk = (function (exports) {
                 issuerClaimNonRevRootsTreeRoot: this.claim.nonRevProof?.treeState?.rootOfRoots?.string(),
                 issuerClaimNonRevState: this.claim.nonRevProof?.treeState?.state?.string(),
                 claimSchema: this.claim.claim?.getSchemaHash().bigInt().toString(),
-                claimPathMtp: prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaimMerklization()),
+                claimPathMtp: prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaim()),
                 claimPathValue: valueProof.value.toString(),
                 operator: this.query.operator,
                 slotIndex: this.query.slotIndex,
@@ -56083,6 +56218,9 @@ var PolygonIdSdk = (function (exports) {
                 this.query.valueProof.validate();
             }
             const valueProof = this.query.valueProof ?? new ValueProof();
+            const treeState = this.skipClaimRevocationCheck
+                ? this.claim.signatureProof?.issuerAuthNonRevProof.treeState
+                : this.claim.nonRevProof?.treeState;
             const s = {
                 requestID: this.requestID.toString(),
                 userGenesisID: this.id.bigInt().toString(),
@@ -56090,16 +56228,10 @@ var PolygonIdSdk = (function (exports) {
                 claimSubjectProfileNonce: this.claimSubjectProfileNonce?.toString(),
                 issuerID: this.claim.issuerID?.bigInt().toString(),
                 issuerClaim: this.claim.claim?.marshalJson(),
-                issuerClaimNonRevClaimsTreeRoot: this.claim.nonRevProof?.treeState?.claimsRoot
-                    ?.bigInt()
-                    .toString(),
-                issuerClaimNonRevRevTreeRoot: this.claim.nonRevProof?.treeState?.revocationRoot
-                    ?.bigInt()
-                    .toString(),
-                issuerClaimNonRevRootsTreeRoot: this.claim.nonRevProof?.treeState?.rootOfRoots
-                    ?.bigInt()
-                    .toString(),
-                issuerClaimNonRevState: this.claim.nonRevProof?.treeState?.state?.bigInt().toString(),
+                issuerClaimNonRevClaimsTreeRoot: treeState?.claimsRoot.bigInt().toString(),
+                issuerClaimNonRevRevTreeRoot: treeState?.revocationRoot.bigInt().toString(),
+                issuerClaimNonRevRootsTreeRoot: treeState?.rootOfRoots.bigInt().toString(),
+                issuerClaimNonRevState: treeState?.state.bigInt().toString(),
                 issuerClaimNonRevMtp: this.claim.nonRevProof?.proof &&
                     prepareSiblingsStr(this.claim.nonRevProof.proof, this.getMTLevel()),
                 issuerClaimSignatureR8x: this.claim.signatureProof?.signature.R8[0].toString(),
@@ -56109,18 +56241,18 @@ var PolygonIdSdk = (function (exports) {
                 issuerAuthClaimMtp: this.claim.signatureProof?.issuerAuthIncProof?.proof &&
                     prepareSiblingsStr(this.claim.signatureProof.issuerAuthIncProof.proof, this.getMTLevel()),
                 issuerAuthClaimsTreeRoot: this.claim.signatureProof?.issuerAuthIncProof.treeState?.claimsRoot
-                    ?.bigInt()
+                    .bigInt()
                     .toString(),
                 issuerAuthRevTreeRoot: this.claim.signatureProof?.issuerAuthIncProof?.treeState?.revocationRoot
-                    ?.bigInt()
+                    .bigInt()
                     .toString(),
                 issuerAuthRootsTreeRoot: this.claim.signatureProof?.issuerAuthIncProof?.treeState?.rootOfRoots
-                    ?.bigInt()
+                    .bigInt()
                     .toString(),
                 issuerAuthClaimNonRevMtp: this.claim.signatureProof?.issuerAuthNonRevProof?.proof &&
                     prepareSiblingsStr(this.claim.signatureProof.issuerAuthNonRevProof.proof, this.getMTLevel()),
                 claimSchema: this.claim.claim?.getSchemaHash().bigInt().toString(),
-                claimPathMtp: prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaimMerklization()),
+                claimPathMtp: prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaim()),
                 claimPathValue: valueProof.value.toString(),
                 operator: this.query.operator,
                 timestamp: this.currentTimeStamp,
@@ -56250,6 +56382,581 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
+    const zero$2 = '0';
+    /**
+     * AtomicQueryV3Inputs ZK private inputs for credentialAtomicQueryV3.circom
+     *
+     * @beta
+     * @class AtomicQueryV3Inputs
+     * @extends {BaseConfig}
+     */
+    class AtomicQueryV3Inputs extends BaseConfig {
+        validate() {
+            if (!this.requestID) {
+                throw new Error(exports.CircuitError.EmptyRequestID);
+            }
+            if (!this.claim.nonRevProof.proof) {
+                throw new Error(exports.CircuitError.EmptyClaimNonRevProof);
+            }
+            if (!this.query.values) {
+                throw new Error(exports.CircuitError.EmptyQueryValue);
+            }
+            if (!this.proofType) {
+                throw new Error(exports.CircuitError.InvalidProofType);
+            }
+            if (this.proofType === exports.ProofType.BJJSignature) {
+                if (!this.claim.signatureProof?.issuerAuthIncProof.proof) {
+                    throw new Error(exports.CircuitError.EmptyIssuerAuthClaimProof);
+                }
+                if (!this.claim.signatureProof.issuerAuthNonRevProof.proof) {
+                    throw new Error(exports.CircuitError.EmptyIssuerAuthClaimNonRevProof);
+                }
+                if (!this.claim.signatureProof.signature) {
+                    throw new Error(exports.CircuitError.EmptyClaimSignature);
+                }
+            }
+            if (this.proofType === exports.ProofType.Iden3SparseMerkleTreeProof) {
+                if (!this.claim?.incProof?.proof) {
+                    throw new Error(exports.CircuitError.EmptyClaimProof);
+                }
+            }
+        }
+        fillMTPProofsWithZero(s) {
+            s.issuerClaimMtp = prepareSiblingsStr(new Kt$1(), this.getMTLevel());
+            s.issuerClaimClaimsTreeRoot = M$2.bigInt().toString();
+            s.issuerClaimRevTreeRoot = M$2.bigInt().toString();
+            s.issuerClaimRootsTreeRoot = M$2.bigInt().toString();
+            s.issuerClaimIdenState = M$2.bigInt().toString();
+        }
+        fillSigProofWithZero(s) {
+            s.issuerClaimSignatureR8x = zero$2;
+            s.issuerClaimSignatureR8y = zero$2;
+            s.issuerClaimSignatureS = zero$2;
+            s.issuerAuthClaim = new v$3().marshalJson();
+            s.issuerAuthClaimMtp = prepareSiblingsStr(new Kt$1(), this.getMTLevel());
+            s.issuerAuthClaimsTreeRoot = zero$2;
+            s.issuerAuthRevTreeRoot = zero$2;
+            s.issuerAuthRootsTreeRoot = zero$2;
+            s.issuerAuthClaimNonRevMtp = prepareSiblingsStr(new Kt$1(), this.getMTLevel());
+            s.issuerAuthClaimNonRevMtpAuxHi = M$2.bigInt().toString();
+            s.issuerAuthClaimNonRevMtpAuxHv = M$2.bigInt().toString();
+            s.issuerAuthClaimNonRevMtpNoAux = zero$2;
+            s.issuerAuthState = zero$2;
+        }
+        // InputsMarshal returns Circom private inputs for credentialAtomicQueryV3.circom
+        inputsMarshal() {
+            this.validate();
+            if (this.query.valueProof) {
+                this.query.validate();
+                this.query.valueProof.validate();
+            }
+            let valueProof = this.query.valueProof;
+            if (!valueProof) {
+                valueProof = new ValueProof();
+                valueProof.path = 0n;
+                valueProof.value = 0n;
+                valueProof.mtp = new Kt$1();
+            }
+            let treeState = this.claim.nonRevProof.treeState;
+            if (this.proofType === exports.ProofType.BJJSignature && this.skipClaimRevocationCheck) {
+                treeState = this.claim.signatureProof?.issuerAuthNonRevProof.treeState;
+            }
+            if (!treeState) {
+                throw new Error(exports.CircuitError.EmptyTreeState);
+            }
+            const s = {
+                requestID: this.requestID.toString(),
+                userGenesisID: this.id.bigInt().toString(),
+                profileNonce: this.profileNonce.toString(),
+                claimSubjectProfileNonce: this.claimSubjectProfileNonce.toString(),
+                issuerID: this.claim.issuerID.bigInt().toString(),
+                issuerClaim: this.claim.claim.marshalJson(),
+                issuerClaimNonRevClaimsTreeRoot: treeState.claimsRoot.bigInt().toString(),
+                issuerClaimNonRevRevTreeRoot: treeState.revocationRoot.bigInt().toString(),
+                issuerClaimNonRevRootsTreeRoot: treeState.rootOfRoots.bigInt().toString(),
+                issuerClaimNonRevState: treeState.state.bigInt().toString(),
+                issuerClaimNonRevMtp: prepareSiblingsStr(this.claim.nonRevProof.proof, this.getMTLevel()),
+                claimSchema: this.claim.claim.getSchemaHash().bigInt().toString(),
+                claimPathMtp: prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaim()),
+                claimPathValue: valueProof.value.toString(),
+                operator: this.query.operator,
+                timestamp: this.currentTimeStamp,
+                // value in this path in merklized json-ld document
+                slotIndex: this.query.slotIndex,
+                isRevocationChecked: 1
+            };
+            if (this.skipClaimRevocationCheck) {
+                s.isRevocationChecked = 0;
+            }
+            if (this.proofType === exports.ProofType.BJJSignature) {
+                s.proofType = '1';
+                s.issuerClaimSignatureR8x = this.claim.signatureProof?.signature.R8[0].toString();
+                s.issuerClaimSignatureR8y = this.claim.signatureProof?.signature.R8[1].toString();
+                s.issuerClaimSignatureS = this.claim.signatureProof?.signature.S.toString();
+                s.issuerAuthClaim = this.claim.signatureProof?.issuerAuthClaim?.marshalJson();
+                s.issuerAuthClaimMtp = prepareSiblingsStr(this.claim.signatureProof?.issuerAuthIncProof.proof, this.getMTLevel());
+                s.issuerAuthClaimsTreeRoot = treeState.claimsRoot.bigInt().toString();
+                s.issuerAuthRevTreeRoot = treeState.revocationRoot.bigInt().toString();
+                s.issuerAuthRootsTreeRoot = treeState.rootOfRoots.bigInt().toString();
+                s.issuerAuthClaimNonRevMtp = prepareSiblingsStr(this.claim.signatureProof?.issuerAuthNonRevProof.proof, this.getMTLevel());
+                const nodeAuxIssuerAuthNonRev = getNodeAuxValue(this.claim.signatureProof?.issuerAuthNonRevProof.proof);
+                s.issuerAuthClaimNonRevMtpAuxHi = nodeAuxIssuerAuthNonRev.key.bigInt().toString();
+                s.issuerAuthClaimNonRevMtpAuxHv = nodeAuxIssuerAuthNonRev.value.bigInt().toString();
+                s.issuerAuthClaimNonRevMtpNoAux = nodeAuxIssuerAuthNonRev.noAux;
+                s.issuerAuthState = this.claim.signatureProof?.issuerAuthIncProof.treeState?.state
+                    .bigInt()
+                    .toString();
+                this.fillMTPProofsWithZero(s);
+            }
+            else if (this.proofType === exports.ProofType.Iden3SparseMerkleTreeProof) {
+                s.proofType = '2';
+                const incProofTreeState = this.claim.incProof?.treeState;
+                if (!incProofTreeState) {
+                    throw new Error(exports.CircuitError.EmptyTreeState);
+                }
+                s.issuerClaimMtp = prepareSiblingsStr(this.claim.incProof?.proof, this.getMTLevel());
+                s.issuerClaimClaimsTreeRoot = incProofTreeState.claimsRoot.bigInt().toString();
+                s.issuerClaimRevTreeRoot = incProofTreeState.revocationRoot.bigInt().toString();
+                s.issuerClaimRootsTreeRoot = incProofTreeState.rootOfRoots.bigInt().toString();
+                s.issuerClaimIdenState = incProofTreeState.state.bigInt().toString();
+                this.fillSigProofWithZero(s);
+            }
+            const nodeAuxNonRev = getNodeAuxValue(this.claim.nonRevProof.proof);
+            s.issuerClaimNonRevMtpAuxHi = nodeAuxNonRev.key.bigInt().toString();
+            s.issuerClaimNonRevMtpAuxHv = nodeAuxNonRev.value.bigInt().toString();
+            s.issuerClaimNonRevMtpNoAux = nodeAuxNonRev.noAux;
+            s.claimPathNotExists = existenceToInt(valueProof.mtp.existence);
+            const nodAuxJSONLD = getNodeAuxValue(valueProof.mtp);
+            s.claimPathMtpNoAux = nodAuxJSONLD.noAux;
+            s.claimPathMtpAuxHi = nodAuxJSONLD.key.bigInt().toString();
+            s.claimPathMtpAuxHv = nodAuxJSONLD.value.bigInt().toString();
+            s.claimPathKey = valueProof.path.toString();
+            const values = prepareCircuitArrayValues(this.query.values, this.getValueArrSize());
+            s.value = bigIntArrayToStringArray(values);
+            s.linkNonce = this.linkNonce.toString();
+            s.verifierID = this.verifierID?.bigInt().toString() ?? '0';
+            s.nullifierSessionID = this.nullifierSessionID.toString();
+            return byteEncoder.encode(JSON.stringify(s));
+        }
+    }
+    /**
+     * @beta
+     * AtomicQueryV3PubSignals public inputs
+     */
+    class AtomicQueryV3PubSignals extends BaseConfig {
+        constructor() {
+            super(...arguments);
+            this.value = [];
+        }
+        // PubSignalsUnmarshal unmarshal credentialAtomicQueryV3.circom public signals
+        pubSignalsUnmarshal(data) {
+            // expected order:
+            // merklized
+            // userID
+            // issuerState
+            // linkID
+            // nullifier
+            // operatorOutput
+            // proofType
+            // requestID
+            // issuerID
+            // isRevocationChecked
+            // issuerClaimNonRevState
+            // timestamp
+            // claimSchema
+            // claimPathNotExists
+            // claimPathKey
+            // slotIndex
+            // operator
+            // value
+            // verifierID
+            // nullifierSessionID
+            // 19 is a number of fields in AtomicQueryV3PubSignals before values, values is last element in the proof and
+            // it is length could be different base on the circuit configuration. The length could be modified by set value
+            // in ValueArraySize
+            const fieldLength = 19;
+            const sVals = JSON.parse(byteDecoder.decode(data));
+            if (sVals.length !== fieldLength + this.getValueArrSize()) {
+                throw new Error(`invalid number of Output values expected ${fieldLength + this.getValueArrSize()} got ${sVals.length}`);
+            }
+            let fieldIdx = 0;
+            // -- merklized
+            this.merklized = parseInt(sVals[fieldIdx]);
+            fieldIdx++;
+            //  - userID
+            this.userID = k$2.fromBigInt(BigInt(sVals[fieldIdx]));
+            fieldIdx++;
+            // - issuerState
+            this.issuerState = V$1.fromString(sVals[fieldIdx]);
+            fieldIdx++;
+            // - linkID
+            this.linkID = BigInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - nullifier
+            this.nullifier = BigInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - operatorOutput
+            this.operatorOutput = BigInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - proofType
+            this.proofType = parseInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - requestID
+            this.requestID = BigInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - issuerID
+            this.issuerID = k$2.fromBigInt(BigInt(sVals[fieldIdx]));
+            fieldIdx++;
+            // - isRevocationChecked
+            this.isRevocationChecked = parseInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - issuerClaimNonRevState
+            this.issuerClaimNonRevState = V$1.fromString(sVals[fieldIdx]);
+            fieldIdx++;
+            //  - timestamp
+            this.timestamp = parseInt(sVals[fieldIdx]);
+            fieldIdx++;
+            //  - claimSchema
+            this.claimSchema = B$3.newSchemaHashFromInt(BigInt(sVals[fieldIdx]));
+            fieldIdx++;
+            // - ClaimPathNotExists
+            this.claimPathNotExists = parseInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - ClaimPathKey
+            this.claimPathKey = BigInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - slotIndex
+            this.slotIndex = parseInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - operator
+            this.operator = parseInt(sVals[fieldIdx]);
+            fieldIdx++;
+            //  - values
+            for (let index = 0; index < this.getValueArrSize(); index++) {
+                this.value.push(BigInt(sVals[fieldIdx]));
+                fieldIdx++;
+            }
+            // - verifierID
+            if (sVals[fieldIdx] !== '0') {
+                this.verifierID = k$2.fromBigInt(BigInt(sVals[fieldIdx]));
+            }
+            fieldIdx++;
+            // - nullifierSessionID
+            this.nullifierSessionID = BigInt(sVals[fieldIdx]);
+            return this;
+        }
+    }
+
+    const zero$1 = '0';
+    /**
+     * AtomicQueryV3OnChainInputs ZK private inputs for credentialAtomicQueryV3OnChain.circom
+     *
+     * @beta
+     * @class AtomicQueryV3OnChainInputs
+     * @extends {BaseConfig}
+     */
+    class AtomicQueryV3OnChainInputs extends BaseConfig {
+        validate() {
+            if (!this.requestID) {
+                throw new Error(exports.CircuitError.EmptyRequestID);
+            }
+            if (!this.claim.nonRevProof.proof) {
+                throw new Error(exports.CircuitError.EmptyClaimNonRevProof);
+            }
+            if (!this.query.values) {
+                throw new Error(exports.CircuitError.EmptyQueryValue);
+            }
+            if (!this.proofType) {
+                throw new Error(exports.CircuitError.InvalidProofType);
+            }
+            if (!this.challenge) {
+                throw new Error(exports.CircuitError.EmptyChallenge);
+            }
+            if (this.authEnabled === 1) {
+                if (!this.authClaimIncMtp) {
+                    throw new Error(exports.CircuitError.EmptyAuthClaimProof);
+                }
+                if (!this.authClaimNonRevMtp) {
+                    throw new Error(exports.CircuitError.EmptyAuthClaimNonRevProof);
+                }
+                if (!this.signature) {
+                    throw new Error(exports.CircuitError.EmptyChallengeSignature);
+                }
+                if (!this.gistProof.proof) {
+                    throw new Error(exports.CircuitError.EmptyGISTProof);
+                }
+            }
+            if (this.proofType === exports.ProofType.BJJSignature) {
+                if (!this.claim.signatureProof?.issuerAuthIncProof.proof) {
+                    throw new Error(exports.CircuitError.EmptyIssuerAuthClaimProof);
+                }
+                if (!this.claim.signatureProof.issuerAuthNonRevProof.proof) {
+                    throw new Error(exports.CircuitError.EmptyIssuerAuthClaimNonRevProof);
+                }
+                if (!this.claim.signatureProof.signature) {
+                    throw new Error(exports.CircuitError.EmptyClaimSignature);
+                }
+            }
+            if (this.proofType === exports.ProofType.Iden3SparseMerkleTreeProof) {
+                if (!this.claim?.incProof?.proof) {
+                    throw new Error(exports.CircuitError.EmptyClaimProof);
+                }
+            }
+        }
+        fillMTPProofsWithZero(s) {
+            s.issuerClaimMtp = prepareSiblingsStr(new Kt$1(), this.getMTLevel());
+            s.issuerClaimClaimsTreeRoot = M$2.bigInt().toString();
+            s.issuerClaimRevTreeRoot = M$2.bigInt().toString();
+            s.issuerClaimRootsTreeRoot = M$2.bigInt().toString();
+            s.issuerClaimIdenState = M$2.bigInt().toString();
+        }
+        fillSigProofWithZero(s) {
+            s.issuerClaimSignatureR8x = zero$1;
+            s.issuerClaimSignatureR8y = zero$1;
+            s.issuerClaimSignatureS = zero$1;
+            s.issuerAuthClaim = new v$3().marshalJson();
+            s.issuerAuthClaimMtp = prepareSiblingsStr(new Kt$1(), this.getMTLevel());
+            s.issuerAuthClaimsTreeRoot = zero$1;
+            s.issuerAuthRevTreeRoot = zero$1;
+            s.issuerAuthRootsTreeRoot = zero$1;
+            s.issuerAuthClaimNonRevMtp = prepareSiblingsStr(new Kt$1(), this.getMTLevel());
+            s.issuerAuthClaimNonRevMtpAuxHi = M$2.bigInt().toString();
+            s.issuerAuthClaimNonRevMtpAuxHv = M$2.bigInt().toString();
+            s.issuerAuthClaimNonRevMtpNoAux = zero$1;
+            s.issuerAuthState = zero$1;
+        }
+        fillAuthWithZero(s) {
+            s.authClaim = new v$3().marshalJson();
+            s.userClaimsTreeRoot = M$2.bigInt().toString();
+            s.userRevTreeRoot = M$2.bigInt().toString();
+            s.userRootsTreeRoot = M$2.bigInt().toString();
+            s.userState = M$2.bigInt().toString();
+            s.authClaimIncMtp = prepareSiblingsStr(new Kt$1(), this.getMTLevel());
+            s.authClaimNonRevMtp = prepareSiblingsStr(new Kt$1(), this.getMTLevel());
+            s.challengeSignatureR8x = zero$1;
+            s.challengeSignatureR8y = zero$1;
+            s.challengeSignatureS = zero$1;
+            s.gistRoot = M$2.bigInt().toString();
+            s.gistMtp = prepareSiblingsStr(new Kt$1(), this.getMTLevelOnChain());
+            s.authClaimNonRevMtpAuxHi = M$2.bigInt().toString();
+            s.authClaimNonRevMtpAuxHv = M$2.bigInt().toString();
+            s.authClaimNonRevMtpNoAux = zero$1;
+            s.gistMtpAuxHi = M$2.bigInt().toString();
+            s.gistMtpAuxHv = M$2.bigInt().toString();
+            s.gistMtpNoAux = zero$1;
+        }
+        // InputsMarshal returns Circom private inputs for credentialAtomicQueryV3OnChain.circom
+        inputsMarshal() {
+            this.validate();
+            if (this.query.valueProof) {
+                this.query.validate();
+                this.query.valueProof.validate();
+            }
+            let valueProof = this.query.valueProof;
+            if (!valueProof) {
+                valueProof = new ValueProof();
+                valueProof.path = 0n;
+                valueProof.value = 0n;
+                valueProof.mtp = new Kt$1();
+            }
+            const treeState = this.claim.nonRevProof.treeState;
+            if (!treeState) {
+                throw new Error(exports.CircuitError.EmptyTreeState);
+            }
+            const s = {
+                requestID: this.requestID.toString(),
+                userGenesisID: this.id.bigInt().toString(),
+                profileNonce: this.profileNonce.toString(),
+                claimSubjectProfileNonce: this.claimSubjectProfileNonce.toString(),
+                issuerID: this.claim.issuerID.bigInt().toString(),
+                issuerClaim: this.claim.claim.marshalJson(),
+                issuerClaimNonRevClaimsTreeRoot: treeState.claimsRoot.bigInt().toString(),
+                issuerClaimNonRevRevTreeRoot: treeState.revocationRoot.bigInt().toString(),
+                issuerClaimNonRevRootsTreeRoot: treeState.rootOfRoots.bigInt().toString(),
+                issuerClaimNonRevState: treeState.state.bigInt().toString(),
+                issuerClaimNonRevMtp: prepareSiblingsStr(this.claim.nonRevProof.proof, this.getMTLevel()),
+                claimSchema: this.claim.claim.getSchemaHash().bigInt().toString(),
+                claimPathMtp: prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaim()),
+                claimPathValue: valueProof.value.toString(),
+                operator: this.query.operator,
+                timestamp: this.currentTimeStamp,
+                // value in this path in merklized json-ld document
+                slotIndex: this.query.slotIndex,
+                isRevocationChecked: 1
+            };
+            s.challenge = this.challenge?.toString();
+            if (this.authEnabled === 1) {
+                s.authClaim = this.authClaim?.marshalJson();
+                s.userClaimsTreeRoot = this.treeState.claimsRoot?.bigInt().toString();
+                s.userRevTreeRoot = this.treeState.revocationRoot?.bigInt().toString();
+                s.userRootsTreeRoot = this.treeState.rootOfRoots?.bigInt().toString();
+                s.userState = this.treeState.state?.bigInt().toString();
+                s.authClaimIncMtp = prepareSiblingsStr(this.authClaimIncMtp, this.getMTLevel());
+                s.authClaimNonRevMtp = prepareSiblingsStr(this.authClaimNonRevMtp, this.getMTLevel());
+                s.challengeSignatureR8x = this.signature.R8[0].toString();
+                s.challengeSignatureR8y = this.signature.R8[1].toString();
+                s.challengeSignatureS = this.signature.S.toString();
+                s.gistMtp =
+                    this.gistProof && prepareSiblingsStr(this.gistProof.proof, this.getMTLevelOnChain());
+                const nodeAuxAuth = getNodeAuxValue(this.authClaimNonRevMtp);
+                s.authClaimNonRevMtpAuxHi = nodeAuxAuth.key.bigInt().toString();
+                s.authClaimNonRevMtpAuxHv = nodeAuxAuth.value.bigInt().toString();
+                s.authClaimNonRevMtpNoAux = nodeAuxAuth.noAux;
+                const globalNodeAux = getNodeAuxValue(this.gistProof.proof);
+                s.gistMtpAuxHi = globalNodeAux.key.bigInt().toString();
+                s.gistMtpAuxHv = globalNodeAux.value.bigInt().toString();
+                s.gistMtpNoAux = globalNodeAux.noAux;
+                s.gistRoot = this.gistProof.root.bigInt().toString();
+            }
+            else {
+                this.fillAuthWithZero(s);
+            }
+            if (this.skipClaimRevocationCheck) {
+                s.isRevocationChecked = 0;
+            }
+            if (this.proofType === exports.ProofType.BJJSignature) {
+                s.proofType = '1';
+                s.issuerClaimSignatureR8x = this.claim.signatureProof?.signature.R8[0].toString();
+                s.issuerClaimSignatureR8y = this.claim.signatureProof?.signature.R8[1].toString();
+                s.issuerClaimSignatureS = this.claim.signatureProof?.signature.S.toString();
+                s.issuerAuthClaim = this.claim.signatureProof?.issuerAuthClaim?.marshalJson();
+                s.issuerAuthClaimMtp = prepareSiblingsStr(this.claim.signatureProof?.issuerAuthIncProof.proof, this.getMTLevel());
+                const issuerAuthTreeState = this.claim.nonRevProof.treeState;
+                if (!issuerAuthTreeState) {
+                    throw new Error(exports.CircuitError.EmptyTreeState);
+                }
+                s.issuerAuthClaimsTreeRoot = issuerAuthTreeState.claimsRoot.bigInt().toString();
+                s.issuerAuthRevTreeRoot = issuerAuthTreeState.revocationRoot.bigInt().toString();
+                s.issuerAuthRootsTreeRoot = issuerAuthTreeState.rootOfRoots.bigInt().toString();
+                s.issuerAuthClaimNonRevMtp = prepareSiblingsStr(this.claim.signatureProof?.issuerAuthNonRevProof.proof, this.getMTLevel());
+                const nodeAuxIssuerAuthNonRev = getNodeAuxValue(this.claim.signatureProof?.issuerAuthNonRevProof.proof);
+                s.issuerAuthClaimNonRevMtpAuxHi = nodeAuxIssuerAuthNonRev.key.bigInt().toString();
+                s.issuerAuthClaimNonRevMtpAuxHv = nodeAuxIssuerAuthNonRev.value.bigInt().toString();
+                s.issuerAuthClaimNonRevMtpNoAux = nodeAuxIssuerAuthNonRev.noAux;
+                s.issuerAuthState = this.claim.signatureProof?.issuerAuthIncProof.treeState?.state
+                    .bigInt()
+                    .toString();
+                this.fillMTPProofsWithZero(s);
+            }
+            else if (this.proofType === exports.ProofType.Iden3SparseMerkleTreeProof) {
+                s.proofType = '2';
+                const incProofTreeState = this.claim.incProof?.treeState;
+                if (!incProofTreeState) {
+                    throw new Error(exports.CircuitError.EmptyTreeState);
+                }
+                s.issuerClaimMtp = prepareSiblingsStr(this.claim.incProof?.proof, this.getMTLevel());
+                s.issuerClaimClaimsTreeRoot = incProofTreeState.claimsRoot.bigInt().toString();
+                s.issuerClaimRevTreeRoot = incProofTreeState.revocationRoot.bigInt().toString();
+                s.issuerClaimRootsTreeRoot = incProofTreeState.rootOfRoots.bigInt().toString();
+                s.issuerClaimIdenState = incProofTreeState.state.bigInt().toString();
+                this.fillSigProofWithZero(s);
+            }
+            const nodeAuxNonRev = getNodeAuxValue(this.claim.nonRevProof.proof);
+            s.issuerClaimNonRevMtpAuxHi = nodeAuxNonRev.key.bigInt().toString();
+            s.issuerClaimNonRevMtpAuxHv = nodeAuxNonRev.value.bigInt().toString();
+            s.issuerClaimNonRevMtpNoAux = nodeAuxNonRev.noAux;
+            s.claimPathNotExists = existenceToInt(valueProof.mtp.existence);
+            const nodAuxJSONLD = getNodeAuxValue(valueProof.mtp);
+            s.claimPathMtpNoAux = nodAuxJSONLD.noAux;
+            s.claimPathMtpAuxHi = nodAuxJSONLD.key.bigInt().toString();
+            s.claimPathMtpAuxHv = nodAuxJSONLD.value.bigInt().toString();
+            s.claimPathKey = valueProof.path.toString();
+            const values = prepareCircuitArrayValues(this.query.values, this.getValueArrSize());
+            s.value = bigIntArrayToStringArray(values);
+            s.linkNonce = this.linkNonce.toString();
+            s.verifierID = this.verifierID?.bigInt().toString() ?? '0';
+            s.nullifierSessionID = this.nullifierSessionID.toString();
+            s.authEnabled = this.authEnabled.toString();
+            return byteEncoder.encode(JSON.stringify(s));
+        }
+    }
+    /**
+     * @beta
+     * AtomicQueryV3OnChainPubSignals public inputs
+     */
+    class AtomicQueryV3OnChainPubSignals extends BaseConfig {
+        // PubSignalsUnmarshal unmarshal credentialAtomicQueryV3.circom public signals
+        pubSignalsUnmarshal(data) {
+            // expected order:
+            // merklized
+            // userID
+            // circuitQueryHash
+            // issuerState
+            // linkID
+            // nullifier
+            // operatorOutput
+            // proofType
+            // requestID
+            // challenge
+            // gistRoot
+            // issuerID
+            // isRevocationChecked
+            // issuerClaimNonRevState
+            // timestamp
+            // verifierID
+            // nullifierSessionID
+            // authEnabled
+            const sVals = JSON.parse(byteDecoder.decode(data));
+            let fieldIdx = 0;
+            // -- merklized
+            this.merklized = parseInt(sVals[fieldIdx]);
+            fieldIdx++;
+            //  - userID
+            this.userID = k$2.fromBigInt(BigInt(sVals[fieldIdx]));
+            fieldIdx++;
+            // - circuitQueryHash
+            this.circuitQueryHash = BigInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - issuerState
+            this.issuerState = V$1.fromString(sVals[fieldIdx]);
+            fieldIdx++;
+            // - linkID
+            this.linkID = BigInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - nullifier
+            this.nullifier = BigInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - operatorOutput
+            this.operatorOutput = BigInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - proofType
+            this.proofType = parseInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - requestID
+            this.requestID = BigInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - challenge
+            this.challenge = BigInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - gistRoot
+            this.gistRoot = V$1.fromString(sVals[fieldIdx]);
+            fieldIdx++;
+            // - issuerID
+            this.issuerID = k$2.fromBigInt(BigInt(sVals[fieldIdx]));
+            fieldIdx++;
+            // - isRevocationChecked
+            this.isRevocationChecked = parseInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - issuerClaimNonRevState
+            this.issuerClaimNonRevState = V$1.fromString(sVals[fieldIdx]);
+            fieldIdx++;
+            //  - timestamp
+            this.timestamp = parseInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - verifierID
+            if (sVals[fieldIdx] !== '0') {
+                this.verifierID = k$2.fromBigInt(BigInt(sVals[fieldIdx]));
+            }
+            fieldIdx++;
+            // - nullifierSessionID
+            this.nullifierSessionID = BigInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - authEnabled
+            this.authEnabled = parseInt(sVals[fieldIdx]);
+            return this;
+        }
+    }
+
     /**
      * AtomicQuerySigV2OnChainInputs ZK private inputs for credentialAtomicQuerySig.circom
      *
@@ -56347,9 +57054,9 @@ var PolygonIdSdk = (function (exports) {
                 issuerAuthClaimNonRevMtp: this.claim.signatureProof?.issuerAuthNonRevProof?.proof &&
                     prepareSiblingsStr(this.claim.signatureProof.issuerAuthNonRevProof.proof, this.getMTLevel()),
                 claimSchema: this.claim.claim?.getSchemaHash().bigInt().toString(),
-                claimPathMtp: prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaimMerklization()),
+                claimPathMtp: prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaim()),
                 claimPathValue: valueProof.value.toString(),
-                operator: this.query?.operator,
+                operator: this.query.operator,
                 timestamp: this.currentTimeStamp,
                 // value in this path in merklized json-ld document
                 slotIndex: this.query?.slotIndex,
@@ -56645,6 +57352,179 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
+    /**
+     * LinkedNullifier circuit representation
+     * Inputs and public signals declaration, marshalling and parsing
+     *
+     * @beta
+     * @class LinkedNullifierInputs
+     */
+    class LinkedNullifierInputs {
+        // InputsMarshal returns Circom private inputs for nullifier.circom
+        inputsMarshal() {
+            const s = {
+                linkNonce: this.linkNonce.toString(),
+                issuerClaim: this.issuerClaim.marshalJson(),
+                userGenesisID: this.id.bigInt().toString(),
+                claimSubjectProfileNonce: this.claimSubjectProfileNonce.toString(),
+                claimSchema: this.issuerClaim.getSchemaHash().bigInt().toString(),
+                verifierID: this.verifierID?.bigInt().toString() ?? '0',
+                nullifierSessionID: this.nullifierSessionID.toString()
+            };
+            return byteEncoder.encode(JSON.stringify(s));
+        }
+    }
+    // LinkedNullifierPubSignals nullifier.circom public signals
+    /**
+     * public signals
+     *
+     * @beta
+     * @class LinkedNullifierPubSignals
+     */
+    class LinkedNullifierPubSignals {
+        /**
+         * PubSignalsUnmarshal unmarshal nullifier.circom public inputs to LinkedNullifierPubSignals
+         *
+         * @beta
+         * @param {Uint8Array} data
+         * @returns LinkedNullifierPubSignals
+         */
+        pubSignalsUnmarshal(data) {
+            const len = 4;
+            const sVals = JSON.parse(byteDecoder.decode(data));
+            if (sVals.length !== len) {
+                throw new Error(`invalid number of Output values expected ${len} got ${sVals.length}`);
+            }
+            this.nullifier = BigInt(sVals[0]);
+            this.linkID = BigInt(sVals[1]);
+            this.verifierID = k$2.fromBigInt(BigInt(sVals[2]));
+            this.nullifierSessionID = BigInt(sVals[3]);
+            return this;
+        }
+    }
+
+    /**
+     * LinkedMultiQuery circuit representation
+     * Inputs and public signals declaration, marshalling and parsing
+     *
+     * @beta
+     * @class LinkedMultiQueryInputs
+     */
+    class LinkedMultiQueryInputs extends BaseConfig {
+        // InputsMarshal returns Circom private inputs for linkedMultiQueryInputs.circom
+        inputsMarshal() {
+            const enabled = [];
+            const claimPathNotExists = [];
+            const claimPathMtp = [];
+            const claimPathMtpNoAux = [];
+            const claimPathMtpAuxHi = [];
+            const claimPathMtpAuxHv = [];
+            const claimPathKey = [];
+            const claimPathValue = [];
+            const slotIndex = [];
+            const operator = [];
+            const value = [];
+            for (let i = 0; i < this.queryLength; i++) {
+                if (!this.query) {
+                    enabled.push(0);
+                    claimPathNotExists.push(0);
+                    claimPathMtp.push([]);
+                    claimPathMtpNoAux.push('0');
+                    claimPathMtpAuxHi.push('0');
+                    claimPathMtpAuxHv.push('0');
+                    claimPathKey.push('0');
+                    claimPathValue.push('0');
+                    slotIndex.push(0);
+                    operator.push(0);
+                    const valuesArr = prepareCircuitArrayValues([], this.getValueArrSize());
+                    value.push(bigIntArrayToStringArray(valuesArr));
+                    continue;
+                }
+                enabled.push(1);
+                const valueProof = this.query[i].valueProof;
+                claimPathNotExists.push(existenceToInt(valueProof.mtp.existence));
+                claimPathMtp.push(prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaim()));
+                const nodAuxJSONLD = getNodeAuxValue(valueProof.mtp);
+                claimPathMtpNoAux.push(nodAuxJSONLD.noAux);
+                claimPathMtpAuxHi.push(nodAuxJSONLD.key.bigInt().toString());
+                claimPathMtpAuxHv.push(nodAuxJSONLD.value.bigInt().toString());
+                claimPathKey.push(valueProof.path.toString());
+                claimPathValue.push(valueProof.value.toString());
+                slotIndex.push(this.query[i].slotIndex);
+                operator.push(this.query[i].operator);
+                const valuesArr = prepareCircuitArrayValues(this.query[i].values, this.getValueArrSize());
+                value.push(bigIntArrayToStringArray(valuesArr));
+            }
+            const s = {
+                linkNonce: this.linkNonce.toString(),
+                issuerClaim: this.claim.marshalJson(),
+                enabled,
+                claimSchema: this.claim.getSchemaHash().bigInt().toString(),
+                claimPathNotExists,
+                claimPathMtp,
+                claimPathMtpNoAux,
+                claimPathMtpAuxHi,
+                claimPathMtpAuxHv,
+                claimPathKey,
+                claimPathValue,
+                slotIndex,
+                operator,
+                value
+            };
+            return byteEncoder.encode(JSON.stringify(s));
+        }
+    }
+    // LinkedMultiQueryPubSignals linkedMultiQuery.circom public signals
+    /**
+     * public signals
+     *
+     * @beta
+     * @class LinkedMultiQueryPubSignals
+     */
+    class LinkedMultiQueryPubSignals {
+        /**
+         * PubSignalsUnmarshal unmarshal linkedMultiQuery.circom public inputs to LinkedMultiQueryPubSignals
+         *
+         * @beta
+         * @param {Uint8Array} data
+         * @returns LinkedMultiQueryPubSignals
+         */
+        pubSignalsUnmarshal(data, queryLength) {
+            const len = queryLength * 3 + 2;
+            const sVals = JSON.parse(byteDecoder.decode(data));
+            if (sVals.length !== len) {
+                throw new Error(`invalid number of Output values expected ${len} got ${sVals.length}`);
+            }
+            let fieldIdx = 0;
+            // -- linkID
+            this.linkID = BigInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // -- merklized
+            this.merklized = parseInt(sVals[fieldIdx]);
+            fieldIdx++;
+            // - operatorOutput
+            this.operatorOutput = [];
+            for (let i = 0; i < queryLength; i++) {
+                this.operatorOutput.push(BigInt(sVals[fieldIdx]));
+                fieldIdx++;
+            }
+            // - circuitQueryHash
+            this.circuitQueryHash = [];
+            for (let i = 0; i < queryLength; i++) {
+                this.circuitQueryHash.push(BigInt(sVals[fieldIdx]));
+                fieldIdx++;
+            }
+            // - enabled
+            this.enabled = [];
+            for (let i = 0; i < queryLength; i++) {
+                const enabledNum = parseInt(sVals[fieldIdx]);
+                this.enabled.push(enabledNum === 1);
+                fieldIdx++;
+            }
+            return this;
+        }
+    }
+
     var abi$1 = [
     	{
     		inputs: [
@@ -58399,6 +59279,25 @@ var PolygonIdSdk = (function (exports) {
         };
     }
 
+    /**
+     * Retrieves the user DID from a given credential.
+     * If the credential does not have a credentialSubject.id property, the issuer DID is returned.
+     * If the credentialSubject.id is not a string, an error is thrown.
+     * @param issuerDID The DID of the issuer.
+     * @param credential The credential object.
+     * @returns The user DID parsed from the credential.
+     * @throws Error if the credentialSubject.id is not a string.
+     */
+    const getUserDIDFromCredential = (issuerDID, credential) => {
+        if (!credential.credentialSubject.id) {
+            return issuerDID;
+        }
+        if (typeof credential.credentialSubject.id !== 'string') {
+            throw new Error('credential subject `id` is not a string');
+        }
+        return W$3.parse(credential.credentialSubject.id);
+    };
+
     // ErrAllClaimsRevoked all claims are revoked.
     const ErrAllClaimsRevoked = 'all claims are revoked';
     /**
@@ -58494,16 +59393,7 @@ var PolygonIdSdk = (function (exports) {
                 ? mtpProof.issuerData.state
                 : sigProof?.issuerData.state;
             const issuerDID = W$3.parse(cred.issuer);
-            let userDID;
-            if (!cred.credentialSubject.id) {
-                userDID = issuerDID;
-            }
-            else {
-                if (typeof cred.credentialSubject.id !== 'string') {
-                    throw new Error('credential status `id` is not a string');
-                }
-                userDID = W$3.parse(cred.credentialSubject.id);
-            }
+            const userDID = getUserDIDFromCredential(issuerDID, cred);
             const opts = {
                 issuerGenesisState: stateInfo,
                 issuerDID,
@@ -59546,6 +60436,17 @@ var PolygonIdSdk = (function (exports) {
     const truthyValues = [true, 1, 'true'];
     const falsyValues = [false, 0, 'false'];
     const equalsComparator = (a, b) => {
+        if (Array.isArray(a) && Array.isArray(b)) {
+            return (a.length === b.length && a.every((val, index) => val === b[index]));
+        }
+        if (!Array.isArray(a) && Array.isArray(b)) {
+            return b.includes(a);
+        }
+        if (Array.isArray(a) && !Array.isArray(b)) {
+            return a.includes(b);
+        }
+        a = a;
+        b = b;
         if (truthyValues.includes(a) && truthyValues.includes(b)) {
             return true;
         }
@@ -59554,14 +60455,65 @@ var PolygonIdSdk = (function (exports) {
         }
         return a === b;
     };
+    const greaterThan = (a, b) => {
+        if (Array.isArray(a) && Array.isArray(b)) {
+            return a.every((val, index) => val > b[index]);
+        }
+        if (!Array.isArray(a) && Array.isArray(b)) {
+            return b.every((val) => a > val);
+        }
+        if (Array.isArray(a) && !Array.isArray(b)) {
+            return a.every((val) => val > b);
+        }
+        return a > b;
+    };
+    const greaterThanOrEqual = (a, b) => {
+        if (Array.isArray(a) && Array.isArray(b)) {
+            return a.every((val, index) => val >= b[index]);
+        }
+        if (!Array.isArray(a) && Array.isArray(b)) {
+            return b.every((val) => a >= val);
+        }
+        if (Array.isArray(a) && !Array.isArray(b)) {
+            return a.every((val) => val >= b);
+        }
+        return a >= b;
+    };
+    const lessThanOrEqual = (a, b) => {
+        if (Array.isArray(a) && Array.isArray(b)) {
+            return a.every((val, index) => val <= b[index]);
+        }
+        if (!Array.isArray(a) && Array.isArray(b)) {
+            return b.every((val) => a <= val);
+        }
+        if (Array.isArray(a) && !Array.isArray(b)) {
+            return a.every((val) => val <= b);
+        }
+        return a <= b;
+    };
+    const inOperator = (a, b) => {
+        if (Array.isArray(a) && Array.isArray(b)) {
+            return a.every((val) => b.includes(val));
+        }
+        if (!Array.isArray(a) && Array.isArray(b)) {
+            return b.includes(a);
+        }
+        if (Array.isArray(a) && !Array.isArray(b)) {
+            return a.includes(b);
+        }
+        return false;
+    };
     const comparatorOptions = {
         $noop: () => true,
+        $sd: () => true,
         $eq: (a, b) => equalsComparator(a, b),
-        $in: (a, b) => b.includes(a),
-        $nin: (a, b) => !b.includes(a),
-        $gt: (a, b) => a > b,
-        $lt: (a, b) => a < b,
-        $ne: (a, b) => !equalsComparator(a, b)
+        $in: (a, b) => inOperator(a, b),
+        $nin: (a, b) => !inOperator(a, b),
+        $gt: (a, b) => greaterThan(a, b),
+        $lt: (a, b) => !greaterThan(a, b),
+        $ne: (a, b) => !equalsComparator(a, b),
+        $gte: (a, b) => greaterThanOrEqual(a, b),
+        $lte: (a, b) => lessThanOrEqual(a, b)
     };
     /**
      * credential search path resolver
@@ -59645,8 +60597,6 @@ var PolygonIdSdk = (function (exports) {
                     return acc.concat(new FilterQuery('credentialSubject.id', comparatorOptions.$eq, queryValue));
                 case 'schema':
                     return acc.concat(new FilterQuery('credentialSchema.id', comparatorOptions.$eq, queryValue));
-                case 'skipClaimRevocationCheck':
-                    return acc;
                 case 'credentialSubject': {
                     const reqFilters = Object.keys(queryValue).reduce((acc, fieldKey) => {
                         const fieldParams = queryValue[fieldKey];
@@ -59664,8 +60614,13 @@ var PolygonIdSdk = (function (exports) {
                     }, []);
                     return acc.concat(reqFilters);
                 }
+                case 'proofType':
+                case 'groupId':
+                case 'skipClaimRevocationCheck': {
+                    return acc;
+                }
                 default:
-                    throw new Error(exports.SearchError.NotDefinedQueryKey);
+                    throw new Error(`${queryKey} : ${exports.SearchError.NotDefinedQueryKey}`);
             }
         }, []);
     };
@@ -60364,6 +61319,18 @@ var PolygonIdSdk = (function (exports) {
      * @returns {ClaimNonRevStatus}
      */
     const toClaimNonRevStatus = (s) => {
+        if (!s) {
+            const hash = $$2.hash(new Array(3).fill(0n));
+            return {
+                proof: new Kt$1(),
+                treeState: {
+                    state: V$1.fromBigInt(hash),
+                    claimsRoot: M$2,
+                    revocationRoot: M$2,
+                    rootOfRoots: M$2
+                }
+            };
+        }
         return {
             proof: s.mtp,
             treeState: buildTreeState(s.issuer.state, s.issuer.claimsTreeRoot, s.issuer.revocationTreeRoot, s.issuer.rootOfRoots)
@@ -60397,6 +61364,88 @@ var PolygonIdSdk = (function (exports) {
             proof
         };
     };
+    const parseCredentialSubject = (credentialSubject) => {
+        // credentialSubject is empty
+        if (!credentialSubject) {
+            return [{ operator: QueryOperators.$eq, fieldName: '' }];
+        }
+        const queries = [];
+        const entries = Object.entries(credentialSubject);
+        if (!entries.length) {
+            throw new Error(`query must have at least 1 predicate`);
+        }
+        for (const [fieldName, fieldReq] of entries) {
+            const fieldReqEntries = Object.entries(fieldReq);
+            const isSelectiveDisclosure = fieldReqEntries.length === 0;
+            if (isSelectiveDisclosure) {
+                queries.push({ operator: QueryOperators.$sd, fieldName: fieldName });
+                continue;
+            }
+            for (const [operatorName, operatorValue] of fieldReqEntries) {
+                if (!QueryOperators[operatorName]) {
+                    throw new Error(`operator is not supported by lib`);
+                }
+                const operator = QueryOperators[operatorName];
+                queries.push({ operator, fieldName, operatorValue });
+            }
+        }
+        return queries;
+    };
+    const parseQueryMetadata = async (propertyQuery, ldContextJSON, credentialType, options) => {
+        const datatype = await lf.newTypeFromContext(ldContextJSON, `${credentialType}.${propertyQuery.fieldName}`, options);
+        const query = {
+            ...propertyQuery,
+            slotIndex: 0,
+            merklizedSchema: false,
+            datatype: datatype,
+            claimPathKey: BigInt(0),
+            values: [],
+            path: new lf()
+        };
+        const serAttr = await Parser.getSerializationAttrFromContext(JSON.parse(ldContextJSON), options, credentialType);
+        if (!serAttr) {
+            query.merklizedSchema = true;
+        }
+        // for merklized credentials slotIndex in query must be equal to zero
+        // and not a position of merklization root.
+        // it has no influence on check in the off-chain circuits, but it aligns with onchain verification standard
+        if (!query.merklizedSchema) {
+            query.slotIndex = await Parser.getFieldSlotIndex(propertyQuery.fieldName, credentialType, byteEncoder.encode(ldContextJSON));
+        }
+        else {
+            try {
+                const path = await buildFieldPath(ldContextJSON, credentialType, propertyQuery.fieldName, options);
+                query.claimPathKey = await path.mtEntry();
+                query.path = path;
+            }
+            catch (e) {
+                throw new Error(`field does not exist in the schema ${e.message}`);
+            }
+        }
+        if (propertyQuery.operatorValue) {
+            if (!isValidOperation(datatype, propertyQuery.operator)) {
+                throw new Error(`operator ${propertyQuery.operator} is not supported for datatype ${datatype}`);
+            }
+            query.values = await transformQueryValueToBigInts(propertyQuery.operatorValue, datatype);
+        }
+        return query;
+    };
+    const parseQueriesMetadata = async (credentialType, ldContextJSON, credentialSubject, options) => {
+        const queriesMetadata = parseCredentialSubject(credentialSubject);
+        return Promise.all(queriesMetadata.map((m) => parseQueryMetadata(m, ldContextJSON, credentialType, options)));
+    };
+    const transformQueryValueToBigInts = async (value, ldType) => {
+        const values = new Array(64).fill(BigInt(0));
+        if (Array.isArray(value)) {
+            for (let index = 0; index < value.length; index++) {
+                values[index] = await ff.hashValue(ldType, value[index]);
+            }
+        }
+        else {
+            values[0] = await ff.hashValue(ldType, value);
+        }
+        return values;
+    };
 
     /* eslint-disable require-await */
     /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -81503,6 +82552,391 @@ var PolygonIdSdk = (function (exports) {
     }
     NativeProver.curveName = 'bn128';
 
+    const circuitValidator = {
+        [exports.CircuitId.AtomicQueryMTPV2]: { maxQueriesCount: 1 },
+        [exports.CircuitId.AtomicQueryMTPV2OnChain]: { maxQueriesCount: 1 },
+        [exports.CircuitId.AtomicQuerySigV2]: { maxQueriesCount: 1 },
+        [exports.CircuitId.AtomicQuerySigV2OnChain]: { maxQueriesCount: 1 },
+        [exports.CircuitId.AtomicQueryV3]: { maxQueriesCount: 1 },
+        [exports.CircuitId.AtomicQueryV3OnChain]: { maxQueriesCount: 1 },
+        [exports.CircuitId.AuthV2]: { maxQueriesCount: 0 },
+        [exports.CircuitId.StateTransition]: { maxQueriesCount: 0 },
+        [exports.CircuitId.LinkedNullifier]: { maxQueriesCount: 1 },
+        [exports.CircuitId.LinkedMultiQuery10]: { maxQueriesCount: 10 }
+    };
+    class InputGenerator {
+        constructor(_identityWallet, _credentialWallet, _stateStorage) {
+            this._identityWallet = _identityWallet;
+            this._credentialWallet = _credentialWallet;
+            this._stateStorage = _stateStorage;
+            this.credentialAtomicQueryMTPV2PrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
+                const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+                circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
+                const circuitInputs = new AtomicQueryMTPV2Inputs();
+                circuitInputs.id = W$3.idFromDID(identifier);
+                circuitInputs.requestID = BigInt(proofReq.id);
+                const query = circuitQueries[0];
+                query.operator = query.operator === exports.Operators.SD ? exports.Operators.EQ : query.operator;
+                circuitInputs.query = query;
+                circuitInputs.claim = {
+                    issuerID: circuitClaimData.issuerId,
+                    claim: circuitClaimData.claim,
+                    incProof: { proof: circuitClaimData.proof, treeState: circuitClaimData.treeState },
+                    nonRevProof: circuitClaimData.nonRevProof
+                };
+                circuitInputs.currentTimeStamp = S$3(new Date());
+                circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
+                circuitInputs.profileNonce = BigInt(params.authProfileNonce);
+                circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
+                return circuitInputs.inputsMarshal();
+            };
+            this.credentialAtomicQueryMTPV2OnChainPrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
+                const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+                const authInfo = await this.prepareAuthBJJCredential(identifier);
+                const authClaimData = await this.newCircuitClaimData({
+                    credential: authInfo.credential,
+                    credentialCoreClaim: authInfo.coreClaim
+                });
+                circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
+                const circuitInputs = new AtomicQueryMTPV2OnChainInputs();
+                const id = W$3.idFromDID(identifier);
+                circuitInputs.id = W$3.idFromDID(identifier);
+                circuitInputs.requestID = BigInt(proofReq.id);
+                const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
+                const gistProof = toGISTProof(stateProof);
+                circuitInputs.gistProof = gistProof;
+                if (authClaimData?.treeState) {
+                    circuitInputs.treeState = {
+                        state: authClaimData?.treeState?.state,
+                        claimsRoot: authClaimData?.treeState?.claimsRoot,
+                        revocationRoot: authClaimData?.treeState?.revocationRoot,
+                        rootOfRoots: authClaimData?.treeState?.rootOfRoots
+                    };
+                }
+                circuitInputs.authClaim = authClaimData.claim;
+                circuitInputs.authClaimIncMtp = authClaimData.proof;
+                circuitInputs.authClaimNonRevMtp = authInfo.nonRevProof.proof;
+                if (!params.challenge) {
+                    throw new Error('challenge must be provided for onchain circuits');
+                }
+                const signature = await this._identityWallet.signChallenge(params.challenge, authInfo.credential);
+                circuitInputs.signature = signature;
+                circuitInputs.challenge = params.challenge;
+                const query = circuitQueries[0];
+                query.operator = query.operator === exports.Operators.SD ? exports.Operators.EQ : query.operator;
+                circuitInputs.query = query;
+                circuitInputs.claim = {
+                    issuerID: circuitClaimData.issuerId,
+                    claim: circuitClaimData.claim,
+                    incProof: { proof: circuitClaimData.proof, treeState: circuitClaimData.treeState },
+                    nonRevProof: circuitClaimData.nonRevProof
+                };
+                circuitInputs.currentTimeStamp = S$3(new Date());
+                circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
+                circuitInputs.profileNonce = BigInt(params.authProfileNonce);
+                circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
+                return circuitInputs.inputsMarshal();
+            };
+            this.credentialAtomicQuerySigV2PrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
+                const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+                circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
+                const circuitInputs = new AtomicQuerySigV2Inputs();
+                circuitInputs.id = W$3.idFromDID(identifier);
+                circuitInputs.claim = {
+                    issuerID: circuitClaimData?.issuerId,
+                    signatureProof: circuitClaimData.signatureProof,
+                    claim: circuitClaimData.claim,
+                    nonRevProof: circuitClaimData.nonRevProof
+                };
+                circuitInputs.requestID = BigInt(proofReq.id);
+                circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
+                circuitInputs.profileNonce = BigInt(params.authProfileNonce);
+                circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
+                const query = circuitQueries[0];
+                query.operator = query.operator === exports.Operators.SD ? exports.Operators.EQ : query.operator;
+                circuitInputs.query = query;
+                circuitInputs.currentTimeStamp = S$3(new Date());
+                return circuitInputs.inputsMarshal();
+            };
+            this.credentialAtomicQuerySigV2OnChainPrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
+                const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+                const authInfo = await this.prepareAuthBJJCredential(identifier);
+                const authClaimData = await this.newCircuitClaimData({
+                    credential: authInfo.credential,
+                    credentialCoreClaim: authInfo.coreClaim
+                });
+                circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
+                const circuitInputs = new AtomicQuerySigV2OnChainInputs();
+                const id = W$3.idFromDID(identifier);
+                circuitInputs.id = id;
+                circuitInputs.claim = {
+                    issuerID: circuitClaimData.issuerId,
+                    signatureProof: circuitClaimData.signatureProof,
+                    claim: circuitClaimData.claim,
+                    nonRevProof: circuitClaimData.nonRevProof
+                };
+                circuitInputs.requestID = BigInt(proofReq.id);
+                circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
+                circuitInputs.profileNonce = BigInt(params.authProfileNonce);
+                circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
+                const query = circuitQueries[0];
+                query.operator = query.operator === exports.Operators.SD ? exports.Operators.EQ : query.operator;
+                circuitInputs.query = query;
+                circuitInputs.currentTimeStamp = S$3(new Date());
+                if (authClaimData.treeState) {
+                    circuitInputs.treeState = {
+                        state: authClaimData.treeState?.state,
+                        claimsRoot: authClaimData.treeState?.claimsRoot,
+                        revocationRoot: authClaimData.treeState?.revocationRoot,
+                        rootOfRoots: authClaimData.treeState?.rootOfRoots
+                    };
+                }
+                const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
+                const gistProof = toGISTProof(stateProof);
+                circuitInputs.gistProof = gistProof;
+                circuitInputs.authClaim = authClaimData.claim;
+                circuitInputs.authClaimIncMtp = authClaimData.proof;
+                circuitInputs.authClaimNonRevMtp = authInfo.nonRevProof.proof;
+                if (!params.challenge) {
+                    throw new Error('challenge must be provided for onchain circuits');
+                }
+                const signature = await this._identityWallet.signChallenge(params.challenge, authInfo.credential);
+                circuitInputs.signature = signature;
+                circuitInputs.challenge = params.challenge;
+                return circuitInputs.inputsMarshal();
+            };
+            this.credentialAtomicQueryV3PrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
+                const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+                circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
+                let proofType;
+                switch (proofReq.query.proofType) {
+                    case exports.ProofType.BJJSignature:
+                        proofType = exports.ProofType.BJJSignature;
+                        break;
+                    case exports.ProofType.Iden3SparseMerkleTreeProof:
+                        proofType = exports.ProofType.Iden3SparseMerkleTreeProof;
+                        break;
+                    default:
+                        if (circuitClaimData.proof) {
+                            proofType = exports.ProofType.Iden3SparseMerkleTreeProof;
+                        }
+                        else if (circuitClaimData.signatureProof) {
+                            proofType = exports.ProofType.BJJSignature;
+                        }
+                        else {
+                            throw Error('claim has no MTP or signature proof');
+                        }
+                        break;
+                }
+                const circuitInputs = new AtomicQueryV3Inputs();
+                circuitInputs.id = W$3.idFromDID(identifier);
+                circuitInputs.claim = {
+                    issuerID: circuitClaimData?.issuerId,
+                    signatureProof: circuitClaimData.signatureProof,
+                    claim: circuitClaimData.claim,
+                    nonRevProof: circuitClaimData.nonRevProof,
+                    incProof: { proof: circuitClaimData.proof, treeState: circuitClaimData.treeState }
+                };
+                circuitInputs.requestID = BigInt(proofReq.id);
+                circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
+                circuitInputs.profileNonce = BigInt(params.authProfileNonce);
+                circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
+                const query = circuitQueries[0];
+                query.values = query.operator === exports.Operators.SD ? new Array(64).fill(0) : query.values;
+                circuitInputs.query = query;
+                circuitInputs.currentTimeStamp = S$3(new Date());
+                circuitInputs.proofType = proofType;
+                circuitInputs.linkNonce = params.linkNonce ?? BigInt(0);
+                circuitInputs.verifierID = params.verifierDid ? W$3.idFromDID(params.verifierDid) : undefined;
+                circuitInputs.nullifierSessionID = proofReq.params?.nullifierSessionId
+                    ? BigInt(proofReq.params?.nullifierSessionId?.toString())
+                    : BigInt(0);
+                return circuitInputs.inputsMarshal();
+            };
+            this.credentialAtomicQueryV3OnChainPrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
+                const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+                circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
+                let proofType;
+                switch (proofReq.query.proofType) {
+                    case exports.ProofType.BJJSignature:
+                        proofType = exports.ProofType.BJJSignature;
+                        break;
+                    case exports.ProofType.Iden3SparseMerkleTreeProof:
+                        proofType = exports.ProofType.Iden3SparseMerkleTreeProof;
+                        break;
+                    default:
+                        if (circuitClaimData.proof) {
+                            proofType = exports.ProofType.Iden3SparseMerkleTreeProof;
+                        }
+                        else if (circuitClaimData.signatureProof) {
+                            proofType = exports.ProofType.BJJSignature;
+                        }
+                        else {
+                            throw Error('claim has no MTP or signature proof');
+                        }
+                        break;
+                }
+                const circuitInputs = new AtomicQueryV3OnChainInputs();
+                circuitInputs.id = W$3.idFromDID(identifier);
+                circuitInputs.claim = {
+                    issuerID: circuitClaimData?.issuerId,
+                    signatureProof: circuitClaimData.signatureProof,
+                    claim: circuitClaimData.claim,
+                    nonRevProof: circuitClaimData.nonRevProof,
+                    incProof: { proof: circuitClaimData.proof, treeState: circuitClaimData.treeState }
+                };
+                circuitInputs.requestID = BigInt(proofReq.id);
+                circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
+                circuitInputs.profileNonce = BigInt(params.authProfileNonce);
+                circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
+                const query = circuitQueries[0];
+                query.values = query.operator === exports.Operators.SD ? new Array(64).fill(0) : query.values;
+                circuitInputs.query = query;
+                circuitInputs.currentTimeStamp = S$3(new Date());
+                circuitInputs.proofType = proofType;
+                circuitInputs.linkNonce = params.linkNonce ?? BigInt(0);
+                circuitInputs.verifierID = params.verifierDid ? W$3.idFromDID(params.verifierDid) : undefined;
+                circuitInputs.nullifierSessionID = proofReq.params?.nullifierSessionID
+                    ? BigInt(proofReq.params?.nullifierSessionID?.toString())
+                    : BigInt(0);
+                let isEthIdentity = true;
+                try {
+                    k$2.ethAddressFromId(circuitInputs.id);
+                }
+                catch {
+                    isEthIdentity = false;
+                }
+                circuitInputs.authEnabled = isEthIdentity ? 0 : 1;
+                circuitInputs.challenge = BigInt(params.challenge ?? 0);
+                const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(identifier);
+                const id = W$3.idFromDID(genesisDID);
+                const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
+                const gistProof = toGISTProof(stateProof);
+                circuitInputs.gistProof = gistProof;
+                // auth inputs
+                if (circuitInputs.authEnabled === 1) {
+                    const authPrepared = await this.prepareAuthBJJCredential(genesisDID);
+                    const authClaimData = await this.newCircuitClaimData({
+                        credential: authPrepared.credential,
+                        credentialCoreClaim: authPrepared.coreClaim
+                    });
+                    const signature = await this._identityWallet.signChallenge(circuitInputs.challenge, authPrepared.credential);
+                    circuitInputs.profileNonce = BigInt(authProfileNonce);
+                    circuitInputs.authClaim = authClaimData.claim;
+                    circuitInputs.authClaimIncMtp = authClaimData.proof;
+                    circuitInputs.authClaimNonRevMtp = authPrepared.nonRevProof.proof;
+                    circuitInputs.treeState = authClaimData.treeState;
+                    circuitInputs.signature = signature;
+                }
+                return circuitInputs.inputsMarshal();
+            };
+            this.linkedNullifierPrepareInputs = async ({ preparedCredential, identifier, proofReq, params }) => {
+                const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+                circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
+                const circuitInputs = new LinkedNullifierInputs();
+                circuitInputs.linkNonce = params.linkNonce ?? BigInt(0);
+                circuitInputs.issuerClaim = circuitClaimData.claim;
+                circuitInputs.id = W$3.idFromDID(identifier);
+                circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
+                circuitInputs.verifierID = params.verifierDid ? W$3.idFromDID(params.verifierDid) : undefined;
+                circuitInputs.nullifierSessionID = proofReq.params?.nullifierSessionID
+                    ? BigInt(proofReq.params?.nullifierSessionID?.toString())
+                    : BigInt(0);
+                return circuitInputs.inputsMarshal();
+            };
+            this.linkedMultiQuery10PrepareInputs = async ({ preparedCredential, proofReq, params, circuitQueries }) => {
+                const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+                circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
+                const circuitInputs = new LinkedMultiQueryInputs();
+                circuitInputs.linkNonce = params.linkNonce ?? BigInt(0);
+                circuitInputs.claim = circuitClaimData.claim;
+                circuitInputs.query = circuitQueries;
+                circuitInputs.queryLength = circuitValidator[proofReq.circuitId].maxQueriesCount;
+                return circuitInputs.inputsMarshal();
+            };
+        }
+        async generateInputs(ctx) {
+            const { circuitId } = ctx.proofReq;
+            const fnName = `${circuitId.split('-')[0]}PrepareInputs`;
+            const queriesLength = ctx.circuitQueries.length;
+            if (queriesLength > circuitValidator[circuitId].maxQueriesCount) {
+                throw new Error(`circuit ${circuitId} supports only ${circuitValidator[circuitId].maxQueriesCount} queries`);
+            }
+            const fn = this[fnName];
+            if (!fn) {
+                throw new Error(`inputs generator for ${circuitId} not found`);
+            }
+            return fn(ctx);
+        }
+        async newCircuitClaimData(preparedCredential) {
+            const smtProof = preparedCredential.credential.getIden3SparseMerkleTreeProof();
+            const circuitClaim = new CircuitClaim();
+            circuitClaim.claim = preparedCredential.credentialCoreClaim;
+            circuitClaim.issuerId = W$3.idFromDID(W$3.parse(preparedCredential.credential.issuer));
+            if (smtProof) {
+                circuitClaim.proof = smtProof.mtp;
+                circuitClaim.treeState = {
+                    state: smtProof.issuerData.state.value,
+                    claimsRoot: smtProof.issuerData.state.claimsTreeRoot,
+                    revocationRoot: smtProof.issuerData.state.revocationTreeRoot,
+                    rootOfRoots: smtProof.issuerData.state.rootOfRoots
+                };
+            }
+            const sigProof = preparedCredential.credential.getBJJSignature2021Proof();
+            if (sigProof) {
+                const issuerDID = sigProof.issuerData.id;
+                const userDID = getUserDIDFromCredential(issuerDID, preparedCredential.credential);
+                const { credentialStatus, mtp, authCoreClaim } = sigProof.issuerData;
+                if (!credentialStatus) {
+                    throw new Error("can't check the validity of issuer auth claim: no credential status in proof");
+                }
+                if (!mtp) {
+                    throw new Error('issuer auth credential must have a mtp proof');
+                }
+                if (!authCoreClaim) {
+                    throw new Error('issuer auth credential must have a core claim proof');
+                }
+                const opts = {
+                    issuerGenesisState: sigProof.issuerData.state,
+                    issuerDID,
+                    userDID
+                };
+                const rs = await this._credentialWallet.getRevocationStatus(credentialStatus, opts);
+                const issuerAuthNonRevProof = toClaimNonRevStatus(rs);
+                circuitClaim.signatureProof = {
+                    signature: sigProof.signature,
+                    issuerAuthIncProof: {
+                        proof: sigProof.issuerData.mtp,
+                        treeState: {
+                            state: sigProof.issuerData.state.value,
+                            claimsRoot: sigProof.issuerData.state.claimsTreeRoot,
+                            revocationRoot: sigProof.issuerData.state.revocationTreeRoot,
+                            rootOfRoots: sigProof.issuerData.state.rootOfRoots
+                        }
+                    },
+                    issuerAuthClaim: sigProof.issuerData.authCoreClaim,
+                    issuerAuthNonRevProof
+                };
+            }
+            return circuitClaim;
+        }
+        async prepareAuthBJJCredential(did, treeStateInfo) {
+            const authCredential = await this._credentialWallet.getAuthBJJCredential(did);
+            const incProof = await this._identityWallet.generateCredentialMtp(did, authCredential, treeStateInfo);
+            const nonRevProof = await this._identityWallet.generateNonRevocationMtp(did, authCredential, treeStateInfo);
+            const authCoreClaim = authCredential.getCoreClaimFromProof(exports.ProofType.Iden3SparseMerkleTreeProof);
+            if (!authCoreClaim) {
+                throw new Error('auth core claim is not defined for auth bjj credential');
+            }
+            return {
+                credential: authCredential,
+                incProof,
+                nonRevProof,
+                coreClaim: authCoreClaim
+            };
+        }
+    }
+
     /**
      * Proof service is an implementation of IProofService
      * that works with a native groth16 prover
@@ -81525,6 +82959,7 @@ var PolygonIdSdk = (function (exports) {
             this._stateStorage = _stateStorage;
             this._prover = opts?.prover ?? new NativeProver(_circuitStorage);
             this._ldOptions = { ...opts, documentLoader: opts?.documentLoader ?? cacheLoader(opts) };
+            this._inputsGenerator = new InputGenerator(_identityWallet, _credentialWallet, _stateStorage);
         }
         /** {@inheritdoc IProofService.verifyProof} */
         async verifyProof(zkp, circuitId) {
@@ -81538,20 +82973,61 @@ var PolygonIdSdk = (function (exports) {
                     challenge: 0n
                 };
             }
-            // find credential
-            const credential = opts.credential ?? (await this.findCredential(identifier, proofReq.query));
+            let credentialWithRevStatus = { cred: opts.credential, revStatus: opts.credentialRevocationStatus };
+            if (!opts.credential) {
+                credentialWithRevStatus = await this.findCredentialByProofQuery(identifier, proofReq.query);
+            }
+            if (opts.credential && !opts.credentialRevocationStatus && !opts.skipRevocation) {
+                const revStatus = await this._credentialWallet.getRevocationStatusFromCredential(opts.credential);
+                credentialWithRevStatus = { cred: opts.credential, revStatus };
+            }
+            if (!credentialWithRevStatus.cred) {
+                throw new Error(`credential not found for query ${JSON.stringify(proofReq.query)}`);
+            }
+            const credentialCoreClaim = await this._identityWallet.getCoreClaimFromCredential(credentialWithRevStatus.cred);
             const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(identifier);
-            const preparedCredential = await this.getPreparedCredential(credential);
+            const preparedCredential = {
+                credential: credentialWithRevStatus.cred,
+                credentialCoreClaim,
+                revStatus: credentialWithRevStatus.revStatus
+            };
             const subjectDID = W$3.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');
             }
-            const { inputs, vp } = await this.generateInputs(preparedCredential, genesisDID, proofReq, {
+            const propertiesMetadata = parseCredentialSubject(proofReq.query.credentialSubject);
+            if (!propertiesMetadata.length) {
+                throw new Error('no queries in zkp request');
+            }
+            const mtPosition = preparedCredential.credentialCoreClaim.getMerklizedPosition();
+            let mk;
+            if (mtPosition !== U$2.None) {
+                mk = await preparedCredential.credential.merklize(this._ldOptions);
+            }
+            const context = proofReq.query['context'];
+            const groupId = proofReq.query['groupId'];
+            const ldContext = await this.loadLdContext(context);
+            const credentialType = proofReq.query['type'];
+            const queriesMetadata = [];
+            const circuitQueries = [];
+            for (const propertyMetadata of propertiesMetadata) {
+                const queryMetadata = await parseQueryMetadata(propertyMetadata, byteDecoder.decode(ldContext), credentialType, this._ldOptions);
+                queriesMetadata.push(queryMetadata);
+                const circuitQuery = await this.toCircuitsQuery(preparedCredential.credential, queryMetadata, mk);
+                circuitQueries.push(circuitQuery);
+            }
+            const inputs = await this.generateInputs(preparedCredential, genesisDID, proofReq, {
                 ...opts,
                 authProfileNonce,
-                credentialSubjectProfileNonce
-            });
+                credentialSubjectProfileNonce,
+                linkNonce: groupId ? opts.linkNonce : 0n
+            }, circuitQueries);
+            const sdQueries = queriesMetadata.filter((q) => q.operator === exports.Operators.SD);
+            let vp;
+            if (sdQueries.length) {
+                vp = createVerifiablePresentation(context, credentialType, preparedCredential.credential, sdQueries);
+            }
             const { proof, pub_signals } = await this._prover.generate(inputs, proofReq.circuitId);
             return {
                 id: proofReq.id,
@@ -81563,7 +83039,7 @@ var PolygonIdSdk = (function (exports) {
         }
         /** {@inheritdoc IProofService.transitState} */
         async transitState(did, oldTreeState, isOldStateGenesis, stateStorage, ethSigner) {
-            const authInfo = await this.prepareAuthBJJCredential(did, oldTreeState);
+            const authInfo = await this._inputsGenerator.prepareAuthBJJCredential(did, oldTreeState);
             const newTreeModel = await this._identityWallet.getDIDTreeModel(did);
             const claimsRoot = await newTreeModel.claimsTree.root();
             const rootOfRoots = await newTreeModel.rootsTree.root();
@@ -81575,17 +83051,17 @@ var PolygonIdSdk = (function (exports) {
                 rootOfRoots
             };
             const challenge = _$3.hash([oldTreeState.state.bigInt(), newTreeState.state.bigInt()]);
-            const signature = await this._identityWallet.signChallenge(challenge, authInfo.authCredential);
+            const signature = await this._identityWallet.signChallenge(challenge, authInfo.credential);
             const circuitInputs = new StateTransitionInputs();
             circuitInputs.id = W$3.idFromDID(did);
             circuitInputs.signature = signature;
             circuitInputs.isOldStateGenesis = isOldStateGenesis;
-            const authClaimIncProofNewState = await this._identityWallet.generateCredentialMtp(did, authInfo.authCredential, newTreeState);
+            const authClaimIncProofNewState = await this._identityWallet.generateCredentialMtp(did, authInfo.credential, newTreeState);
             circuitInputs.newTreeState = authClaimIncProofNewState.treeState;
             circuitInputs.authClaimNewStateIncProof = authClaimIncProofNewState.proof;
             circuitInputs.oldTreeState = oldTreeState;
             circuitInputs.authClaim = {
-                claim: authInfo.authCoreClaim,
+                claim: authInfo.coreClaim,
                 incProof: authInfo.incProof,
                 nonRevProof: authInfo.nonRevProof
             };
@@ -81595,370 +83071,65 @@ var PolygonIdSdk = (function (exports) {
             await this._identityWallet.updateIdentityState(did, true, newTreeState);
             return txId;
         }
-        async getPreparedCredential(credential) {
-            const revStatus = await this._credentialWallet.getRevocationStatusFromCredential(credential);
-            const credCoreClaim = await this._identityWallet.getCoreClaimFromCredential(credential);
-            return { credential, revStatus, credentialCoreClaim: credCoreClaim };
-        }
-        async prepareAuthBJJCredential(did, treeStateInfo) {
-            const authCredential = await this._credentialWallet.getAuthBJJCredential(did);
-            const incProof = await this._identityWallet.generateCredentialMtp(did, authCredential, treeStateInfo);
-            const nonRevProof = await this._identityWallet.generateNonRevocationMtp(did, authCredential, treeStateInfo);
-            const authCoreClaim = authCredential.getCoreClaimFromProof(exports.ProofType.Iden3SparseMerkleTreeProof);
-            if (!authCoreClaim) {
-                throw new Error('auth core claim is not defined for auth bjj credential');
-            }
-            return { authCredential, incProof, nonRevProof, authCoreClaim };
-        }
-        async generateInputs(preparedCredential, identifier, proofReq, params) {
-            let generateInputFn;
-            switch (proofReq.circuitId) {
-                case exports.CircuitId.AtomicQueryMTPV2:
-                    generateInputFn = this.generateMTPV2Inputs.bind(this);
-                    break;
-                case exports.CircuitId.AtomicQueryMTPV2OnChain:
-                    generateInputFn = this.generateMTPV2OnChainInputs.bind(this);
-                    break;
-                case exports.CircuitId.AtomicQuerySigV2:
-                    generateInputFn = this.generateQuerySigV2Inputs.bind(this);
-                    break;
-                case exports.CircuitId.AtomicQuerySigV2OnChain:
-                    generateInputFn = this.generateQuerySigV2OnChainInputs.bind(this);
-                    break;
-                default:
-                    throw new Error(`circuit with id ${proofReq.circuitId} is not supported by issuer`);
-            }
-            return generateInputFn(preparedCredential, identifier, proofReq, params);
-        }
-        async generateMTPV2Inputs(preparedCredential, identifier, proofReq, params) {
-            const circuitClaimData = await this.newCircuitClaimData(preparedCredential.credential, preparedCredential.credentialCoreClaim);
-            circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
-            const circuitInputs = new AtomicQueryMTPV2Inputs();
-            circuitInputs.id = W$3.idFromDID(identifier);
-            circuitInputs.requestID = BigInt(proofReq.id);
-            const { query, vp } = await this.toCircuitsQuery(proofReq.query, preparedCredential.credential, preparedCredential.credentialCoreClaim);
-            circuitInputs.query = query;
-            circuitInputs.claim = {
-                issuerID: circuitClaimData.issuerId,
-                claim: circuitClaimData.claim,
-                incProof: { proof: circuitClaimData.proof, treeState: circuitClaimData.treeState },
-                nonRevProof: circuitClaimData.nonRevProof
-            };
-            circuitInputs.currentTimeStamp = S$3(new Date());
-            circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
-            circuitInputs.profileNonce = BigInt(params.authProfileNonce);
-            circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
-            return { inputs: circuitInputs.inputsMarshal(), vp };
-        }
-        async generateMTPV2OnChainInputs(preparedCredential, identifier, proofReq, params) {
-            const circuitClaimData = await this.newCircuitClaimData(preparedCredential.credential, preparedCredential.credentialCoreClaim);
-            const authPrepared = await this.prepareAuthBJJCredential(identifier);
-            const authClaimData = await this.newCircuitClaimData(authPrepared.authCredential, authPrepared.authCoreClaim);
-            circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
-            const circuitInputs = new AtomicQueryMTPV2OnChainInputs();
-            const id = W$3.idFromDID(identifier);
-            circuitInputs.id = W$3.idFromDID(identifier);
-            circuitInputs.requestID = BigInt(proofReq.id);
-            const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
-            const gistProof = toGISTProof(stateProof);
-            circuitInputs.gistProof = gistProof;
-            if (authClaimData?.treeState) {
-                circuitInputs.treeState = {
-                    state: authClaimData?.treeState?.state,
-                    claimsRoot: authClaimData?.treeState?.claimsRoot,
-                    revocationRoot: authClaimData?.treeState?.revocationRoot,
-                    rootOfRoots: authClaimData?.treeState?.rootOfRoots
-                };
-            }
-            circuitInputs.authClaim = authClaimData.claim;
-            circuitInputs.authClaimIncMtp = authClaimData.proof;
-            circuitInputs.authClaimNonRevMtp = authPrepared.nonRevProof.proof;
-            if (!params.challenge) {
-                throw new Error('challenge must be provided for onchain circuits');
-            }
-            const signature = await this._identityWallet.signChallenge(params.challenge, authPrepared.authCredential);
-            circuitInputs.signature = signature;
-            circuitInputs.challenge = params.challenge;
-            const { query, vp } = await this.toCircuitsQuery(proofReq.query, preparedCredential.credential, preparedCredential.credentialCoreClaim);
-            circuitInputs.query = query;
-            circuitInputs.claim = {
-                issuerID: circuitClaimData.issuerId,
-                claim: circuitClaimData.claim,
-                incProof: { proof: circuitClaimData.proof, treeState: circuitClaimData.treeState },
-                nonRevProof: circuitClaimData.nonRevProof
-            };
-            circuitInputs.currentTimeStamp = S$3(new Date());
-            circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
-            circuitInputs.profileNonce = BigInt(params.authProfileNonce);
-            circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
-            return { inputs: circuitInputs.inputsMarshal(), vp };
-        }
-        async generateQuerySigV2Inputs(preparedCredential, identifier, proofReq, params) {
-            const circuitClaimData = await this.newCircuitClaimData(preparedCredential.credential, preparedCredential.credentialCoreClaim);
-            circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
-            const circuitInputs = new AtomicQuerySigV2Inputs();
-            circuitInputs.id = W$3.idFromDID(identifier);
-            circuitInputs.claim = {
-                issuerID: circuitClaimData?.issuerId,
-                signatureProof: circuitClaimData.signatureProof,
-                claim: circuitClaimData.claim,
-                nonRevProof: circuitClaimData.nonRevProof
-            };
-            circuitInputs.requestID = BigInt(proofReq.id);
-            circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
-            circuitInputs.profileNonce = BigInt(params.authProfileNonce);
-            circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
-            const { query, vp } = await this.toCircuitsQuery(proofReq.query, preparedCredential.credential, preparedCredential.credentialCoreClaim);
-            circuitInputs.query = query;
-            circuitInputs.currentTimeStamp = S$3(new Date());
-            return { inputs: circuitInputs.inputsMarshal(), vp };
-        }
-        async generateQuerySigV2OnChainInputs(preparedCredential, identifier, proofReq, params) {
-            const circuitClaimData = await this.newCircuitClaimData(preparedCredential.credential, preparedCredential.credentialCoreClaim);
-            const authPrepared = await this.prepareAuthBJJCredential(identifier);
-            const authClaimData = await this.newCircuitClaimData(authPrepared.authCredential, authPrepared.authCoreClaim);
-            circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
-            const circuitInputs = new AtomicQuerySigV2OnChainInputs();
-            const id = W$3.idFromDID(identifier);
-            circuitInputs.id = id;
-            circuitInputs.claim = {
-                issuerID: circuitClaimData.issuerId,
-                signatureProof: circuitClaimData.signatureProof,
-                claim: circuitClaimData.claim,
-                nonRevProof: circuitClaimData.nonRevProof
-            };
-            circuitInputs.requestID = BigInt(proofReq.id);
-            circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
-            circuitInputs.profileNonce = BigInt(params.authProfileNonce);
-            circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
-            const { query, vp } = await this.toCircuitsQuery(proofReq.query, preparedCredential.credential, preparedCredential.credentialCoreClaim);
-            circuitInputs.query = query;
-            circuitInputs.currentTimeStamp = S$3(new Date());
-            if (authClaimData.treeState) {
-                circuitInputs.treeState = {
-                    state: authClaimData.treeState?.state,
-                    claimsRoot: authClaimData.treeState?.claimsRoot,
-                    revocationRoot: authClaimData.treeState?.revocationRoot,
-                    rootOfRoots: authClaimData.treeState?.rootOfRoots
-                };
-            }
-            const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
-            const gistProof = toGISTProof(stateProof);
-            circuitInputs.gistProof = gistProof;
-            circuitInputs.authClaim = authClaimData.claim;
-            circuitInputs.authClaimIncMtp = authClaimData.proof;
-            circuitInputs.authClaimNonRevMtp = authPrepared.nonRevProof.proof;
-            if (!params.challenge) {
-                throw new Error('challenge must be provided for onchain circuits');
-            }
-            const signature = await this._identityWallet.signChallenge(params.challenge, authPrepared.authCredential);
-            circuitInputs.signature = signature;
-            circuitInputs.challenge = params.challenge;
-            return { inputs: circuitInputs.inputsMarshal(), vp };
+        async generateInputs(preparedCredential, identifier, proofReq, params, circuitQueries) {
+            return this._inputsGenerator.generateInputs({
+                preparedCredential,
+                identifier,
+                proofReq,
+                params,
+                circuitQueries
+            });
         }
-        // NewCircuitClaimData generates circuits claim structure
-        async newCircuitClaimData(credential, coreClaim) {
-            const smtProof = credential.getIden3SparseMerkleTreeProof();
-            const circuitClaim = new CircuitClaim();
-            circuitClaim.claim = coreClaim;
-            circuitClaim.issuerId = W$3.idFromDID(W$3.parse(credential.issuer));
-            if (smtProof) {
-                circuitClaim.proof = smtProof.mtp;
-                circuitClaim.treeState = {
-                    state: smtProof.issuerData.state.value,
-                    claimsRoot: smtProof.issuerData.state.claimsTreeRoot,
-                    revocationRoot: smtProof.issuerData.state.revocationTreeRoot,
-                    rootOfRoots: smtProof.issuerData.state.rootOfRoots
-                };
+        async toCircuitsQuery(credential, queryMetadata, merklizedCredential) {
+            if (queryMetadata.merklizedSchema && !merklizedCredential) {
+                throw new Error('merklized root position is set to None for merklized schema');
             }
-            const sigProof = credential.getBJJSignature2021Proof();
-            if (sigProof) {
-                const issuerDID = sigProof.issuerData.id;
-                let userDID;
-                if (!credential.credentialSubject.id) {
-                    userDID = issuerDID;
-                }
-                else {
-                    if (typeof credential.credentialSubject.id !== 'string') {
-                        throw new Error('credential status `id` is not a string');
-                    }
-                    userDID = W$3.parse(credential.credentialSubject.id);
-                }
-                if (!sigProof.issuerData.credentialStatus) {
-                    throw new Error("can't check the validity of issuer auth claim: no credential status in proof");
-                }
-                const opts = {
-                    issuerGenesisState: sigProof.issuerData.state,
-                    issuerDID,
-                    userDID
-                };
-                const rs = await this._credentialWallet.getRevocationStatus(sigProof.issuerData.credentialStatus, opts);
-                if (!rs) {
-                    throw new Error("can't fetch the credential status of issuer auth claim");
-                }
-                const issuerAuthNonRevProof = toClaimNonRevStatus(rs);
-                if (!sigProof.issuerData.mtp) {
-                    throw new Error('issuer auth credential must have a mtp proof');
-                }
-                if (!sigProof.issuerData.authCoreClaim) {
-                    throw new Error('issuer auth credential must have a core claim proof');
-                }
-                circuitClaim.signatureProof = {
-                    signature: sigProof.signature,
-                    issuerAuthIncProof: {
-                        proof: sigProof.issuerData.mtp,
-                        treeState: {
-                            state: sigProof.issuerData.state.value,
-                            claimsRoot: sigProof.issuerData.state.claimsTreeRoot,
-                            revocationRoot: sigProof.issuerData.state.revocationTreeRoot,
-                            rootOfRoots: sigProof.issuerData.state.rootOfRoots
-                        }
-                    },
-                    issuerAuthClaim: sigProof.issuerData.authCoreClaim,
-                    issuerAuthNonRevProof
-                };
+            if (!queryMetadata.merklizedSchema && merklizedCredential) {
+                throw new Error('merklized root position is not set to None for non-merklized schema');
             }
-            return circuitClaim;
-        }
-        async toCircuitsQuery(query, credential, coreClaim) {
-            const mtPosition = coreClaim.getMerklizedPosition();
-            return mtPosition === U$2.None
-                ? this.prepareNonMerklizedQuery(query, credential)
-                : this.prepareMerklizedQuery(query, credential);
-        }
-        async prepareMerklizedQuery(query, credential) {
-            const parsedQuery = await this.parseRequest(query.credentialSubject);
-            const ldContext = await this.loadLdContextFromJSONSchema(credential.credentialSchema.id);
-            let path = new lf();
-            if (parsedQuery.fieldName) {
-                path = await lf.getContextPathKey(byteDecoder.decode(ldContext), credential.type[1], parsedQuery.fieldName, this._ldOptions);
-            }
-            path.prepend(['https://www.w3.org/2018/credentials#credentialSubject']);
-            const mk = await credential.merklize(this._ldOptions);
-            const { proof, value: mtValue } = await mk.proof(path);
-            const pathKey = await path.mtEntry();
-            parsedQuery.query.valueProof = new ValueProof();
-            parsedQuery.query.valueProof.mtp = proof;
-            parsedQuery.query.valueProof.path = pathKey;
-            parsedQuery.query.valueProof.mtp = proof;
-            const mtEntry = await mtValue?.mtEntry();
-            if (!mtEntry) {
-                throw new Error(`can't merklize credential: no merkle tree entry found`);
-            }
-            parsedQuery.query.valueProof.value = mtEntry;
-            // for merklized credentials slotIndex in query must be equal to zero
-            // and not a position of merklization root.
-            // it has no influence on check in the off-chain circuits, but it aligns with onchain verification standard
-            parsedQuery.query.slotIndex = 0;
-            if (!parsedQuery.fieldName) {
-                const resultQuery = parsedQuery.query;
-                resultQuery.operator = QueryOperators.$eq;
-                resultQuery.values = [mtEntry];
-                return { query: resultQuery };
-            }
-            if (parsedQuery.isSelectiveDisclosure) {
-                const rawValue = mk.rawValue(path);
-                const vp = createVerifiablePresentation(query.context ?? '', query.type ?? '', parsedQuery.fieldName, rawValue);
-                const resultQuery = parsedQuery.query;
-                resultQuery.operator = QueryOperators.$eq;
-                resultQuery.values = [mtEntry];
-                return { query: resultQuery, vp };
-            }
-            if (parsedQuery.rawValue === null || parsedQuery.rawValue === undefined) {
-                throw new Error('value is not presented in the query');
-            }
-            const ldType = await mk.jsonLDType(path);
-            parsedQuery.query.values = await this.transformQueryValueToBigInts(parsedQuery.rawValue, ldType);
-            return { query: parsedQuery.query };
-        }
-        async prepareNonMerklizedQuery(query, credential) {
-            const ldContext = await this.loadLdContextFromJSONSchema(credential.credentialSchema.id);
-            if (query.credentialSubject && Object.keys(query.credentialSubject).length > 1) {
-                throw new Error('multiple requests are not supported');
-            }
-            const parsedQuery = await this.parseRequest(query.credentialSubject);
-            if (!query.type) {
-                throw new Error('query type is not defined');
-            }
-            parsedQuery.query.slotIndex = await Parser.getFieldSlotIndex(parsedQuery.fieldName, query.type, ldContext);
-            const { vp, mzValue, dataType } = await verifiablePresentationFromCred(credential, query, parsedQuery.fieldName, this._ldOptions);
-            if (parsedQuery.isSelectiveDisclosure) {
-                const resultQuery = parsedQuery.query;
-                resultQuery.operator = QueryOperators.$eq;
-                resultQuery.values = [await mzValue.mtEntry()];
-                return { query: resultQuery, vp };
-            }
-            if (parsedQuery.rawValue === null || parsedQuery.rawValue === undefined) {
-                throw new Error('value is not presented in the query');
-            }
-            parsedQuery.query.values = await this.transformQueryValueToBigInts(parsedQuery.rawValue, dataType);
-            return { query: parsedQuery.query };
-        }
-        async loadLdContextFromJSONSchema(jsonSchemaURL) {
+            const query = new Query();
+            query.slotIndex = queryMetadata.slotIndex;
+            query.operator = queryMetadata.operator;
+            query.values = queryMetadata.values;
+            if (queryMetadata.merklizedSchema && merklizedCredential) {
+                const { proof, value: mtValue } = await merklizedCredential.proof(queryMetadata.path);
+                query.valueProof = new ValueProof();
+                query.valueProof.mtp = proof;
+                query.valueProof.path = queryMetadata.claimPathKey;
+                const mtEntry = await mtValue?.mtEntry();
+                if (!mtEntry) {
+                    throw new Error(`can't merklize credential: no merkle tree entry found`);
+                }
+                query.valueProof.value = mtEntry;
+                if (!queryMetadata.fieldName) {
+                    query.values = [mtEntry];
+                    return query;
+                }
+            }
+            if (queryMetadata.operator === exports.Operators.SD) {
+                const [first, ...rest] = queryMetadata.fieldName.split('.');
+                let v = credential.credentialSubject[first];
+                for (const part of rest) {
+                    v = v[part];
+                }
+                if (typeof v === 'undefined') {
+                    throw new Error(`credential doesn't contain value for field ${queryMetadata.fieldName}`);
+                }
+                query.values = await transformQueryValueToBigInts(v, queryMetadata.datatype);
+            }
+            return query;
+        }
+        async loadLdContext(context) {
             const loader = af(this._ldOptions);
-            let schema;
-            try {
-                schema = (await loader(jsonSchemaURL)).document;
-            }
-            catch (e) {
-                throw new Error(`can't load credential schema ${jsonSchemaURL}`);
-            }
-            const jsonSchema = schema;
             let ldSchema;
-            let ldContextUrl = '';
             try {
-                ldContextUrl = jsonSchema.$metadata.uris['jsonLdContext'];
-                if (!ldContextUrl) {
-                    throw new Error('ldContext is not defined in json schema metadata');
-                }
-                ldSchema = (await loader(ldContextUrl)).document;
+                ldSchema = (await loader(context)).document;
             }
             catch (e) {
-                throw new Error(`can't load ld context from url ${ldContextUrl}`);
+                throw new Error(`can't load ld context from url ${context}`);
             }
             return byteEncoder.encode(JSON.stringify(ldSchema));
         }
-        async parseRequest(req) {
-            if (!req) {
-                const query = new Query();
-                query.operator = QueryOperators.$eq;
-                return { query, fieldName: '' };
-            }
-            const entries = Object.entries(req);
-            if (entries.length > 1) {
-                throw new Error(`multiple requests  not supported`);
-            }
-            const [fieldName, fieldReq] = entries[0];
-            const fieldReqEntries = Object.entries(fieldReq);
-            if (fieldReqEntries.length > 1) {
-                throw new Error(`multiple predicates for one field not supported`);
-            }
-            const isSelectiveDisclosure = fieldReqEntries.length === 0;
-            const query = new Query();
-            if (isSelectiveDisclosure) {
-                return { query, fieldName, isSelectiveDisclosure };
-            }
-            let operator = 0;
-            const [key, value] = fieldReqEntries[0];
-            if (!QueryOperators[key]) {
-                throw new Error(`operator is not supported by lib`);
-            }
-            operator = QueryOperators[key];
-            query.operator = operator;
-            return { query, fieldName, rawValue: value };
-        }
-        async transformQueryValueToBigInts(value, ldType) {
-            const values = new Array(64).fill(BigInt(0));
-            if (Array.isArray(value)) {
-                for (let index = 0; index < value.length; index++) {
-                    values[index] = await ff.hashValue(ldType, value[index]);
-                }
-            }
-            else {
-                values[0] = await ff.hashValue(ldType, value);
-            }
-            return values;
-        }
         /** {@inheritdoc IProofService.generateAuthV2Inputs} */
         async generateAuthV2Inputs(hash, did, circuitId) {
             if (circuitId !== exports.CircuitId.AuthV2) {
@@ -81966,9 +83137,12 @@ var PolygonIdSdk = (function (exports) {
             }
             const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(did);
             const challenge = T$3.bytesToInt(hash.reverse());
-            const authPrepared = await this.prepareAuthBJJCredential(genesisDID);
-            const authClaimData = await this.newCircuitClaimData(authPrepared.authCredential, authPrepared.authCoreClaim);
-            const signature = await this._identityWallet.signChallenge(challenge, authPrepared.authCredential);
+            const authPrepared = await this._inputsGenerator.prepareAuthBJJCredential(genesisDID);
+            const authClaimData = await this._inputsGenerator.newCircuitClaimData({
+                credential: authPrepared.credential,
+                credentialCoreClaim: authPrepared.coreClaim
+            });
+            const signature = await this._identityWallet.signChallenge(challenge, authPrepared.credential);
             const id = W$3.idFromDID(genesisDID);
             const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
             const gistProof = toGISTProof(stateProof);
@@ -82004,7 +83178,7 @@ var PolygonIdSdk = (function (exports) {
             }
             return true;
         }
-        async findCredential(did, query) {
+        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`);
@@ -82012,18 +83186,11 @@ var PolygonIdSdk = (function (exports) {
             //  For EQ / IN / NIN / LT / GT operations selective if credential satisfies query - we can get any.
             // TODO: choose credential for selective credentials
             const credential = query.skipClaimRevocationCheck
-                ? credentials[0]
-                : (await this._credentialWallet.findNonRevokedCredential(credentials)).cred;
+                ? { cred: credentials[0], revStatus: undefined }
+                : await this._credentialWallet.findNonRevokedCredential(credentials);
             return credential;
         }
     }
-    // BJJSignatureFromHexString converts hex to  babyjub.Signature
-    const bJJSignatureFromHexString = async (sigHex) => {
-        const signatureBytes = b$5.decodeString(sigHex);
-        const compressedSig = Uint8Array.from(signatureBytes).slice(0, 64);
-        const bjjSig = EI.newFromCompressed(compressedSig);
-        return bjjSig;
-    };
 
     /**
      * creates empty basic message
@@ -82677,15 +83844,55 @@ var PolygonIdSdk = (function (exports) {
                 from: did.string(),
                 to: authRequest.from
             };
-            for (const proofReq of authRequest.body.scope) {
-                const zkpReq = {
-                    id: proofReq.id,
-                    circuitId: proofReq.circuitId,
-                    query: proofReq.query
-                };
+            const requestScope = authRequest.body.scope;
+            const combinedQueries = requestScope.reduce((acc, proofReq) => {
+                const groupId = proofReq.query.groupId;
+                if (!groupId) {
+                    return acc;
+                }
+                const existedData = acc.get(groupId);
+                if (!existedData) {
+                    const seed = V$3(12);
+                    const dataView = new DataView(seed.buffer);
+                    const linkNonce = dataView.getUint32(0);
+                    acc.set(groupId, { query: proofReq.query, linkNonce });
+                    return acc;
+                }
+                const credentialSubject = mergeObjects(existedData.query.credentialSubject, proofReq.query.credentialSubject);
+                acc.set(groupId, {
+                    ...existedData,
+                    query: {
+                        skipClaimRevocationCheck: existedData.query.skipClaimRevocationCheck || proofReq.query.skipClaimRevocationCheck,
+                        ...existedData.query,
+                        credentialSubject
+                    }
+                });
+                return acc;
+            }, new Map());
+            const groupedCredentialsCache = new Map();
+            for (const proofReq of requestScope) {
                 const query = proofReq.query;
-                const zkpRes = await this._proofService.generateProof(zkpReq, did, {
-                    skipRevocation: query.skipClaimRevocationCheck ?? false
+                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, {
+                    skipRevocation: Boolean(query.skipClaimRevocationCheck),
+                    credential: credWithRevStatus?.cred,
+                    credentialRevocationStatus: credWithRevStatus?.revStatus,
+                    linkNonce: combinedQueryData?.linkNonce ? BigInt(combinedQueryData.linkNonce) : undefined
                 });
                 authResponse.body.scope.push(zkpRes);
             }
@@ -82819,7 +84026,8 @@ var PolygonIdSdk = (function (exports) {
             this._zkpVerifier = _zkpVerifier;
             this._allowedCircuits = [
                 exports.CircuitId.AtomicQueryMTPV2OnChain,
-                exports.CircuitId.AtomicQuerySigV2OnChain
+                exports.CircuitId.AtomicQuerySigV2OnChain,
+                exports.CircuitId.AtomicQueryV3OnChain
             ];
         }
         /**
@@ -82853,19 +84061,28 @@ var PolygonIdSdk = (function (exports) {
                 throw new Error("Can't sign transaction. Provide Signer in options.");
             }
             const zkRequests = [];
+            const { contract_address, chain_id } = ciRequest.body.transaction_data;
+            const networkFlag = Object.keys(u$2).find((key) => u$2[key] === chain_id);
+            if (!networkFlag) {
+                throw new Error(`Invalid chain id ${chain_id}`);
+            }
+            const [blockchain, networkId] = networkFlag.split(':');
+            const verifierId = buildVerifierId(contract_address, {
+                blockchain,
+                networkId,
+                // DidMethod.Iden3 is used based on discussions: all onchain issuers have iden3 did method by default. This can be changed in the release of v3 circuit.
+                method: h$3.Iden3
+            });
+            const verifierDid = W$3.parseFromId(verifierId);
             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 zkpReq = {
-                    id: proofReq.id,
-                    circuitId: proofReq.circuitId,
-                    query: proofReq.query
-                };
                 const query = proofReq.query;
-                const zkpRes = await this._proofService.generateProof(zkpReq, did, {
+                const zkpRes = await this._proofService.generateProof(proofReq, did, {
                     skipRevocation: query.skipClaimRevocationCheck ?? false,
-                    challenge: opts.challenge
+                    challenge: opts.challenge,
+                    verifierDid
                 });
                 zkRequests.push(zkpRes);
             }
@@ -82884,6 +84101,10 @@ var PolygonIdSdk = (function (exports) {
     exports.AtomicQuerySigV2OnChainInputs = AtomicQuerySigV2OnChainInputs;
     exports.AtomicQuerySigV2OnChainPubSignals = AtomicQuerySigV2OnChainPubSignals;
     exports.AtomicQuerySigV2PubSignals = AtomicQuerySigV2PubSignals;
+    exports.AtomicQueryV3Inputs = AtomicQueryV3Inputs;
+    exports.AtomicQueryV3OnChainInputs = AtomicQueryV3OnChainInputs;
+    exports.AtomicQueryV3OnChainPubSignals = AtomicQueryV3OnChainPubSignals;
+    exports.AtomicQueryV3PubSignals = AtomicQueryV3PubSignals;
     exports.AuthHandler = AuthHandler;
     exports.AuthV2Inputs = AuthV2Inputs;
     exports.AuthV2PubSignals = AuthV2PubSignals;
@@ -82926,6 +84147,10 @@ var PolygonIdSdk = (function (exports) {
     exports.JsonSchemaValidator = JsonSchemaValidator;
     exports.KMS = KMS;
     exports.LDParser = LDParser;
+    exports.LinkedMultiQueryInputs = LinkedMultiQueryInputs;
+    exports.LinkedMultiQueryPubSignals = LinkedMultiQueryPubSignals;
+    exports.LinkedNullifierInputs = LinkedNullifierInputs;
+    exports.LinkedNullifierPubSignals = LinkedNullifierPubSignals;
     exports.LocalStoragePrivateKeyStore = LocalStoragePrivateKeyStore;
     exports.MerkleTreeIndexedDBStorage = MerkleTreeIndexedDBStorage;
     exports.MerkleTreeLocalStorage = MerkleTreeLocalStorage;
@@ -82952,13 +84177,14 @@ var PolygonIdSdk = (function (exports) {
     exports.VerificationHandlerFunc = VerificationHandlerFunc;
     exports.W3CCredential = W3CCredential;
     exports.ZKPPacker = ZKPPacker;
-    exports.bJJSignatureFromHexString = bJJSignatureFromHexString;
+    exports.availableTypesOperators = availableTypesOperators;
     exports.base58ToBytes = base58ToBytes;
     exports.base64ToBytes = base64ToBytes;
     exports.base64UrlToBytes = base64UrlToBytes;
     exports.bigIntArrayToStringArray = bigIntArrayToStringArray;
-    exports.buildQueryPath = buildQueryPath;
+    exports.buildFieldPath = buildFieldPath;
     exports.buildTreeState = buildTreeState;
+    exports.buildVerifierId = buildVerifierId;
     exports.byteDecoder = byteDecoder;
     exports.byteEncoder = byteEncoder;
     exports.bytesToBase58 = bytesToBase58;
@@ -82976,7 +84202,7 @@ var PolygonIdSdk = (function (exports) {
     exports.decodeBase64url = decodeBase64url;
     exports.defaultEthConnectionConfig = defaultEthConnectionConfig;
     exports.defaultMTLevels = defaultMTLevels;
-    exports.defaultMTLevelsClaimsMerklization = defaultMTLevelsClaimsMerklization;
+    exports.defaultMTLevelsClaim = defaultMTLevelsClaim;
     exports.defaultMTLevelsOnChain = defaultMTLevelsOnChain;
     exports.defaultValueArraySize = defaultValueArraySize;
     exports.defineMerklizedRootPosition = defineMerklizedRootPosition;
@@ -82987,15 +84213,22 @@ var PolygonIdSdk = (function (exports) {
     exports.factoryComparer = factoryComparer;
     exports.fieldToByteArray = fieldToByteArray;
     exports.fillSlot = fillSlot;
+    exports.findValue = findValue;
     exports.generateProfileDID = generateProfileDID;
     exports.getNodeAuxValue = getNodeAuxValue;
     exports.getProperties = getProperties;
+    exports.getUserDIDFromCredential = getUserDIDFromCredential;
     exports.hexToBytes = hexToBytes$1;
     exports.isGenesisState = isGenesisState;
     exports.isGenesisStateId = isGenesisStateId;
     exports.isIssuerGenesis = isIssuerGenesis;
+    exports.isValidOperation = isValidOperation;
     exports.jsonLDMerklizer = index;
     exports.keyPath = keyPath;
+    exports.mergeObjects = mergeObjects;
+    exports.parseCredentialSubject = parseCredentialSubject;
+    exports.parseQueriesMetadata = parseQueriesMetadata;
+    exports.parseQueryMetadata = parseQueryMetadata;
     exports.prepareCircuitArrayValues = prepareCircuitArrayValues;
     exports.prepareSiblingsStr = prepareSiblingsStr;
     exports.pushHashesToRHS = pushHashesToRHS;
@@ -83008,7 +84241,7 @@ var PolygonIdSdk = (function (exports) {
     exports.toClaimNonRevStatus = toClaimNonRevStatus;
     exports.toGISTProof = toGISTProof;
     exports.toRevocationStatus = toRevocationStatus;
-    exports.verifiablePresentationFromCred = verifiablePresentationFromCred;
+    exports.transformQueryValueToBigInts = transformQueryValueToBigInts;
 
     return exports;