@0xpolygonid/js-sdk 1.8.2 → 1.9.0

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PubSignalsVerifier = exports.userStateError = void 0;
-const js_crypto_1 = require("@iden3/js-crypto");
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const js_jsonld_merklization_1 = require("@iden3/js-jsonld-merklization");
 const utils_1 = require("../../utils");
@@ -15,6 +14,8 @@ const linked_multi_query_1 = require("../../circuits/linked-multi-query");
 const models_1 = require("../../circuits/models");
 const query_1 = require("./query");
 const common_2 = require("../common");
+const circuits_1 = require("../../circuits");
+const query_hash_1 = require("./query-hash");
 exports.userStateError = new Error(`user state is not valid`);
 const zeroInt = 0n;
 const defaultProofVerifyOpts = 1 * 60 * 60 * 1000; // 1 hour
@@ -112,7 +113,6 @@ class PubSignalsVerifier {
                 timestamp: v3PubSignals.timestamp,
                 merklized: v3PubSignals.merklized,
                 claimPathKey: v3PubSignals.claimPathKey,
-                claimPathNotExists: v3PubSignals.claimPathNotExists,
                 valueArraySize: v3PubSignals.getValueArrSize(),
                 isRevocationChecked: v3PubSignals.isRevocationChecked
             };
@@ -189,7 +189,7 @@ class PubSignalsVerifier {
             this.verifyIdOwnership(sender, challenge);
             return new common_1.BaseConfig();
         };
