@0xpolygonid/js-sdk 1.8.3 → 1.9.1

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

@@ -0,0 +1,119 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RevocationStatusHandler = void 0;
+const constants_1 = require("../constants");
+const constants_2 = require("../constants");
+const js_iden3_core_1 = require("@iden3/js-iden3-core");
+const uuid = __importStar(require("uuid"));
+const utils_1 = require("../../utils");
+const js_jwz_1 = require("@iden3/js-jwz");
+/**
+ *
+ * Allows to process RevocationStatusRequest protocol message
+ *
+
+ * @class RevocationStatusHandler
+ * @implements implements IRevocationStatusHandler interface
+ */
+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 !== constants_1.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: constants_2.MediaType.PlainMessage
+            };
+        }
+        if (opts.mediaType === constants_2.MediaType.SignedMessage && !opts.packerOptions) {
+            throw new Error(`jws packer options are required for ${constants_2.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 = js_iden3_core_1.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 === constants_2.MediaType.SignedMessage
+            ? opts.packerOptions
+            : {
+                provingMethodAlg: js_jwz_1.proving.provingMethodGroth16AuthV2Instance.methodAlg
+            };
+        const senderDID = js_iden3_core_1.DID.parse(rsRequest.to);
+        const guid = uuid.v4();
+        const response = {
+            id: guid,
+            typ: constants_2.MediaType.PlainMessage,
+            type: constants_1.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, utils_1.byteEncoder.encode(JSON.stringify(response)), {
+            senderDID,
+            ...packerOpts
+        });
+    }
+}
+exports.RevocationStatusHandler = RevocationStatusHandler;

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

@@ -253,6 +253,10 @@ 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(), storage_1.MerkleTreeType.Revocations);
         const claimsRoot = await treesModel.claimsTree.root();

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

@@ -90,16 +90,21 @@ const parseCredentialSubject = (credentialSubject) => {
 };
 exports.parseCredentialSubject = parseCredentialSubject;
 const parseQueryMetadata = async (propertyQuery, ldContextJSON, credentialType, options) => {
-    const datatype = await js_jsonld_merklization_1.Path.newTypeFromContext(ldContextJSON, `${credentialType}.${propertyQuery.fieldName}`, options);
     const query = {
         ...propertyQuery,
         slotIndex: 0,
         merklizedSchema: false,
-        datatype: datatype,
+        datatype: '',
         claimPathKey: BigInt(0),
         values: [],
         path: new js_jsonld_merklization_1.Path()
     };
+    if (!propertyQuery.fieldName && propertyQuery.operator !== circuits_1.Operators.NOOP) {
+        throw new Error('query must have a field name if operator is not $noop');
+    }
+    if (propertyQuery.fieldName) {
+        query.datatype = await js_jsonld_merklization_1.Path.newTypeFromContext(ldContextJSON, `${credentialType}.${propertyQuery.fieldName}`, options);
+    }
     const serAttr = await (0, verifiable_1.getSerializationAttrFromContext)(JSON.parse(ldContextJSON), options, credentialType);
     if (!serAttr) {
         query.merklizedSchema = true;
@@ -121,9 +126,10 @@ const parseQueryMetadata = async (propertyQuery, ldContextJSON, credentialType,
         }
     }
     if (propertyQuery.operatorValue) {
-        if (!(0, circuits_1.isValidOperation)(datatype, propertyQuery.operator)) {
-            throw new Error(`operator ${propertyQuery.operator} is not supported for datatype ${datatype}`);
+        if (!(0, circuits_1.isValidOperation)(query.datatype, propertyQuery.operator)) {
+            throw new Error(`operator ${propertyQuery.operator} is not supported for datatype ${query.datatype}`);
         }
+        const datatype = propertyQuery.operator === circuits_1.Operators.EXISTS ? circuits_1.XSDNS.Boolean : query.datatype;
         query.values = await (0, exports.transformQueryValueToBigInts)(propertyQuery.operatorValue, datatype);
     }
     return query;
@@ -135,7 +141,7 @@ const parseQueriesMetadata = async (credentialType, ldContextJSON, credentialSub
 };
 exports.parseQueriesMetadata = parseQueriesMetadata;
 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 js_jsonld_merklization_1.Merklizer.hashValue(ldType, value[index]);

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

@@ -205,10 +205,8 @@ class InputGenerator {
             circuitInputs.profileNonce = BigInt(params.authProfileNonce);
             circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
             const query = circuitQueries[0];
-            query.values =
-                query.operator === circuits_1.Operators.SD || query.operator === circuits_1.Operators.NOOP
-                    ? new Array(circuits_1.defaultValueArraySize).fill(0)
-                    : query.values;
+            query.values = [circuits_1.Operators.SD, circuits_1.Operators.NOOP].includes(query.operator) ? [] : query.values;
+            query.valueProof = query.operator === circuits_1.Operators.NOOP ? new circuits_1.ValueProof() : query.valueProof;
             circuitInputs.query = query;
             circuitInputs.currentTimeStamp = (0, js_iden3_core_1.getUnixTimestamp)(new Date());
             circuitInputs.proofType = proofType;
@@ -256,10 +254,8 @@ class InputGenerator {
             circuitInputs.profileNonce = BigInt(params.authProfileNonce);
             circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
             const query = circuitQueries[0];
-            query.values =
-                query.operator === circuits_1.Operators.SD || query.operator === circuits_1.Operators.NOOP
-                    ? new Array(circuits_1.defaultValueArraySize).fill(0)
-                    : query.values;
+            query.values = [circuits_1.Operators.SD, circuits_1.Operators.NOOP].includes(query.operator) ? [] : query.values;
+            query.valueProof = query.operator === circuits_1.Operators.NOOP ? new circuits_1.ValueProof() : query.valueProof;
             circuitInputs.query = query;
             circuitInputs.currentTimeStamp = (0, js_iden3_core_1.getUnixTimestamp)(new Date());
             circuitInputs.proofType = proofType;
@@ -275,7 +271,7 @@ 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 = js_iden3_core_1.DID.idFromDID(genesisDID);
@@ -283,7 +279,7 @@ class InputGenerator {
             const gistProof = (0, common_1.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/cjs/proof/verifiers/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./pub-signals-verifier"), exports);
 __exportStar(require("./query"), exports);
+__exportStar(require("./query-hash"), exports);

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);