@0xpolygonid/js-sdk 1.8.3 → 1.9.1

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

@@ -2,3 +2,5 @@ export * from './auth';
 export * from './fetch';
 export * from './contract-request';
 export * from './refresh';
+export * from './revocation-status';
+export * from './common';

package/dist/node/esm/iden3comm/handlers/revocation-status.js

@@ -0,0 +1,92 @@
+import { PROTOCOL_MESSAGE_TYPE } from '../constants';
+import { MediaType } from '../constants';
+import { DID } from '@iden3/js-iden3-core';
+import * as uuid from 'uuid';
+import { byteEncoder } from '../../utils';
+import { proving } from '@iden3/js-jwz';
+/**
+ *
+ * Allows to process RevocationStatusRequest protocol message
+ *
+
+ * @class RevocationStatusHandler
+ * @implements implements IRevocationStatusHandler interface
+ */
+export class RevocationStatusHandler {
+    /**
+     * Creates an instance of RevocationStatusHandler.
+     * @param {IPackageManager} _packerMgr - package manager to unpack message envelope
+     * @param {IIdentityWallet} _identityWallet - identity wallet
+     *
+     */
+    constructor(_packerMgr, _identityWallet) {
+        this._packerMgr = _packerMgr;
+        this._identityWallet = _identityWallet;
+    }
+    /**
+     * @inheritdoc IRevocationStatusHandler#parseRevocationStatusRequest
+     */
+    async parseRevocationStatusRequest(request) {
+        const { unpackedMessage: message } = await this._packerMgr.unpack(request);
+        const ciRequest = message;
+        if (message.type !== PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_REQUEST_MESSAGE_TYPE) {
+            throw new Error('Invalid media type');
+        }
+        return ciRequest;
+    }
+    /**
+     * @inheritdoc IRevocationStatusHandler#handleRevocationStatusRequest
+     */
+    async handleRevocationStatusRequest(did, request, opts) {
+        if (!opts) {
+            opts = {
+                mediaType: MediaType.PlainMessage
+            };
+        }
+        if (opts.mediaType === MediaType.SignedMessage && !opts.packerOptions) {
+            throw new Error(`jws packer options are required for ${MediaType.SignedMessage}`);
+        }
+        const rsRequest = await this.parseRevocationStatusRequest(request);
+        if (!rsRequest.to) {
+            throw new Error(`failed request. empty 'to' field`);
+        }
+        if (!rsRequest.from) {
+            throw new Error(`failed request. empty 'from' field`);
+        }
+        if (!rsRequest.body?.revocation_nonce) {
+            throw new Error(`failed request. empty 'revocation_nonce' field`);
+        }
+        const issuerDID = DID.parse(rsRequest.to);
+        const mtpWithTreeState = await this._identityWallet.generateNonRevocationMtpWithNonce(issuerDID, BigInt(rsRequest.body.revocation_nonce), opts?.treeState);
+        const treeState = mtpWithTreeState.treeState;
+        const revStatus = {
+            issuer: {
+                state: treeState?.state.string(),
+                claimsTreeRoot: treeState.claimsRoot.string(),
+                revocationTreeRoot: treeState.revocationRoot.string(),
+                rootOfRoots: treeState.rootOfRoots.string()
+            },
+            mtp: mtpWithTreeState.proof
+        };
+        const packerOpts = opts.mediaType === MediaType.SignedMessage
+            ? opts.packerOptions
+            : {
+                provingMethodAlg: proving.provingMethodGroth16AuthV2Instance.methodAlg
+            };
+        const senderDID = DID.parse(rsRequest.to);
+        const guid = uuid.v4();
+        const response = {
+            id: guid,
+            typ: MediaType.PlainMessage,
+            type: PROTOCOL_MESSAGE_TYPE.REVOCATION_STATUS_RESPONSE_MESSAGE_TYPE,
+            thid: rsRequest.thid ?? guid,
+            body: revStatus,
+            from: did.string(),
+            to: rsRequest.from
+        };
+        return this._packerMgr.pack(opts.mediaType, byteEncoder.encode(JSON.stringify(response)), {
+            senderDID,
+            ...packerOpts
+        });
+    }
+}

package/dist/node/esm/identity/identity-wallet.js

@@ -227,6 +227,10 @@ export class IdentityWallet {
     async generateNonRevocationMtp(did, credential, treeState) {
         const coreClaim = await this.getCoreClaimFromCredential(credential);
         const revNonce = coreClaim.getRevocationNonce();
+        return this.generateNonRevocationMtpWithNonce(did, revNonce, treeState);
+    }
+    /** {@inheritDoc IIdentityWallet.generateNonRevocationMtpWithNonce} */
+    async generateNonRevocationMtpWithNonce(did, revNonce, treeState) {
         const treesModel = await this.getDIDTreeModel(did);
         const revocationTree = await this._storage.mt.getMerkleTreeByIdentifierAndType(did.string(), MerkleTreeType.Revocations);
         const claimsRoot = await treesModel.claimsTree.root();

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);
 };
 /**
  *

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

@@ -66,6 +66,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));
@@ -78,9 +91,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];
+};
 export const 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),
@@ -88,7 +111,9 @@ export const 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
@@ -136,7 +161,8 @@ export class FilterQuery {
             throw new Error(SearchError.NotDefinedComparator);
         }
         const credentialPathValue = 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/esm/verifiable/core-utils.js

@@ -194,7 +194,7 @@ export const parseCoreClaimSlots = async (ldCtx, mz, credentialType) => {
  * @param {Uint8Array} schemaId
  * @returns {*}  {SchemaHash}
  */
