@0xpolygonid/js-sdk 1.5.0 → 1.6.0

package/dist/browser/esm/index.js

@@ -1,4 +1,4 @@
-import { BytesHelper, checkBigIntInField, Claim, DID, IdPosition, MerklizedRootPosition as MerklizedRootPosition$1, Id, SchemaHash, ClaimOptions, buildDIDType, getChainId, DidMethod, Blockchain, NetworkId, getUnixTimestamp } from '@iden3/js-iden3-core';
+import { BytesHelper, checkBigIntInField, genesisFromEthAddress, buildDIDType, Id, Claim, DID, IdPosition, MerklizedRootPosition as MerklizedRootPosition$1, SchemaHash, ClaimOptions, getChainId, DidMethod, Blockchain, NetworkId, getUnixTimestamp, ChainIds } from '@iden3/js-iden3-core';
 import * as jsIden3Core from '@iden3/js-iden3-core';
 export { jsIden3Core as core };
 import { Merklizer, Path, getDocumentLoader } from '@iden3/js-jsonld-merklization';
@@ -13709,6 +13709,54 @@ function bytesToHex$1(b) {
     return Hex.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 = Hex.decodeString(address);
+    const ethAddr = ethAddrBytes.slice(0, 20);
+    const genesis = genesisFromEthAddress(ethAddr);
+    const tp = buildDIDType(info.method, info.blockchain, info.networkId);
+    return new Id(tp, genesis);
+};
+
 /**
  * Provider for Sec256p1 keys256p1
  * @public
@@ -14129,6 +14177,7 @@ class Iden3SparseMerkleTreeProof {
             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) {
@@ -14207,6 +14256,7 @@ class BJJSignatureProof2021 {
      * 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: {
@@ -14408,19 +14458,23 @@ const stringByPath = (obj, path) => {
     }
     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 Path();
+    if (field) {
+        path = await Path.getContextPathKey(ldSchema, contextType, field, opts);
     }
-    catch (error) {
-        throw new Error(`context not found: ${error.message}`);
-    }
-    const path = await Path.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;
@@ -14428,36 +14482,33 @@ const createVerifiablePresentation = (context, tp, path, value) => {
     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 */
