@0xpolygonid/js-sdk 1.8.2 → 1.9.0

package/dist/node/esm/circuits/linked-multi-query.js

@@ -1,6 +1,6 @@
 import { Proof } from '@iden3/js-merkletree';
 import { byteDecoder, byteEncoder } from '../utils';
-import { BaseConfig, bigIntArrayToStringArray, existenceToInt, getNodeAuxValue, prepareCircuitArrayValues, prepareSiblingsStr } from './common';
+import { BaseConfig, bigIntArrayToStringArray, getNodeAuxValue, prepareCircuitArrayValues, prepareSiblingsStr } from './common';
 import { ValueProof } from './models';
 /**
  * LinkedMultiQuery circuit representation
@@ -12,8 +12,6 @@ import { ValueProof } from './models';
 export class LinkedMultiQueryInputs extends BaseConfig {
     // InputsMarshal returns Circom private inputs for linkedMultiQueryInputs.circom
     inputsMarshal() {
-        const enabled = [];
-        const claimPathNotExists = [];
         const claimPathMtp = [];
         const claimPathMtpNoAux = [];
         const claimPathMtpAuxHi = [];
@@ -23,10 +21,9 @@ export class LinkedMultiQueryInputs extends BaseConfig {
         const slotIndex = [];
         const operator = [];
         const value = [];
+        const valueArraySize = [];
         for (let i = 0; i < LinkedMultiQueryInputs.queryCount; i++) {
             if (!this.query[i]) {
-                enabled.push(0);
-                claimPathNotExists.push(0);
                 claimPathMtp.push(new Array(this.getMTLevelsClaim()).fill('0'));
                 claimPathMtpNoAux.push('0');
                 claimPathMtpAuxHi.push('0');
@@ -37,9 +34,9 @@ export class LinkedMultiQueryInputs extends BaseConfig {
                 operator.push(0);
                 const valuesArr = prepareCircuitArrayValues([], this.getValueArrSize());
                 value.push(bigIntArrayToStringArray(valuesArr));
+                valueArraySize.push(0);
                 continue;
             }
-            enabled.push(1);
             let valueProof = this.query[i].valueProof;
             if (!valueProof) {
                 valueProof = new ValueProof();
@@ -47,7 +44,6 @@ export class LinkedMultiQueryInputs extends BaseConfig {
                 valueProof.value = 0n;
                 valueProof.mtp = new Proof();
             }
-            claimPathNotExists.push(existenceToInt(valueProof.mtp.existence));
             claimPathMtp.push(prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaim()));
             const nodAuxJSONLD = getNodeAuxValue(valueProof.mtp);
             claimPathMtpNoAux.push(nodAuxJSONLD.noAux);
@@ -57,15 +53,14 @@ export class LinkedMultiQueryInputs extends BaseConfig {
             claimPathValue.push(valueProof.value.toString());
             slotIndex.push(this.query[i].slotIndex);
             operator.push(this.query[i].operator);
+            valueArraySize.push(this.query[i].values.length);
             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,
@@ -74,7 +69,8 @@ export class LinkedMultiQueryInputs extends BaseConfig {
             claimPathValue,
             slotIndex,
             operator,
-            value
+            value,
+            valueArraySize
         };
         return byteEncoder.encode(JSON.stringify(s));
     }
@@ -96,7 +92,7 @@ export class LinkedMultiQueryPubSignals {
      * @returns LinkedMultiQueryPubSignals
      */
     pubSignalsUnmarshal(data) {
-        const len = 32;
+        const len = 22;
         const queryLength = LinkedMultiQueryInputs.queryCount;
         const sVals = JSON.parse(byteDecoder.decode(data));
         if (sVals.length !== len) {
@@ -121,13 +117,6 @@ export class LinkedMultiQueryPubSignals {
             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;
     }
 }

package/dist/node/esm/circuits/models.js

@@ -1,5 +1,5 @@
 import { Proof } from '@iden3/js-merkletree';
-import { QueryOperators } from './comparer';
+import { Operators, QueryOperators } from './comparer';
 /**
  * Query represents basic request to claim slot verification
  *
@@ -17,6 +17,48 @@ export class Query {
             this.values?.some((v) => typeof v !== 'bigint'))
             throw new Error(CircuitError.EmptyQueryValue);
     }
+    validateValueArraySize(maxArrSize) {
+        switch (this.values.length) {
+            case 0: {
+                const zeroArrSizeOps = [Operators.NOOP, Operators.SD, Operators.NULLIFY];
+                if (!zeroArrSizeOps.includes(this.operator)) {
+                    throw new Error(CircuitError.InvalidValuesArrSize);
+                }
+                return;
+            }
+            case 1: {
+                const oneArrSizeOps = [
+                    Operators.EQ,
+                    Operators.LT,
+                    Operators.GT,
+                    Operators.NE,
+                    Operators.LTE,
+                    Operators.GTE,
+                    Operators.EXISTS
+                ];
+                if (!oneArrSizeOps.includes(this.operator)) {
+                    throw new Error(CircuitError.InvalidValuesArrSize);
+                }
+                return;
+            }
+            case 2: {
+                const twoArrSizeOps = [Operators.BETWEEN, Operators.NONBETWEEN];
+                if (!twoArrSizeOps.includes(this.operator)) {
+                    throw new Error(CircuitError.InvalidValuesArrSize);
+                }
+                return;
+            }
+            default: {
+                const maxArrSizeOps = [Operators.IN, Operators.NIN];
+                if (!maxArrSizeOps.includes(this.operator)) {
+                    throw new Error(CircuitError.InvalidOperationType);
+                }
+                if (!this.values.length || this.values.length > maxArrSize) {
+                    throw new Error(CircuitError.InvalidValuesArrSize);
+                }
+            }
+        }
+    }
 }
 /**
  * CircuitID is alias for circuit identifier
@@ -41,17 +83,17 @@ export var CircuitId;
      * @beta
      */
     // AtomicQueryV3CircuitID is a type for credentialAtomicQueryV3.circom
-    CircuitId["AtomicQueryV3"] = "credentialAtomicQueryV3-beta.0";
+    CircuitId["AtomicQueryV3"] = "credentialAtomicQueryV3-beta.1";
     /**
      * @beta
      */
     // AtomicQueryV3OnChainCircuitID is a type for credentialAtomicQueryV3OnChain.circom
-    CircuitId["AtomicQueryV3OnChain"] = "credentialAtomicQueryV3OnChain-beta.0";
+    CircuitId["AtomicQueryV3OnChain"] = "credentialAtomicQueryV3OnChain-beta.1";
     /**
      * @beta
      */
     // LinkedMultiQuery is a type for linkedMultiQuery.circom
-    CircuitId["LinkedMultiQuery10"] = "linkedMultiQuery10-beta.0";
+    CircuitId["LinkedMultiQuery10"] = "linkedMultiQuery10-beta.1";
 })(CircuitId || (CircuitId = {}));
 /**
  * Claim structure for circuit inputs
@@ -88,6 +130,8 @@ export var CircuitError;
     CircuitError["EmptyTreeState"] = "empty tree state";
     CircuitError["EmptyRequestID"] = "empty request ID";
     CircuitError["InvalidProofType"] = "invalid proof type";
+    CircuitError["InvalidValuesArrSize"] = "invalid query Values array size";
+    CircuitError["InvalidOperationType"] = "invalid operation type";
 })(CircuitError || (CircuitError = {}));
 /**
  * ValueProof represents a Merkle Proof for a value stored as MT

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

@@ -69,6 +69,7 @@ export class AuthHandler {
         if (message.type !== PROTOCOL_MESSAGE_TYPE.AUTHORIZATION_REQUEST_MESSAGE_TYPE) {
             throw new Error('Invalid media type');
         }
+        authRequest.body.scope = authRequest.body.scope || [];
         return authRequest;
     }
     /**
@@ -180,7 +181,8 @@ export class AuthHandler {
             throw new Error(`sender of the request is not a target of response - expected ${request.from}, given ${response.to}`);
         }
         this.verifyAuthRequest(request);
-        const requestScope = request.body.scope;
+        const requestScope = request.body.scope || [];
+        const responseScope = response.body.scope || [];
         if (!response.from) {
             throw new Error(`proof response doesn't contain from field`);
         }
@@ -188,7 +190,7 @@ export class AuthHandler {
         // group requests by query group id
         for (const proofRequest of requestScope) {
             const groupId = proofRequest.query.groupId;
-            const proofResp = response.body.scope.find((resp) => resp.id === proofRequest.id);
+            const proofResp = responseScope.find((resp) => resp.id === proofRequest.id);
             if (!proofResp) {
                 throw new Error(`proof is not given for requestId ${proofRequest.id}`);
             }
@@ -224,7 +226,7 @@ export class AuthHandler {
     }
     verifyAuthRequest(request) {
         const groupIdValidationMap = {};
-        const requestScope = request.body.scope;
+        const requestScope = request.body.scope || [];
         for (const proofRequest of requestScope) {
             const groupId = proofRequest.query.groupId;
             if (groupId) {

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

@@ -1,7 +1,6 @@
 import { CircuitId } from '../../circuits/models';
 import { PROTOCOL_MESSAGE_TYPE } from '../constants';
-import { DID, ChainIds, DidMethod } from '@iden3/js-iden3-core';
-import { buildVerifierId } from '../../utils';
+import { DID, ChainIds } from '@iden3/js-iden3-core';
 /**
  *
  * Allows to process ContractInvokeRequest protocol message
@@ -41,6 +40,7 @@ export class ContractRequestHandler {
         if (message.type !== PROTOCOL_MESSAGE_TYPE.CONTRACT_INVOKE_REQUEST_MESSAGE_TYPE) {
             throw new Error('Invalid media type');
         }
+        ciRequest.body.scope = ciRequest.body.scope || [];
         return ciRequest;
     }
     /**
@@ -60,19 +60,11 @@ export 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 { 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.`);
@@ -81,7 +73,7 @@ export class ContractRequestHandler {
             const zkpRes = await this._proofService.generateProof(proofReq, did, {
                 skipRevocation: query.skipClaimRevocationCheck ?? false,
                 challenge: opts.challenge,
-                verifierDid
+                verifierDid: ciRequest.from ? DID.parse(ciRequest.from) : undefined
             });
             zkRequests.push(zkpRes);
         }

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

@@ -1,5 +1,5 @@
 import { Hash, Proof, ZERO_HASH } from '@iden3/js-merkletree';
-import { buildTreeState, isValidOperation, QueryOperators } from '../circuits';
+import { buildTreeState, isValidOperation, Operators, QueryOperators, XSDNS } from '../circuits';
 import { buildFieldPath, getSerializationAttrFromContext, getFieldSlotIndex } from '../verifiable';
 import { Merklizer, Path } from '@iden3/js-jsonld-merklization';
 import { byteEncoder } from '../utils';
@@ -84,16 +84,21 @@ export const parseCredentialSubject = (credentialSubject) => {
     return queries;
 };
 export 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,
+        datatype: '',
         claimPathKey: BigInt(0),
         values: [],
         path: new Path()
     };
+    if (!propertyQuery.fieldName && propertyQuery.operator !== Operators.NOOP) {
+        throw new Error('query must have a field name if operator is not $noop');
+    }
+    if (propertyQuery.fieldName) {
+        query.datatype = await Path.newTypeFromContext(ldContextJSON, `${credentialType}.${propertyQuery.fieldName}`, options);
+    }
     const serAttr = await getSerializationAttrFromContext(JSON.parse(ldContextJSON), options, credentialType);
     if (!serAttr) {
         query.merklizedSchema = true;
@@ -115,9 +120,10 @@ export const parseQueryMetadata = async (propertyQuery, ldContextJSON, credentia
         }
     }
     if (propertyQuery.operatorValue) {
-        if (!isValidOperation(datatype, propertyQuery.operator)) {
-            throw new Error(`operator ${propertyQuery.operator} is not supported for datatype ${datatype}`);
+        if (!isValidOperation(query.datatype, propertyQuery.operator)) {
+            throw new Error(`operator ${propertyQuery.operator} is not supported for datatype ${query.datatype}`);
         }
+        const datatype = propertyQuery.operator === Operators.EXISTS ? XSDNS.Boolean : query.datatype;
         query.values = await transformQueryValueToBigInts(propertyQuery.operatorValue, datatype);
     }
     return query;
@@ -127,7 +133,7 @@ export const parseQueriesMetadata = async (credentialType, ldContextJSON, creden
     return Promise.all(queriesMetadata.map((m) => parseQueryMetadata(m, ldContextJSON, credentialType, options)));
 };
 export const transformQueryValueToBigInts = async (value, ldType) => {
-    const values = new Array(64).fill(BigInt(0));
+    const values = [];
     if (Array.isArray(value)) {
         for (let index = 0; index < value.length; index++) {
             values[index] = await Merklizer.hashValue(ldType, value[index]);

package/dist/node/esm/proof/provers/inputs-generator.js

@@ -1,6 +1,6 @@
 import { DID, Id, getUnixTimestamp } from '@iden3/js-iden3-core';
 import { ProofType } from '../../verifiable';
-import { AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainInputs, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, CircuitClaim, CircuitId, defaultValueArraySize, LinkedMultiQueryInputs, Operators, QueryOperators } from '../../circuits';
+import { AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainInputs, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, CircuitClaim, CircuitId, LinkedMultiQueryInputs, Operators, QueryOperators, ValueProof } from '../../circuits';
 import { toClaimNonRevStatus, toGISTProof } from '../common';
 import { getUserDIDFromCredential } from '../../credentials';
 const allOperations = Object.values(QueryOperators);
@@ -202,10 +202,8 @@ export class InputGenerator {
             circuitInputs.profileNonce = BigInt(params.authProfileNonce);
             circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
             const query = circuitQueries[0];
-            query.values =
-                query.operator === Operators.SD || query.operator === Operators.NOOP
-                    ? new Array(defaultValueArraySize).fill(0)
-                    : query.values;
+            query.values = [Operators.SD, Operators.NOOP].includes(query.operator) ? [] : query.values;
+            query.valueProof = query.operator === Operators.NOOP ? new ValueProof() : query.valueProof;
             circuitInputs.query = query;
             circuitInputs.currentTimeStamp = getUnixTimestamp(new Date());
             circuitInputs.proofType = proofType;
@@ -253,10 +251,8 @@ export class InputGenerator {
             circuitInputs.profileNonce = BigInt(params.authProfileNonce);
             circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
             const query = circuitQueries[0];
-            query.values =
-                query.operator === Operators.SD || query.operator === Operators.NOOP
-                    ? new Array(defaultValueArraySize).fill(0)
-                    : query.values;
+            query.values = [Operators.SD, Operators.NOOP].includes(query.operator) ? [] : query.values;
+            query.valueProof = query.operator === Operators.NOOP ? new ValueProof() : query.valueProof;
             circuitInputs.query = query;
             circuitInputs.currentTimeStamp = getUnixTimestamp(new Date());
             circuitInputs.proofType = proofType;
@@ -272,7 +268,7 @@ export class InputGenerator {
             catch {
                 isEthIdentity = false;
             }
-            circuitInputs.authEnabled = isEthIdentity ? 0 : 1;
+            circuitInputs.isBJJAuthEnabled = isEthIdentity ? 0 : 1;
             circuitInputs.challenge = BigInt(params.challenge ?? 0);
             const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(identifier);
             const id = DID.idFromDID(genesisDID);
@@ -280,7 +276,7 @@ export class InputGenerator {
             const gistProof = toGISTProof(stateProof);
             circuitInputs.gistProof = gistProof;
             // auth inputs
-            if (circuitInputs.authEnabled === 1) {
+            if (circuitInputs.isBJJAuthEnabled === 1) {
                 const authPrepared = await this.prepareAuthBJJCredential(genesisDID);
                 const authClaimData = await this.newCircuitClaimData({
                     credential: authPrepared.credential,

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

@@ -1,2 +1,3 @@
 export * from './pub-signals-verifier';
 export * from './query';
+export * from './query-hash';

package/dist/node/esm/proof/verifiers/pub-signals-verifier.js

@@ -1,17 +1,18 @@
-import { poseidon } from '@iden3/js-crypto';
 import { DID, getDateFromUnixTimestamp } from '@iden3/js-iden3-core';
 import { Path } from '@iden3/js-jsonld-merklization';
-import { bigIntCompare, byteEncoder, isGenesisState } from '../../utils';
-import { caclulateCoreSchemaHash, ProofType } from '../../verifiable';
+import { byteEncoder, isGenesisState } from '../../utils';
+import { calculateCoreSchemaHash, ProofType } from '../../verifiable';
 import { AtomicQueryMTPV2PubSignals } from '../../circuits/atomic-query-mtp-v2';
 import { AtomicQuerySigV2PubSignals } from '../../circuits/atomic-query-sig-v2';
 import { AtomicQueryV3PubSignals } from '../../circuits/atomic-query-v3';
 import { AuthV2PubSignals } from '../../circuits/auth-v2';
 import { BaseConfig } from '../../circuits/common';
-import { LinkedMultiQueryPubSignals } from '../../circuits/linked-multi-query';
+import { LinkedMultiQueryPubSignals, LinkedMultiQueryInputs } from '../../circuits/linked-multi-query';
 import { CircuitId } from '../../circuits/models';
-import { checkQueryRequest } from './query';
+import { checkQueryRequest, fieldValueFromVerifiablePresentation } from './query';
 import { parseQueriesMetadata } from '../common';
+import { Operators } from '../../circuits';
+import { calculateQueryHashV3 } from './query-hash';
 export const userStateError = new Error(`user state is not valid`);
 const zeroInt = 0n;
 const defaultProofVerifyOpts = 1 * 60 * 60 * 1000; // 1 hour
@@ -109,7 +110,6 @@ export class PubSignalsVerifier {
                 timestamp: v3PubSignals.timestamp,
                 merklized: v3PubSignals.merklized,
                 claimPathKey: v3PubSignals.claimPathKey,
-                claimPathNotExists: v3PubSignals.claimPathNotExists,
                 valueArraySize: v3PubSignals.getValueArrSize(),
                 isRevocationChecked: v3PubSignals.isRevocationChecked
             };
@@ -186,7 +186,7 @@ export class PubSignalsVerifier {
             this.verifyIdOwnership(sender, challenge);
             return new BaseConfig();
         };
-        this.linkedMultiQuery10Verify = async ({ query, pubSignals }) => {
+        this.linkedMultiQuery10Verify = async ({ query, verifiablePresentation, pubSignals }) => {
             let multiQueryPubSignals = new LinkedMultiQueryPubSignals();
             multiQueryPubSignals = multiQueryPubSignals.pubSignalsUnmarshal(byteEncoder.encode(JSON.stringify(pubSignals)));
             // verify query
@@ -200,26 +200,41 @@ export class PubSignalsVerifier {
             }
             const ldContextJSON = JSON.stringify(schema);
             const credentialSubject = query.credentialSubject;
-            const schemaId = await Path.getTypeIDFromContext(JSON.stringify(schema), query.type || '', ldOpts);
-            const schemaHash = caclulateCoreSchemaHash(byteEncoder.encode(schemaId));
+            const schemaId = await Path.getTypeIDFromContext(ldContextJSON, query.type || '', ldOpts);
+            const schemaHash = calculateCoreSchemaHash(byteEncoder.encode(schemaId));
             const queriesMetadata = await parseQueriesMetadata(query.type || '', ldContextJSON, credentialSubject, ldOpts);
-            const queryHashes = queriesMetadata.map((queryMeta) => {
-                const valueHash = poseidon.spongeHashX(queryMeta.values, 6);
-                return poseidon.hash([
-                    schemaHash.bigInt(),
-                    BigInt(queryMeta.slotIndex),
-                    BigInt(queryMeta.operator),
-                    BigInt(queryMeta.claimPathKey),
-                    queryMeta.merklizedSchema ? 0n : 1n,
-                    valueHash
-                ]);
-            });
-            const circuitQueryHashes = multiQueryPubSignals.circuitQueryHash
-                .filter((i) => i !== 0n)
-                .sort(bigIntCompare);
-            queryHashes.sort(bigIntCompare);
-            if (!queryHashes.every((queryHash, i) => queryHash === circuitQueryHashes[i])) {
-                throw new Error('query hashes do not match');
+            const request = [];
+            const merklized = queriesMetadata[0]?.merklizedSchema ? 1 : 0;
+            for (let i = 0; i < LinkedMultiQueryInputs.queryCount; i++) {
+                const queryMeta = queriesMetadata[i];
+                const values = queryMeta?.values ?? [];
+                const valArrSize = values.length;
+                const queryHash = calculateQueryHashV3(values, schemaHash, queryMeta?.slotIndex ?? 0, queryMeta?.operator ?? 0, queryMeta?.claimPathKey.toString() ?? 0, valArrSize, merklized, 0, 0, 0);
+                request.push({ queryHash, queryMeta });
+            }
+            const queryHashCompare = (a, b) => {
+                if (a.queryHash < b.queryHash)
+                    return -1;
+                if (a.queryHash > b.queryHash)
+                    return 1;
+                return 0;
+            };
+            const pubSignalsMeta = multiQueryPubSignals.circuitQueryHash.map((queryHash, index) => ({
+                queryHash,
+                operatorOutput: multiQueryPubSignals.operatorOutput[index]
+            }));
+            pubSignalsMeta.sort(queryHashCompare);
+            request.sort(queryHashCompare);
+            for (let i = 0; i < LinkedMultiQueryInputs.queryCount; i++) {
+                if (request[i].queryHash != pubSignalsMeta[i].queryHash) {
+                    throw new Error('query hashes do not match');
+                }
+                if (request[i].queryMeta?.operator === Operators.SD) {
+                    const disclosedValue = await fieldValueFromVerifiablePresentation(request[i].queryMeta.fieldName, verifiablePresentation, this._documentLoader);
+                    if (disclosedValue != pubSignalsMeta[i].operatorOutput) {
+                        throw new Error('disclosed value is not in the proof outputs');
+                    }
+                }
             }
             return multiQueryPubSignals;
         };

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

@@ -0,0 +1,35 @@
+import { poseidon } from '@iden3/js-crypto';
+import { defaultValueArraySize, prepareCircuitArrayValues } from '../../circuits';
+export function calculateQueryHashV2(values, schema, slotIndex, operator, claimPathKey, claimPathNotExists) {
+    const expValue = prepareCircuitArrayValues(values, 64);
+    const valueHash = poseidon.spongeHashX(expValue, 6);
+    return poseidon.hash([
+        schema.bigInt(),
+        BigInt(slotIndex),
+        BigInt(operator),
+        BigInt(claimPathKey),
+        BigInt(claimPathNotExists),
+        valueHash
+    ]);
+}
+export function calculateQueryHashV3(values, schema, slotIndex, operator, claimPathKey, valueArraySize, merklized, isRevocationChecked, verifierID, nullifierSessionID) {
+    const expValue = prepareCircuitArrayValues(values, defaultValueArraySize);
+    const valueHash = poseidon.spongeHashX(expValue, 6);
+    const firstPartQueryHash = poseidon.hash([
+        schema.bigInt(),
+        BigInt(slotIndex),
+        BigInt(operator),
+        BigInt(claimPathKey),
+        BigInt(merklized),
+        valueHash
+    ]);
+    const queryHash = poseidon.hash([
+        firstPartQueryHash,
+        BigInt(valueArraySize),
+        BigInt(isRevocationChecked),
+        BigInt(verifierID),
+        BigInt(nullifierSessionID),
+        0n
+    ]);
+    return queryHash;
+}

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

@@ -2,7 +2,7 @@ import { DID, getDateFromUnixTimestamp } from '@iden3/js-iden3-core';
 import { getDocumentLoader, Merklizer, Path } from '@iden3/js-jsonld-merklization';
 import { byteEncoder } from '../../utils';
 import { Operators } from '../../circuits/comparer';
-import { caclulateCoreSchemaHash, VerifiableConstants } from '../../verifiable';
+import { calculateCoreSchemaHash, VerifiableConstants } from '../../verifiable';
 import { parseQueriesMetadata } from '../common';
 import { circuitValidator } from '../provers';
 const defaultProofGenerationDelayOpts = 24 * 60 * 60 * 1000; // 24 hours
@@ -29,7 +29,7 @@ export async function checkQueryRequest(query, outputs, circuitId, schemaLoader,
     const schemaId = await Path.getTypeIDFromContext(JSON.stringify(schema), query.type, {
         documentLoader: schemaLoader
     });
-    const schemaHash = caclulateCoreSchemaHash(byteEncoder.encode(schemaId));
+    const schemaHash = calculateCoreSchemaHash(byteEncoder.encode(schemaId));
     if (schemaHash.bigInt() !== outputs.schemaHash.bigInt()) {
         throw new Error(`schema that was used is not equal to requested in query`);
     }
@@ -47,7 +47,8 @@ export async function checkQueryRequest(query, outputs, circuitId, schemaLoader,
     if (notSupportedOpIndx > -1) {
         throw new Error(`circuit ${circuitId} not support ${queriesMetadata[notSupportedOpIndx].operator} operator`);
     }
-    queriesMetadata.forEach(async (metadata) => {
+    for (let i = 0; i < queriesMetadata.length; i++) {
+        const metadata = queriesMetadata[i];
         if (!query.type) {
             throw new Error(`proof query type is undefined`);
         }
@@ -100,7 +101,7 @@ export async function checkQueryRequest(query, outputs, circuitId, schemaLoader,
         if (timeDiff > acceptedProofGenerationDelay) {
             throw new Error('generated proof is outdated');
         }
-    });
+    }
     return;
 }
 async function validateEmptyCredentialSubject(cq, outputs) {
@@ -129,14 +130,14 @@ async function validateOperators(cq, outputs) {
     }
     for (let index = 0; index < outputs.value.length; index++) {
         if (outputs.value[index] !== cq.values[index]) {
+            if (outputs.value[index] === 0n && cq.values[index] === undefined) {
+                continue;
+            }
             throw new Error(`comparison value that was used is not equal to requested in query`);
         }
     }
 }
 async function validateDisclosure(cq, outputs, verifiablePresentation, ldLoader) {
-    if (!verifiablePresentation) {
-        throw new Error(`verifiablePresentation is required for selective disclosure request`);
-    }
     if (outputs.operator !== Operators.EQ) {
         throw new Error(`operator for selective disclosure must be $eq`);
     }
@@ -145,6 +146,15 @@ async function validateDisclosure(cq, outputs, verifiablePresentation, ldLoader)
             throw new Error(`selective disclosure not available for array of values`);
         }
     }
+    const bi = await fieldValueFromVerifiablePresentation(cq.fieldName, verifiablePresentation, ldLoader);
+    if (bi !== outputs.value[0]) {
+        throw new Error(`value that was used is not equal to requested in query`);
+    }
+}
+export const fieldValueFromVerifiablePresentation = async (fieldName, verifiablePresentation, ldLoader) => {
+    if (!verifiablePresentation) {
+        throw new Error(`verifiablePresentation is required for selective disclosure request`);
+    }
     let mz;
     const strVerifiablePresentation = JSON.stringify(verifiablePresentation);
     try {
@@ -157,13 +167,13 @@ async function validateDisclosure(cq, outputs, verifiablePresentation, ldLoader)
     }
     let merklizedPath;
     try {
-        const p = `verifiableCredential.credentialSubject.${cq.fieldName}`;
+        const p = `verifiableCredential.credentialSubject.${fieldName}`;
         merklizedPath = await Path.fromDocument(null, strVerifiablePresentation, p, {
             documentLoader: ldLoader
         });
     }
     catch (e) {
-        throw new Error(`can't build path to '${cq.fieldName}' key`);
+        throw new Error(`can't build path to '${fieldName}' key`);
     }
     let proof;
     let value;
@@ -171,16 +181,13 @@ async function validateDisclosure(cq, outputs, verifiablePresentation, ldLoader)
         ({ proof, value } = await mz.proof(merklizedPath));
     }
     catch (e) {
-        throw new Error(`can't get value by path '${cq.fieldName}'`);
+        throw new Error(`can't get value by path '${fieldName}'`);
     }
     if (!value) {
-        throw new Error(`can't get merkle value for field '${cq.fieldName}'`);
+        throw new Error(`can't get merkle value for field '${fieldName}'`);
     }
     if (!proof.existence) {
         throw new Error(`path [${merklizedPath.parts}] doesn't exist in verifiablePresentation document`);
     }
-    const bi = await value.mtEntry();
-    if (bi !== outputs.value[0]) {
-        throw new Error(`value that was used is not equal to requested in query`);
-    }
-}
+    return await value.mtEntry();
+};

package/dist/node/esm/schema-processor/utils.js

@@ -1,5 +1,5 @@
 import { BytesHelper, checkBigIntInField } from '@iden3/js-iden3-core';
-import { caclulateCoreSchemaHash, fillCoreClaimSlot } from '../verifiable';
+import { calculateCoreSchemaHash, fillCoreClaimSlot } from '../verifiable';
 /**
  * SwapEndianness swaps the endianness of the value encoded in buf. If buf is
  * Big-Endian, the result will be Little-Endian and vice-versa.
@@ -48,14 +48,14 @@ export function checkDataInField(data) {
 }
 /**
  *
- * @deprecated The method should not be used. Use caclulateCoreSchemaHash from verifiable.
+ * @deprecated The method should not be used. Use calculateCoreSchemaHash from verifiable.
  * Calculates schema hash
  *
  * @param {Uint8Array} schemaId
  * @returns {*}  {SchemaHash}
  */
 export const createSchemaHash = (schemaId) => {
-    return caclulateCoreSchemaHash(schemaId);
+    return calculateCoreSchemaHash(schemaId);
 };
 /**
  *