-export const caclulateCoreSchemaHash = (schemaId) => {
+export const calculateCoreSchemaHash = (schemaId) => {
     const sHash = Hex.decodeString(keccak256(schemaId));
     return new SchemaHash(sHash.slice(sHash.length - 16, sHash.length));
 };

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

@@ -7,7 +7,7 @@ import { PublicKey, poseidon } from '@iden3/js-crypto';
 import { getUserDIDFromCredential } from '../credentials/utils';
 import { byteEncoder, validateDIDDocumentAuth } from '../utils';
 import { MerklizedRootPosition, ProofType, SubjectPosition } from './constants';
-import { caclulateCoreSchemaHash, findCredentialType, parseCoreClaimSlots } from './core-utils';
+import { calculateCoreSchemaHash, findCredentialType, parseCoreClaimSlots } from './core-utils';
 import * as jsonld from 'jsonld/lib';
 import * as ldcontext from 'jsonld/lib/context';
 /**
@@ -119,7 +119,7 @@ export class W3CCredential {
         if (!nonMerklized && opts.merklizedRootPosition === MerklizedRootPosition.None) {
             opts.merklizedRootPosition = MerklizedRootPosition.Index;
         }
-        const schemaHash = caclulateCoreSchemaHash(byteEncoder.encode(credentialType));
+        const schemaHash = calculateCoreSchemaHash(byteEncoder.encode(credentialType));
         const claim = Claim.newClaim(schemaHash, ClaimOptions.withIndexDataBytes(slots.indexA, slots.indexB), ClaimOptions.withValueDataBytes(slots.valueA, slots.valueB), ClaimOptions.withRevocationNonce(BigInt(opts.revNonce)), ClaimOptions.withVersion(opts.version));
         if (opts.updatable) {
             claim.setFlagUpdatable(opts.updatable);

package/dist/types/circuits/atomic-query-v3-on-chain.d.ts

@@ -32,7 +32,7 @@ export declare class AtomicQueryV3OnChainInputs extends BaseConfig {
     linkNonce: bigint;
     verifierID?: Id;
     nullifierSessionID: bigint;
-    authEnabled: number;
+    isBJJAuthEnabled: number;
     validate(): void;
     fillMTPProofsWithZero(s: Partial<AtomicQueryV3OnChainCircuitInputs>): void;
     fillSigProofWithZero(s: Partial<AtomicQueryV3OnChainCircuitInputs>): void;
@@ -73,7 +73,6 @@ interface AtomicQueryV3OnChainCircuitInputs {
     issuerAuthRootsTreeRoot: string;
     issuerAuthState: string;
     isRevocationChecked: number;
-    claimPathNotExists: number;
     claimPathMtp: string[];
     claimPathMtpNoAux: string;
     claimPathMtpAuxHi: string;
@@ -84,6 +83,7 @@ interface AtomicQueryV3OnChainCircuitInputs {
     slotIndex: number;
     timestamp: number;
     value: string[];
+    valueArraySize: number;
     issuerClaimMtp: string[];
     issuerClaimClaimsTreeRoot: string;
     issuerClaimRevTreeRoot: string;
@@ -112,7 +112,7 @@ interface AtomicQueryV3OnChainCircuitInputs {
     linkNonce: string;
     verifierID: string;
     nullifierSessionID: string;
-    authEnabled: string;
+    isBJJAuthEnabled: string;
 }
 /**
  * @beta
@@ -125,8 +125,6 @@ export declare class AtomicQueryV3OnChainPubSignals extends BaseConfig {
     issuerState: Hash;
     issuerClaimNonRevState: Hash;
     timestamp: number;
-    merklized: number;
-    isRevocationChecked: number;
     circuitQueryHash: bigint;
     challenge: bigint;
     gistRoot: Hash;
@@ -134,9 +132,7 @@ export declare class AtomicQueryV3OnChainPubSignals extends BaseConfig {
     linkID: bigint;
     nullifier: bigint;
     operatorOutput: bigint;
-    verifierID: Id;
-    nullifierSessionID: bigint;
-    authEnabled: number;
+    isBJJAuthEnabled: number;
     pubSignalsUnmarshal(data: Uint8Array): AtomicQueryV3OnChainPubSignals;
 }
 export {};

package/dist/types/circuits/atomic-query-v3.d.ts

@@ -69,7 +69,6 @@ interface AtomicQueryV3CircuitInputs {
     issuerAuthRootsTreeRoot: string;
     issuerAuthState: string;
     isRevocationChecked: number;
-    claimPathNotExists: number;
     claimPathMtp: string[];
     claimPathMtpNoAux: string;
     claimPathMtpAuxHi: string;
@@ -80,6 +79,7 @@ interface AtomicQueryV3CircuitInputs {
     slotIndex: number;
     timestamp: number;
     value: string[];
+    valueArraySize: number;
     issuerClaimMtp: string[];
     issuerClaimClaimsTreeRoot: string;
     issuerClaimRevTreeRoot: string;
@@ -104,10 +104,10 @@ export declare class AtomicQueryV3PubSignals extends BaseConfig {
     slotIndex: number;
     operator: number;
     value: bigint[];
+    valueArraySize: number;
     timestamp: number;
     merklized: number;
     claimPathKey: bigint;
-    claimPathNotExists: number;
     isRevocationChecked: number;
     proofType: number;
     linkID: bigint;