@@ -27532,6 +27583,13 @@ class Parser {
         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) {
@@ -36800,6 +36858,7 @@ class JsonSchemaValidator {
         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;
@@ -55149,7 +55208,7 @@ function isGenesisState(did, state) {
 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';
@@ -55175,14 +55234,12 @@ class BaseConfig {
         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
@@ -55326,6 +55383,21 @@ function getProperties(obj) {
     return result;
 }
 
+/**
+ * Represents the XSD namespace and its corresponding data types.
+ */
+var XSDNS;
+(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";
+})(XSDNS || (XSDNS = {}));
 /**
  * List of available operators.
  *
@@ -55340,6 +55412,11 @@ var Operators;
     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";
 })(Operators || (Operators = {}));
 /** QueryOperators represents operators for atomic circuits */
 const QueryOperators = {
@@ -55349,7 +55426,41 @@ const QueryOperators = {
     $gt: Operators.GT,
     $in: Operators.IN,
     $nin: Operators.NIN,
-    $ne: Operators.NE
+    $ne: Operators.NE,
+    $lte: Operators.LTE,
+    $gte: Operators.GTE,
+    $between: Operators.BETWEEN,
+    $sd: Operators.SD,
+    $nullify: Operators.NULLIFY
+};
+const allOperations = Object.values(QueryOperators);
+const availableTypesOperators = new Map([
+    [XSDNS.Boolean, [QueryOperators.$eq, QueryOperators.$ne]],
+    [XSDNS.Integer, allOperations],
+    [XSDNS.NonNegativeInteger, allOperations],
+    [XSDNS.PositiveInteger, allOperations],
+    [XSDNS.Double, [QueryOperators.$eq, QueryOperators.$ne, QueryOperators.$in, QueryOperators.$nin]],
+    [XSDNS.String, [QueryOperators.$eq, QueryOperators.$ne, QueryOperators.$in, QueryOperators.$nin]],
+    [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 === 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.
@@ -55461,7 +55572,9 @@ class Query {
      *
      */
     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(CircuitError.EmptyQueryValue);
     }
 }
@@ -55484,6 +55597,26 @@ var CircuitId;
     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";
 })(CircuitId || (CircuitId = {}));
 /**
  * Claim structure for circuit inputs
@@ -55517,7 +55650,9 @@ var CircuitError;
     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";
 })(CircuitError || (CircuitError = {}));
 /**
  * ValueProof represents a Merkle Proof for a value stored as MT
@@ -55606,7 +55741,7 @@ class AtomicQueryMTPV2Inputs extends BaseConfig {
                 .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,
@@ -55787,7 +55922,7 @@ class AtomicQueryMTPV2OnChainInputs extends BaseConfig {
             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,
@@ -55944,6 +56079,9 @@ class AtomicQuerySigV2Inputs extends BaseConfig {
             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(),
@@ -55951,16 +56089,10 @@ class AtomicQuerySigV2Inputs extends BaseConfig {
             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(),
@@ -55970,18 +56102,18 @@ class AtomicQuerySigV2Inputs extends BaseConfig {
             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,
@@ -56111,6 +56243,581 @@ class AtomicQuerySigV2PubSignals extends BaseConfig {
     }
 }
 
+const zero$1 = '0';
+/**
+ * AtomicQueryV3Inputs ZK private inputs for credentialAtomicQueryV3.circom
+ *
+ * @beta
+ * @class AtomicQueryV3Inputs
+ * @extends {BaseConfig}
+ */
+class AtomicQueryV3Inputs extends BaseConfig {
+    validate() {
+        if (!this.requestID) {
+            throw new Error(CircuitError.EmptyRequestID);
+        }
+        if (!this.claim.nonRevProof.proof) {
+            throw new Error(CircuitError.EmptyClaimNonRevProof);
+        }
+        if (!this.query.values) {
+            throw new Error(CircuitError.EmptyQueryValue);
+        }
+        if (!this.proofType) {
+            throw new Error(CircuitError.InvalidProofType);
+        }
+        if (this.proofType === ProofType.BJJSignature) {
+            if (!this.claim.signatureProof?.issuerAuthIncProof.proof) {
+                throw new Error(CircuitError.EmptyIssuerAuthClaimProof);
+            }
+            if (!this.claim.signatureProof.issuerAuthNonRevProof.proof) {
+                throw new Error(CircuitError.EmptyIssuerAuthClaimNonRevProof);
+            }
+            if (!this.claim.signatureProof.signature) {
+                throw new Error(CircuitError.EmptyClaimSignature);
+            }
+        }
+        if (this.proofType === ProofType.Iden3SparseMerkleTreeProof) {
+            if (!this.claim?.incProof?.proof) {
+                throw new Error(CircuitError.EmptyClaimProof);
+            }
+        }
+    }
+    fillMTPProofsWithZero(s) {
+        s.issuerClaimMtp = prepareSiblingsStr(new Proof(), this.getMTLevel());
+        s.issuerClaimClaimsTreeRoot = ZERO_HASH.bigInt().toString();
+        s.issuerClaimRevTreeRoot = ZERO_HASH.bigInt().toString();
+        s.issuerClaimRootsTreeRoot = ZERO_HASH.bigInt().toString();
+        s.issuerClaimIdenState = ZERO_HASH.bigInt().toString();
+    }
+    fillSigProofWithZero(s) {
+        s.issuerClaimSignatureR8x = zero$1;
+        s.issuerClaimSignatureR8y = zero$1;
+        s.issuerClaimSignatureS = zero$1;
+        s.issuerAuthClaim = new Claim().marshalJson();
+        s.issuerAuthClaimMtp = prepareSiblingsStr(new Proof(), this.getMTLevel());
+        s.issuerAuthClaimsTreeRoot = zero$1;
+        s.issuerAuthRevTreeRoot = zero$1;
+        s.issuerAuthRootsTreeRoot = zero$1;
+        s.issuerAuthClaimNonRevMtp = prepareSiblingsStr(new Proof(), this.getMTLevel());
+        s.issuerAuthClaimNonRevMtpAuxHi = ZERO_HASH.bigInt().toString();
+        s.issuerAuthClaimNonRevMtpAuxHv = ZERO_HASH.bigInt().toString();
+        s.issuerAuthClaimNonRevMtpNoAux = zero$1;
+        s.issuerAuthState = zero$1;
+    }
+    // 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 Proof();
+        }
+        let treeState = this.claim.nonRevProof.treeState;
+        if (this.proofType === ProofType.BJJSignature && this.skipClaimRevocationCheck) {
+            treeState = this.claim.signatureProof?.issuerAuthNonRevProof.treeState;
+        }
+        if (!treeState) {
+            throw new Error(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 === 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 === ProofType.Iden3SparseMerkleTreeProof) {
+            s.proofType = '2';
+            const incProofTreeState = this.claim.incProof?.treeState;
+            if (!incProofTreeState) {
+                throw new Error(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 = Id.fromBigInt(BigInt(sVals[fieldIdx]));
+        fieldIdx++;
+        // - issuerState
+        this.issuerState = Hash$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 = Id.fromBigInt(BigInt(sVals[fieldIdx]));
+        fieldIdx++;
+        // - isRevocationChecked
+        this.isRevocationChecked = parseInt(sVals[fieldIdx]);
+        fieldIdx++;
+        // - issuerClaimNonRevState
+        this.issuerClaimNonRevState = Hash$1.fromString(sVals[fieldIdx]);
+        fieldIdx++;
+        //  - timestamp
+        this.timestamp = parseInt(sVals[fieldIdx]);
+        fieldIdx++;
+        //  - claimSchema
+        this.claimSchema = SchemaHash.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 = Id.fromBigInt(BigInt(sVals[fieldIdx]));
+        }
+        fieldIdx++;
+        // - nullifierSessionID
+        this.nullifierSessionID = BigInt(sVals[fieldIdx]);
+        return this;
+    }
+}
+
+const zero = '0';
+/**
+ * AtomicQueryV3OnChainInputs ZK private inputs for credentialAtomicQueryV3OnChain.circom
+ *
+ * @beta
+ * @class AtomicQueryV3OnChainInputs
+ * @extends {BaseConfig}
+ */
+class AtomicQueryV3OnChainInputs extends BaseConfig {
+    validate() {
+        if (!this.requestID) {
+            throw new Error(CircuitError.EmptyRequestID);
+        }
+        if (!this.claim.nonRevProof.proof) {
+            throw new Error(CircuitError.EmptyClaimNonRevProof);
+        }
+        if (!this.query.values) {
+            throw new Error(CircuitError.EmptyQueryValue);
+        }
+        if (!this.proofType) {
+            throw new Error(CircuitError.InvalidProofType);
+        }
+        if (!this.challenge) {
+            throw new Error(CircuitError.EmptyChallenge);
+        }
+        if (this.authEnabled === 1) {
+            if (!this.authClaimIncMtp) {
+                throw new Error(CircuitError.EmptyAuthClaimProof);
+            }
+            if (!this.authClaimNonRevMtp) {
+                throw new Error(CircuitError.EmptyAuthClaimNonRevProof);
+            }
+            if (!this.signature) {
+                throw new Error(CircuitError.EmptyChallengeSignature);
+            }
+            if (!this.gistProof.proof) {
+                throw new Error(CircuitError.EmptyGISTProof);
+            }
+        }
+        if (this.proofType === ProofType.BJJSignature) {
+            if (!this.claim.signatureProof?.issuerAuthIncProof.proof) {
+                throw new Error(CircuitError.EmptyIssuerAuthClaimProof);
+            }
+            if (!this.claim.signatureProof.issuerAuthNonRevProof.proof) {
+                throw new Error(CircuitError.EmptyIssuerAuthClaimNonRevProof);
+            }
+            if (!this.claim.signatureProof.signature) {
+                throw new Error(CircuitError.EmptyClaimSignature);
+            }
+        }
+        if (this.proofType === ProofType.Iden3SparseMerkleTreeProof) {
+            if (!this.claim?.incProof?.proof) {
+                throw new Error(CircuitError.EmptyClaimProof);
+            }
+        }
+    }
+    fillMTPProofsWithZero(s) {
+        s.issuerClaimMtp = prepareSiblingsStr(new Proof(), this.getMTLevel());
+        s.issuerClaimClaimsTreeRoot = ZERO_HASH.bigInt().toString();
+        s.issuerClaimRevTreeRoot = ZERO_HASH.bigInt().toString();
+        s.issuerClaimRootsTreeRoot = ZERO_HASH.bigInt().toString();
+        s.issuerClaimIdenState = ZERO_HASH.bigInt().toString();
+    }
+    fillSigProofWithZero(s) {
+        s.issuerClaimSignatureR8x = zero;
+        s.issuerClaimSignatureR8y = zero;
+        s.issuerClaimSignatureS = zero;
+        s.issuerAuthClaim = new Claim().marshalJson();
+        s.issuerAuthClaimMtp = prepareSiblingsStr(new Proof(), this.getMTLevel());
+        s.issuerAuthClaimsTreeRoot = zero;
+        s.issuerAuthRevTreeRoot = zero;
+        s.issuerAuthRootsTreeRoot = zero;
+        s.issuerAuthClaimNonRevMtp = prepareSiblingsStr(new Proof(), this.getMTLevel());
+        s.issuerAuthClaimNonRevMtpAuxHi = ZERO_HASH.bigInt().toString();
+        s.issuerAuthClaimNonRevMtpAuxHv = ZERO_HASH.bigInt().toString();
+        s.issuerAuthClaimNonRevMtpNoAux = zero;
+        s.issuerAuthState = zero;
+    }
+    fillAuthWithZero(s) {
+        s.authClaim = new Claim().marshalJson();
+        s.userClaimsTreeRoot = ZERO_HASH.bigInt().toString();
+        s.userRevTreeRoot = ZERO_HASH.bigInt().toString();
+        s.userRootsTreeRoot = ZERO_HASH.bigInt().toString();
+        s.userState = ZERO_HASH.bigInt().toString();
+        s.authClaimIncMtp = prepareSiblingsStr(new Proof(), this.getMTLevel());
+        s.authClaimNonRevMtp = prepareSiblingsStr(new Proof(), this.getMTLevel());
+        s.challengeSignatureR8x = zero;
+        s.challengeSignatureR8y = zero;
+        s.challengeSignatureS = zero;
+        s.gistRoot = ZERO_HASH.bigInt().toString();
+        s.gistMtp = prepareSiblingsStr(new Proof(), this.getMTLevelOnChain());
+        s.authClaimNonRevMtpAuxHi = ZERO_HASH.bigInt().toString();
+        s.authClaimNonRevMtpAuxHv = ZERO_HASH.bigInt().toString();
+        s.authClaimNonRevMtpNoAux = zero;
+        s.gistMtpAuxHi = ZERO_HASH.bigInt().toString();
+        s.gistMtpAuxHv = ZERO_HASH.bigInt().toString();
+        s.gistMtpNoAux = zero;
+    }
+    // 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 Proof();
+        }
+        const treeState = this.claim.nonRevProof.treeState;
+        if (!treeState) {
+            throw new Error(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 === 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(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 === ProofType.Iden3SparseMerkleTreeProof) {
+            s.proofType = '2';
+            const incProofTreeState = this.claim.incProof?.treeState;
+            if (!incProofTreeState) {
+                throw new Error(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 = Id.fromBigInt(BigInt(sVals[fieldIdx]));
+        fieldIdx++;
+        // - circuitQueryHash
+        this.circuitQueryHash = BigInt(sVals[fieldIdx]);
+        fieldIdx++;
+        // - issuerState
+        this.issuerState = Hash$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 = Hash$1.fromString(sVals[fieldIdx]);
+        fieldIdx++;
+        // - issuerID
+        this.issuerID = Id.fromBigInt(BigInt(sVals[fieldIdx]));
+        fieldIdx++;
+        // - isRevocationChecked
+        this.isRevocationChecked = parseInt(sVals[fieldIdx]);
+        fieldIdx++;
+        // - issuerClaimNonRevState
+        this.issuerClaimNonRevState = Hash$1.fromString(sVals[fieldIdx]);
+        fieldIdx++;
+        //  - timestamp
+        this.timestamp = parseInt(sVals[fieldIdx]);
+        fieldIdx++;
+        // - verifierID
+        if (sVals[fieldIdx] !== '0') {
+            this.verifierID = Id.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
  *
@@ -56208,9 +56915,9 @@ class AtomicQuerySigV2OnChainInputs extends BaseConfig {
             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,
@@ -56506,6 +57213,179 @@ class StateTransitionPubSignals {
     }
 }
 
+/**
+ * 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 = Id.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: [
@@ -58260,6 +59140,25 @@ function buildRevocationMessageRequest(from, to, revocationNonce) {
     };
 }
 
+/**
+ * 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 DID.parse(credential.credentialSubject.id);
+};
+
 // ErrAllClaimsRevoked all claims are revoked.
 const ErrAllClaimsRevoked = 'all claims are revoked';
 /**
@@ -58355,16 +59254,7 @@ class CredentialWallet {
             ? mtpProof.issuerData.state
             : sigProof?.issuerData.state;
         const issuerDID = DID.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 = DID.parse(cred.credentialSubject.id);
-        }
+        const userDID = getUserDIDFromCredential(issuerDID, cred);
         const opts = {
             issuerGenesisState: stateInfo,
             issuerDID,
@@ -59407,6 +60297,17 @@ var SearchError;
 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;
     }
@@ -59415,14 +60316,65 @@ const equalsComparator = (a, b) => {
     }
     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
@@ -59506,8 +60458,6 @@ const StandardJSONCredentialsQueryFilter = (query) => {
                 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];
@@ -59525,8 +60475,13 @@ const StandardJSONCredentialsQueryFilter = (query) => {
                 }, []);
                 return acc.concat(reqFilters);
             }
+            case 'proofType':
+            case 'groupId':
+            case 'skipClaimRevocationCheck': {
+                return acc;
+            }
             default:
-                throw new Error(SearchError.NotDefinedQueryKey);
+                throw new Error(`${queryKey} : ${SearchError.NotDefinedQueryKey}`);
         }
     }, []);
 };
@@ -60225,6 +61180,18 @@ class FSCircuitStorage {
  * @returns {ClaimNonRevStatus}
  */
 const toClaimNonRevStatus = (s) => {
+    if (!s) {
+        const hash = poseidon.hash(new Array(3).fill(0n));
+        return {
+            proof: new Proof(),
+            treeState: {
+                state: Hash$1.fromBigInt(hash),
+                claimsRoot: ZERO_HASH,
+                revocationRoot: ZERO_HASH,
+                rootOfRoots: ZERO_HASH
+            }
+        };
+    }
     return {
         proof: s.mtp,
         treeState: buildTreeState(s.issuer.state, s.issuer.claimsTreeRoot, s.issuer.revocationTreeRoot, s.issuer.rootOfRoots)
@@ -60258,6 +61225,88 @@ const toGISTProof = (smtProof) => {
         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 Path.newTypeFromContext(ldContextJSON, `${credentialType}.${propertyQuery.fieldName}`, options);
+    const query = {
+        ...propertyQuery,
+        slotIndex: 0,
+        merklizedSchema: false,
+        datatype: datatype,
+        claimPathKey: BigInt(0),
+        values: [],
+        path: new Path()
+    };
+    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 Merklizer.hashValue(ldType, value[index]);
+        }
+    }
+    else {
+        values[0] = await Merklizer.hashValue(ldType, value);
+    }
+    return values;
+};
 
 /* eslint-disable require-await */
 /* eslint-disable @typescript-eslint/no-explicit-any */
@@ -60604,6 +61653,391 @@ class NativeProver {
 }
 NativeProver.curveName = 'bn128';
 
+const circuitValidator = {
+    [CircuitId.AtomicQueryMTPV2]: { maxQueriesCount: 1 },
+    [CircuitId.AtomicQueryMTPV2OnChain]: { maxQueriesCount: 1 },
+    [CircuitId.AtomicQuerySigV2]: { maxQueriesCount: 1 },
+    [CircuitId.AtomicQuerySigV2OnChain]: { maxQueriesCount: 1 },
+    [CircuitId.AtomicQueryV3]: { maxQueriesCount: 1 },
+    [CircuitId.AtomicQueryV3OnChain]: { maxQueriesCount: 1 },
+    [CircuitId.AuthV2]: { maxQueriesCount: 0 },
+    [CircuitId.StateTransition]: { maxQueriesCount: 0 },
+    [CircuitId.LinkedNullifier]: { maxQueriesCount: 1 },
+    [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 = DID.idFromDID(identifier);
+            circuitInputs.requestID = BigInt(proofReq.id);
+            const query = circuitQueries[0];
+            query.operator = query.operator === Operators.SD ? 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 = getUnixTimestamp(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 = DID.idFromDID(identifier);
+            circuitInputs.id = DID.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 === Operators.SD ? 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 = getUnixTimestamp(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 = DID.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 === Operators.SD ? Operators.EQ : query.operator;
+            circuitInputs.query = query;
+            circuitInputs.currentTimeStamp = getUnixTimestamp(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 = DID.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 === Operators.SD ? Operators.EQ : query.operator;
+            circuitInputs.query = query;
+            circuitInputs.currentTimeStamp = getUnixTimestamp(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 ProofType.BJJSignature:
+                    proofType = ProofType.BJJSignature;
+                    break;
+                case ProofType.Iden3SparseMerkleTreeProof:
+                    proofType = ProofType.Iden3SparseMerkleTreeProof;
+                    break;
+                default:
+                    if (circuitClaimData.proof) {
+                        proofType = ProofType.Iden3SparseMerkleTreeProof;
+                    }
+                    else if (circuitClaimData.signatureProof) {
+                        proofType = ProofType.BJJSignature;
+                    }
+                    else {
+                        throw Error('claim has no MTP or signature proof');
+                    }
+                    break;
+            }
+            const circuitInputs = new AtomicQueryV3Inputs();
+            circuitInputs.id = DID.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 === Operators.SD ? new Array(64).fill(0) : query.values;
+            circuitInputs.query = query;
+            circuitInputs.currentTimeStamp = getUnixTimestamp(new Date());
+            circuitInputs.proofType = proofType;
+            circuitInputs.linkNonce = params.linkNonce ?? BigInt(0);
+            circuitInputs.verifierID = params.verifierDid ? DID.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 ProofType.BJJSignature:
+                    proofType = ProofType.BJJSignature;
+                    break;
+                case ProofType.Iden3SparseMerkleTreeProof:
+                    proofType = ProofType.Iden3SparseMerkleTreeProof;
+                    break;
+                default:
+                    if (circuitClaimData.proof) {
+                        proofType = ProofType.Iden3SparseMerkleTreeProof;
+                    }
+                    else if (circuitClaimData.signatureProof) {
+                        proofType = ProofType.BJJSignature;
+                    }
+                    else {
+                        throw Error('claim has no MTP or signature proof');
+                    }
+                    break;
+            }
+            const circuitInputs = new AtomicQueryV3OnChainInputs();
+            circuitInputs.id = DID.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 === Operators.SD ? new Array(64).fill(0) : query.values;
+            circuitInputs.query = query;
+            circuitInputs.currentTimeStamp = getUnixTimestamp(new Date());
+            circuitInputs.proofType = proofType;
+            circuitInputs.linkNonce = params.linkNonce ?? BigInt(0);
+            circuitInputs.verifierID = params.verifierDid ? DID.idFromDID(params.verifierDid) : undefined;
+            circuitInputs.nullifierSessionID = proofReq.params?.nullifierSessionID
+                ? BigInt(proofReq.params?.nullifierSessionID?.toString())
+                : BigInt(0);
+            let isEthIdentity = true;
+            try {
+                Id.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 = DID.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 = DID.idFromDID(identifier);
+            circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
+            circuitInputs.verifierID = params.verifierDid ? DID.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 = DID.idFromDID(DID.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(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
@@ -60626,6 +62060,7 @@ class ProofService {
         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) {
@@ -60639,20 +62074,61 @@ class ProofService {
                 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 = DID.parse(preparedCredential.credential.credentialSubject['id']);
         const { nonce: credentialSubjectProfileNonce, genesisDID: subjectGenesisDID } = await this._identityWallet.getGenesisDIDMetadata(subjectDID);
         if (subjectGenesisDID.string() !== genesisDID.string()) {
             throw new Error('subject and auth profiles are not derived from the same did');
         }
-        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 !== MerklizedRootPosition$1.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 === 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,
@@ -60664,7 +62140,7 @@ class ProofService {
     }
     /** {@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();
@@ -60676,17 +62152,17 @@ class ProofService {
             rootOfRoots
         };
         const challenge = Poseidon.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 = DID.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
         };
@@ -60696,370 +62172,65 @@ class ProofService {
         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 generateInputs(preparedCredential, identifier, proofReq, params, circuitQueries) {
+        return this._inputsGenerator.generateInputs({
+            preparedCredential,
+            identifier,
+            proofReq,
+            params,
+            circuitQueries
+        });
     }
-    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(ProofType.Iden3SparseMerkleTreeProof);
-        if (!authCoreClaim) {
-            throw new Error('auth core claim is not defined for auth bjj credential');
+    async toCircuitsQuery(credential, queryMetadata, merklizedCredential) {
+        if (queryMetadata.merklizedSchema && !merklizedCredential) {
+            throw new Error('merklized root position is set to None for merklized schema');
         }
-        return { authCredential, incProof, nonRevProof, authCoreClaim };
-    }
-    async generateInputs(preparedCredential, identifier, proofReq, params) {
-        let generateInputFn;
-        switch (proofReq.circuitId) {
-            case CircuitId.AtomicQueryMTPV2:
-                generateInputFn = this.generateMTPV2Inputs.bind(this);
-                break;
-            case CircuitId.AtomicQueryMTPV2OnChain:
-                generateInputFn = this.generateMTPV2OnChainInputs.bind(this);
-                break;
-            case CircuitId.AtomicQuerySigV2:
-                generateInputFn = this.generateQuerySigV2Inputs.bind(this);
-                break;
-            case 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 = DID.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 = getUnixTimestamp(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 = DID.idFromDID(identifier);
-        circuitInputs.id = DID.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
-            };
+        if (!queryMetadata.merklizedSchema && merklizedCredential) {
+            throw new Error('merklized root position is not set to None for non-merklized schema');
         }
-        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 = getUnixTimestamp(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 = DID.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 = getUnixTimestamp(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 = DID.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 = getUnixTimestamp(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 };
-    }
-    // NewCircuitClaimData generates circuits claim structure
-    async newCircuitClaimData(credential, coreClaim) {
-        const smtProof = credential.getIden3SparseMerkleTreeProof();
-        const circuitClaim = new CircuitClaim();
-        circuitClaim.claim = coreClaim;
-        circuitClaim.issuerId = DID.idFromDID(DID.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
-            };
-        }
-        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 = DID.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
-            };
-        }
-        return circuitClaim;
-    }
-    async toCircuitsQuery(query, credential, coreClaim) {
-        const mtPosition = coreClaim.getMerklizedPosition();
-        return mtPosition === MerklizedRootPosition$1.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 Path();
-        if (parsedQuery.fieldName) {
-            path = await Path.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 === 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 = getDocumentLoader(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 Merklizer.hashValue(ldType, value[index]);
-            }
-        }
-        else {
-            values[0] = await Merklizer.hashValue(ldType, value);
-        }
-        return values;
-    }
     /** {@inheritdoc IProofService.generateAuthV2Inputs} */
     async generateAuthV2Inputs(hash, did, circuitId) {
         if (circuitId !== CircuitId.AuthV2) {
@@ -61067,9 +62238,12 @@ class ProofService {
         }
         const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(did);
         const challenge = BytesHelper.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 = DID.idFromDID(genesisDID);
         const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
         const gistProof = toGISTProof(stateProof);
@@ -61105,7 +62279,7 @@ class ProofService {
         }
         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`);
@@ -61113,18 +62287,11 @@ class ProofService {
         //  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 = Hex.decodeString(sigHex);
-    const compressedSig = Uint8Array.from(signatureBytes).slice(0, 64);
-    const bjjSig = Signature$5.newFromCompressed(compressedSig);
-    return bjjSig;
-};
 
 /**
  * creates empty basic message
@@ -61776,15 +62943,55 @@ class AuthHandler {
             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 = getRandomBytes(12);
+                const dataView = new DataView(seed.buffer);
+                const linkNonce = dataView.getUint32(0);
+                acc.set(groupId, { query: proofReq.query, linkNonce });
+                return acc;
+            }
+            const credentialSubject = mergeObjects(existedData.query.credentialSubject, proofReq.query.credentialSubject);
+            acc.set(groupId, {
+                ...existedData,
+                query: {
+                    skipClaimRevocationCheck: existedData.query.skipClaimRevocationCheck || proofReq.query.skipClaimRevocationCheck,
+                    ...existedData.query,
+                    credentialSubject
+                }
+            });
+            return acc;
+        }, new Map());
+        const groupedCredentialsCache = new Map();
+        for (const proofReq of requestScope) {
             const query = proofReq.query;
-            const 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);
         }
@@ -61918,7 +63125,8 @@ class ContractRequestHandler {
         this._zkpVerifier = _zkpVerifier;
         this._allowedCircuits = [
             CircuitId.AtomicQueryMTPV2OnChain,
-            CircuitId.AtomicQuerySigV2OnChain
+            CircuitId.AtomicQuerySigV2OnChain,
+            CircuitId.AtomicQueryV3OnChain
         ];
     }
     /**
@@ -61952,19 +63160,28 @@ class ContractRequestHandler {
             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(ChainIds).find((key) => ChainIds[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: DidMethod.Iden3
+        });
+        const verifierDid = DID.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);
         }
@@ -61972,5 +63189,5 @@ class ContractRequestHandler {
     }
 }
 
-export { AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DataPrepareHandlerFunc, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, NativeProver, OnChainResolver, OnChainZKPVerifier, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, Query, QueryOperators, RHSResolver, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, ZKPPacker, bJJSignatureFromHexString, base58ToBytes, base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, buildQueryPath, buildTreeState, byteDecoder, byteEncoder, bytesToBase58, bytesToBase64, bytesToBase64url, bytesToHex$1 as bytesToHex, cacheLoader, checkDataInField, comparatorOptions, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaimsMerklization, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fillSlot, generateProfileDID, getNodeAuxValue, getProperties, hexToBytes$1 as hexToBytes, isGenesisState, isGenesisStateId, isIssuerGenesis, keyPath, prepareCircuitArrayValues, prepareSiblingsStr, pushHashesToRHS, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, verifiablePresentationFromCred };
+export { AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DataPrepareHandlerFunc, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LinkedNullifierInputs, LinkedNullifierPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, NativeProver, OnChainResolver, OnChainZKPVerifier, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, Query, QueryOperators, RHSResolver, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes, base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58, bytesToBase64, bytesToBase64url, bytesToHex$1 as bytesToHex, cacheLoader, checkDataInField, comparatorOptions, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fillSlot, findValue, generateProfileDID, getNodeAuxValue, getProperties, getUserDIDFromCredential, hexToBytes$1 as hexToBytes, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, prepareCircuitArrayValues, prepareSiblingsStr, pushHashesToRHS, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts };
 //# sourceMappingURL=index.js.map