-        this.linkedMultiQuery10Verify = async ({ query, pubSignals }) => {
+        this.linkedMultiQuery10Verify = async ({ query, verifiablePresentation, pubSignals }) => {
             let multiQueryPubSignals = new linked_multi_query_1.LinkedMultiQueryPubSignals();
             multiQueryPubSignals = multiQueryPubSignals.pubSignalsUnmarshal(utils_1.byteEncoder.encode(JSON.stringify(pubSignals)));
             // verify query
@@ -203,26 +203,41 @@ class PubSignalsVerifier {
             }
             const ldContextJSON = JSON.stringify(schema);
             const credentialSubject = query.credentialSubject;
-            const schemaId = await js_jsonld_merklization_1.Path.getTypeIDFromContext(JSON.stringify(schema), query.type || '', ldOpts);
-            const schemaHash = (0, verifiable_1.caclulateCoreSchemaHash)(utils_1.byteEncoder.encode(schemaId));
+            const schemaId = await js_jsonld_merklization_1.Path.getTypeIDFromContext(ldContextJSON, query.type || '', ldOpts);
+            const schemaHash = (0, verifiable_1.calculateCoreSchemaHash)(utils_1.byteEncoder.encode(schemaId));
             const queriesMetadata = await (0, common_2.parseQueriesMetadata)(query.type || '', ldContextJSON, credentialSubject, ldOpts);
-            const queryHashes = queriesMetadata.map((queryMeta) => {
-                const valueHash = js_crypto_1.poseidon.spongeHashX(queryMeta.values, 6);
-                return js_crypto_1.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(utils_1.bigIntCompare);
-            queryHashes.sort(utils_1.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 < linked_multi_query_1.LinkedMultiQueryInputs.queryCount; i++) {
+                const queryMeta = queriesMetadata[i];
+                const values = queryMeta?.values ?? [];
+                const valArrSize = values.length;
+                const queryHash = (0, query_hash_1.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 < linked_multi_query_1.LinkedMultiQueryInputs.queryCount; i++) {
+                if (request[i].queryHash != pubSignalsMeta[i].queryHash) {
+                    throw new Error('query hashes do not match');
+                }
+                if (request[i].queryMeta?.operator === circuits_1.Operators.SD) {
+                    const disclosedValue = await (0, query_1.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/cjs/proof/verifiers/query-hash.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.calculateQueryHashV3 = exports.calculateQueryHashV2 = void 0;
+const js_crypto_1 = require("@iden3/js-crypto");
+const circuits_1 = require("../../circuits");
+function calculateQueryHashV2(values, schema, slotIndex, operator, claimPathKey, claimPathNotExists) {
+    const expValue = (0, circuits_1.prepareCircuitArrayValues)(values, 64);
+    const valueHash = js_crypto_1.poseidon.spongeHashX(expValue, 6);
+    return js_crypto_1.poseidon.hash([
+        schema.bigInt(),
+        BigInt(slotIndex),
+        BigInt(operator),
+        BigInt(claimPathKey),
+        BigInt(claimPathNotExists),
+        valueHash
+    ]);
+}
+exports.calculateQueryHashV2 = calculateQueryHashV2;
+function calculateQueryHashV3(values, schema, slotIndex, operator, claimPathKey, valueArraySize, merklized, isRevocationChecked, verifierID, nullifierSessionID) {
+    const expValue = (0, circuits_1.prepareCircuitArrayValues)(values, circuits_1.defaultValueArraySize);
+    const valueHash = js_crypto_1.poseidon.spongeHashX(expValue, 6);
+    const firstPartQueryHash = js_crypto_1.poseidon.hash([
+        schema.bigInt(),
+        BigInt(slotIndex),
+        BigInt(operator),
+        BigInt(claimPathKey),
+        BigInt(merklized),
+        valueHash
+    ]);
+    const queryHash = js_crypto_1.poseidon.hash([
+        firstPartQueryHash,
+        BigInt(valueArraySize),
+        BigInt(isRevocationChecked),
+        BigInt(verifierID),
+        BigInt(nullifierSessionID),
+        0n
+    ]);
+    return queryHash;
+}
+exports.calculateQueryHashV3 = calculateQueryHashV3;

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

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.checkQueryRequest = void 0;
+exports.fieldValueFromVerifiablePresentation = exports.checkQueryRequest = void 0;
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const js_jsonld_merklization_1 = require("@iden3/js-jsonld-merklization");
 const utils_1 = require("../../utils");
@@ -32,7 +32,7 @@ async function checkQueryRequest(query, outputs, circuitId, schemaLoader, verifi
     const schemaId = await js_jsonld_merklization_1.Path.getTypeIDFromContext(JSON.stringify(schema), query.type, {
         documentLoader: schemaLoader
     });
-    const schemaHash = (0, verifiable_1.caclulateCoreSchemaHash)(utils_1.byteEncoder.encode(schemaId));
+    const schemaHash = (0, verifiable_1.calculateCoreSchemaHash)(utils_1.byteEncoder.encode(schemaId));
     if (schemaHash.bigInt() !== outputs.schemaHash.bigInt()) {
         throw new Error(`schema that was used is not equal to requested in query`);
     }
@@ -50,7 +50,8 @@ async function checkQueryRequest(query, outputs, circuitId, schemaLoader, verifi
     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`);
         }
@@ -103,7 +104,7 @@ async function checkQueryRequest(query, outputs, circuitId, schemaLoader, verifi
         if (timeDiff > acceptedProofGenerationDelay) {
             throw new Error('generated proof is outdated');
         }
-    });
+    }
     return;
 }
 exports.checkQueryRequest = checkQueryRequest;
@@ -133,14 +134,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 !== comparer_1.Operators.EQ) {
         throw new Error(`operator for selective disclosure must be $eq`);
     }
@@ -149,6 +150,15 @@ async function validateDisclosure(cq, outputs, verifiablePresentation, ldLoader)
             throw new Error(`selective disclosure not available for array of values`);
         }
     }
+    const bi = await (0, exports.fieldValueFromVerifiablePresentation)(cq.fieldName, verifiablePresentation, ldLoader);
+    if (bi !== outputs.value[0]) {
+        throw new Error(`value that was used is not equal to requested in query`);
+    }
+}
+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 {
@@ -161,13 +171,13 @@ async function validateDisclosure(cq, outputs, verifiablePresentation, ldLoader)
     }
     let merklizedPath;
     try {
-        const p = `verifiableCredential.credentialSubject.${cq.fieldName}`;
+        const p = `verifiableCredential.credentialSubject.${fieldName}`;
         merklizedPath = await js_jsonld_merklization_1.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;
@@ -175,16 +185,14 @@ 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();
+};
+exports.fieldValueFromVerifiablePresentation = fieldValueFromVerifiablePresentation;

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

@@ -55,14 +55,14 @@ function checkDataInField(data) {
 exports.checkDataInField = checkDataInField;
 /**
  *
- * @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}
  */
 const createSchemaHash = (schemaId) => {
-    return (0, verifiable_1.caclulateCoreSchemaHash)(schemaId);
+    return (0, verifiable_1.calculateCoreSchemaHash)(schemaId);
 };
 exports.createSchemaHash = createSchemaHash;
 /**

package/dist/node/cjs/storage/filters/jsonQuery.js

@@ -69,6 +69,19 @@ const lessThanOrEqual = (a, b) => {
     }
     return a <= b;
 };
+// a - field value
+// b - true / false (exists operator values)
+const existsComparator = (a, b) => {
+    if (truthyValues.includes(b) && typeof a !== 'undefined') {
+        // if exists val is true , a field val exists
+        return true;
+    }
+    // if exists val is false , a field val doesn't exist
+    if (falsyValues.includes(b) && (a === undefined || (Array.isArray(a) && !a.length))) {
+        return true;
+    }
+    return false;
+};
 const inOperator = (a, b) => {
     if (Array.isArray(a) && Array.isArray(b)) {
         return a.every((val) => b.includes(val));
@@ -81,9 +94,19 @@ const inOperator = (a, b) => {
     }
     return false;
 };
+const betweenOperator = (a, b) => {
+    if (!Array.isArray(b) || b.length !== 2) {
+        throw new Error('$between/$nonbetween operator value should be 2 elements array');
+    }
+    if (Array.isArray(a)) {
+        return a.every((val) => val >= b[0] && val <= b[1]);
+    }
+    return a >= b[0] && a <= b[1];
+};
 exports.comparatorOptions = {
     $noop: () => true,
     $sd: () => true,
+    $exists: (a, b) => existsComparator(a, b),
     $eq: (a, b) => equalsComparator(a, b),
     $in: (a, b) => inOperator(a, b),
     $nin: (a, b) => !inOperator(a, b),
@@ -91,7 +114,9 @@ exports.comparatorOptions = {
     $lt: (a, b) => !greaterThan(a, b),
     $ne: (a, b) => !equalsComparator(a, b),
     $gte: (a, b) => greaterThanOrEqual(a, b),
-    $lte: (a, b) => lessThanOrEqual(a, b)
+    $lte: (a, b) => lessThanOrEqual(a, b),
+    $between: (a, b) => betweenOperator(a, b),
+    $nonbetween: (a, b) => !betweenOperator(a, b)
 };
 /**
  * credential search path resolver
@@ -140,7 +165,8 @@ class FilterQuery {
             throw new Error(SearchError.NotDefinedComparator);
         }
         const credentialPathValue = (0, exports.resolvePath)(credential, this.path);
-        if (credentialPathValue === null || credentialPathValue === undefined) {
+        if ((credentialPathValue === null || credentialPathValue === undefined) &&
+            this.operatorFunc !== existsComparator) {
             return false;
         }
         if (this.isReverseParams) {

package/dist/node/cjs/verifiable/core-utils.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.caclulateCoreSchemaHash = exports.parseCoreClaimSlots = exports.findCredentialType = exports.parseSerializationAttr = exports.getSerializationAttrFromParsedContext = exports.getSerializationAttrFromContext = exports.fillCoreClaimSlot = exports.getFieldSlotIndex = void 0;
+exports.calculateCoreSchemaHash = exports.parseCoreClaimSlots = exports.findCredentialType = exports.parseSerializationAttr = exports.getSerializationAttrFromParsedContext = exports.getSerializationAttrFromContext = exports.fillCoreClaimSlot = exports.getFieldSlotIndex = void 0;
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const js_jsonld_merklization_1 = require("@iden3/js-jsonld-merklization");
 const utils_1 = require("../utils");
@@ -227,8 +227,8 @@ exports.parseCoreClaimSlots = parseCoreClaimSlots;
  * @param {Uint8Array} schemaId
  * @returns {*}  {SchemaHash}
  */
-const caclulateCoreSchemaHash = (schemaId) => {
+const calculateCoreSchemaHash = (schemaId) => {
     const sHash = js_crypto_1.Hex.decodeString((0, js_sha3_1.keccak256)(schemaId));
     return new js_iden3_core_1.SchemaHash(sHash.slice(sHash.length - 16, sHash.length));
 };
-exports.caclulateCoreSchemaHash = caclulateCoreSchemaHash;
+exports.calculateCoreSchemaHash = calculateCoreSchemaHash;

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

@@ -145,7 +145,7 @@ class W3CCredential {
         if (!nonMerklized && opts.merklizedRootPosition === constants_1.MerklizedRootPosition.None) {
             opts.merklizedRootPosition = constants_1.MerklizedRootPosition.Index;
         }
-        const schemaHash = (0, core_utils_1.caclulateCoreSchemaHash)(utils_2.byteEncoder.encode(credentialType));
+        const schemaHash = (0, core_utils_1.calculateCoreSchemaHash)(utils_2.byteEncoder.encode(credentialType));
         const claim = js_iden3_core_1.Claim.newClaim(schemaHash, js_iden3_core_1.ClaimOptions.withIndexDataBytes(slots.indexA, slots.indexB), js_iden3_core_1.ClaimOptions.withValueDataBytes(slots.valueA, slots.valueB), js_iden3_core_1.ClaimOptions.withRevocationNonce(BigInt(opts.revNonce)), js_iden3_core_1.ClaimOptions.withVersion(opts.version));
         if (opts.updatable) {
             claim.setFlagUpdatable(opts.updatable);

package/dist/node/esm/circuits/atomic-query-v3-on-chain.js

@@ -1,5 +1,5 @@
 import { Claim, Id } from '@iden3/js-iden3-core';
-import { BaseConfig, bigIntArrayToStringArray, prepareSiblingsStr, existenceToInt, getNodeAuxValue, prepareCircuitArrayValues } from './common';
+import { BaseConfig, bigIntArrayToStringArray, prepareSiblingsStr, getNodeAuxValue, prepareCircuitArrayValues } from './common';
 import { CircuitError, ValueProof } from './models';
 import { Hash, Proof, ZERO_HASH } from '@iden3/js-merkletree';
 import { byteDecoder, byteEncoder } from '../utils';
@@ -23,13 +23,14 @@ export class AtomicQueryV3OnChainInputs extends BaseConfig {
         if (!this.query.values) {
             throw new Error(CircuitError.EmptyQueryValue);
         }
+        this.query.validateValueArraySize(this.getValueArrSize());
         if (!this.proofType) {
             throw new Error(CircuitError.InvalidProofType);
         }
         if (!this.challenge) {
             throw new Error(CircuitError.EmptyChallenge);
         }
-        if (this.authEnabled === 1) {
+        if (this.isBJJAuthEnabled === 1) {
             if (!this.authClaimIncMtp) {
                 throw new Error(CircuitError.EmptyAuthClaimProof);
             }
@@ -145,7 +146,7 @@ export class AtomicQueryV3OnChainInputs extends BaseConfig {
             isRevocationChecked: 1
         };
         s.challenge = this.challenge?.toString();
-        if (this.authEnabled === 1) {
+        if (this.isBJJAuthEnabled === 1) {
             s.authClaim = this.authClaim?.marshalJson();
             s.userClaimsTreeRoot = this.treeState.claimsRoot?.bigInt().toString();
             s.userRevTreeRoot = this.treeState.revocationRoot?.bigInt().toString();
@@ -220,18 +221,18 @@ export class AtomicQueryV3OnChainInputs extends BaseConfig {
         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();
+        s.valueArraySize = this.query.values.length;
         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();
+        s.isBJJAuthEnabled = this.isBJJAuthEnabled.toString();
         return byteEncoder.encode(JSON.stringify(s));
     }
 }
@@ -243,7 +244,6 @@ export class AtomicQueryV3OnChainPubSignals extends BaseConfig {
     // PubSignalsUnmarshal unmarshal credentialAtomicQueryV3.circom public signals
     pubSignalsUnmarshal(data) {
         // expected order:
-        // merklized
         // userID
         // circuitQueryHash
         // issuerState
@@ -255,17 +255,11 @@ export class AtomicQueryV3OnChainPubSignals extends BaseConfig {
         // challenge
         // gistRoot
         // issuerID
-        // isRevocationChecked
         // issuerClaimNonRevState
         // timestamp
-        // verifierID
-        // nullifierSessionID
-        // authEnabled
+        // isBJJAuthEnabled
         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++;
@@ -299,25 +293,14 @@ export class AtomicQueryV3OnChainPubSignals extends BaseConfig {
         // - issuerID
         this.issuerID = Id.fromBigInt(BigInt(sVals[fieldIdx]));
         fieldIdx++;
-        // - isRevocationChecked
-        this.isRevocationChecked = parseInt(sVals[fieldIdx]);
-        fieldIdx++;
         // - issuerClaimNonRevState
         this.issuerClaimNonRevState = Hash.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]);
+        // - isBJJAuthEnabled
+        this.isBJJAuthEnabled = parseInt(sVals[fieldIdx]);
         return this;
     }
 }

package/dist/node/esm/circuits/atomic-query-v3.js

@@ -1,5 +1,5 @@
 import { Claim, Id, SchemaHash } from '@iden3/js-iden3-core';
-import { BaseConfig, bigIntArrayToStringArray, prepareSiblingsStr, existenceToInt, getNodeAuxValue, prepareCircuitArrayValues } from './common';
+import { BaseConfig, bigIntArrayToStringArray, prepareSiblingsStr, getNodeAuxValue, prepareCircuitArrayValues } from './common';
 import { CircuitError, ValueProof } from './models';
 import { Hash, Proof, ZERO_HASH } from '@iden3/js-merkletree';
 import { byteDecoder, byteEncoder } from '../utils';
@@ -23,6 +23,7 @@ export class AtomicQueryV3Inputs extends BaseConfig {
         if (!this.query.values) {
             throw new Error(CircuitError.EmptyQueryValue);
         }
+        this.query.validateValueArraySize(this.getValueArrSize());
         if (!this.proofType) {
             throw new Error(CircuitError.InvalidProofType);
         }
@@ -152,12 +153,12 @@ export class AtomicQueryV3Inputs extends BaseConfig {
         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();
+        s.valueArraySize = this.query.values.length;
         const values = prepareCircuitArrayValues(this.query.values, this.getValueArrSize());
         s.value = bigIntArrayToStringArray(values);
         s.linkNonce = this.linkNonce.toString();
@@ -191,11 +192,11 @@ export class AtomicQueryV3PubSignals extends BaseConfig {
         // issuerClaimNonRevState
         // timestamp
         // claimSchema
-        // claimPathNotExists
         // claimPathKey
         // slotIndex
         // operator
         // value
+        // valueArraySize
         // verifierID
         // nullifierSessionID
         // 19 is a number of fields in AtomicQueryV3PubSignals before values, values is last element in the proof and
@@ -246,9 +247,6 @@ export class AtomicQueryV3PubSignals extends BaseConfig {
         //  - claimSchema
         this.claimSchema = SchemaHash.newSchemaHashFromInt(BigInt(sVals[fieldIdx]));
         fieldIdx++;
-        // - ClaimPathNotExists
-        this.claimPathNotExists = parseInt(sVals[fieldIdx]);
-        fieldIdx++;
         // - ClaimPathKey
         this.claimPathKey = BigInt(sVals[fieldIdx]);
         fieldIdx++;
@@ -263,6 +261,9 @@ export class AtomicQueryV3PubSignals extends BaseConfig {
             this.value.push(BigInt(sVals[fieldIdx]));
             fieldIdx++;
         }
+        // - valueArraySize
+        this.valueArraySize = parseInt(sVals[fieldIdx]);
+        fieldIdx++;
         // - verifierID
         if (sVals[fieldIdx] !== '0') {
             this.verifierID = Id.fromBigInt(BigInt(sVals[fieldIdx]));

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

@@ -42,7 +42,7 @@ export class BaseConfig {
      * @returns number
      */
     getValueArrSize() {
-        return this.valueArraySize ? this.valueArraySize : defaultValueArraySize;
+        return this.maxValueArraySize ? this.maxValueArraySize : defaultValueArraySize;
     }
     /**
      * getMTLevelOnChain return level on chain for given circuit

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

@@ -30,6 +30,8 @@ export var Operators;
     Operators[Operators["LTE"] = 7] = "LTE";
     Operators[Operators["GTE"] = 8] = "GTE";
     Operators[Operators["BETWEEN"] = 9] = "BETWEEN";
+    Operators[Operators["NONBETWEEN"] = 10] = "NONBETWEEN";
+    Operators[Operators["EXISTS"] = 11] = "EXISTS";
     Operators[Operators["SD"] = 16] = "SD";
     Operators[Operators["NULLIFY"] = 17] = "NULLIFY";
 })(Operators || (Operators = {}));
@@ -45,12 +47,17 @@ export const QueryOperators = {
     $lte: Operators.LTE,
     $gte: Operators.GTE,
     $between: Operators.BETWEEN,
+    $nonbetween: Operators.NONBETWEEN,
+    $exists: Operators.EXISTS,
     $sd: Operators.SD,
     $nullify: Operators.NULLIFY
 };
 const allOperations = Object.values(QueryOperators);
 export const availableTypesOperators = new Map([
-    [XSDNS.Boolean, [QueryOperators.$eq, QueryOperators.$ne, QueryOperators.$sd]],
+    [
+        XSDNS.Boolean,
+        [QueryOperators.$eq, QueryOperators.$ne, QueryOperators.$sd, QueryOperators.$exists]
+    ],
     [XSDNS.Integer, allOperations],
     [XSDNS.NonNegativeInteger, allOperations],
     [XSDNS.PositiveInteger, allOperations],
@@ -61,7 +68,8 @@ export const availableTypesOperators = new Map([
             QueryOperators.$ne,
             QueryOperators.$in,
             QueryOperators.$nin,
-            QueryOperators.$sd
+            QueryOperators.$sd,
+            QueryOperators.$exists
         ]
     ],
     [
@@ -71,7 +79,8 @@ export const availableTypesOperators = new Map([
             QueryOperators.$ne,
             QueryOperators.$in,
             QueryOperators.$nin,
-            QueryOperators.$sd
+            QueryOperators.$sd,
+            QueryOperators.$exists
         ]
     ],
     [XSDNS.DateTime, allOperations]
@@ -162,6 +171,16 @@ export class Vector {
                 return this.y.includes(this.x);
             case Operators.NIN:
                 return !this.y.includes(this.x);
+            case Operators.BETWEEN:
+                if (this.y.length !== 2) {
+                    return false;
+                }
+                return this.x >= this.y[0] && this.x <= this.y[1];
+            case Operators.NONBETWEEN:
+                if (this.y.length !== 2) {
+                    return false;
+                }
+                return this.x < this.y[0] || this.x > this.y[1];
             default:
                 throw new Error('unknown compare type for vector');
         }
@@ -187,6 +206,8 @@ export const factoryComparer = (x, y, operator) => {
             return new Scalar(x, y[0]);
         case Operators.IN:
         case Operators.NIN:
+        case Operators.BETWEEN:
+        case Operators.NONBETWEEN:
             return new Vector(x, y);
         default:
             throw new Error('unknown compare type');