@0xpolygonid/js-sdk 1.5.0 → 1.6.0

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

@@ -11,6 +11,17 @@ export var SearchError;
 const truthyValues = [true, 1, 'true'];
 const falsyValues = [false, 0, 'false'];
 const equalsComparator = (a, b) => {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return (a.length === b.length && a.every((val, index) => val === b[index]));
+    }
+    if (!Array.isArray(a) && Array.isArray(b)) {
+        return b.includes(a);
+    }
+    if (Array.isArray(a) && !Array.isArray(b)) {
+        return a.includes(b);
+    }
+    a = a;
+    b = b;
     if (truthyValues.includes(a) && truthyValues.includes(b)) {
         return true;
     }
@@ -19,14 +30,65 @@ const equalsComparator = (a, b) => {
     }
     return a === b;
 };
-export /** @type {*}  - filter operators and their functions */ const comparatorOptions = {
+const greaterThan = (a, b) => {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.every((val, index) => val > b[index]);
+    }
+    if (!Array.isArray(a) && Array.isArray(b)) {
+        return b.every((val) => a > val);
+    }
+    if (Array.isArray(a) && !Array.isArray(b)) {
+        return a.every((val) => val > b);
+    }
+    return a > b;
+};
+const greaterThanOrEqual = (a, b) => {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.every((val, index) => val >= b[index]);
+    }
+    if (!Array.isArray(a) && Array.isArray(b)) {
+        return b.every((val) => a >= val);
+    }
+    if (Array.isArray(a) && !Array.isArray(b)) {
+        return a.every((val) => val >= b);
+    }
+    return a >= b;
+};
+const lessThanOrEqual = (a, b) => {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.every((val, index) => val <= b[index]);
+    }
+    if (!Array.isArray(a) && Array.isArray(b)) {
+        return b.every((val) => a <= val);
+    }
+    if (Array.isArray(a) && !Array.isArray(b)) {
+        return a.every((val) => val <= b);
+    }
+    return a <= b;
+};
+const inOperator = (a, b) => {
+    if (Array.isArray(a) && Array.isArray(b)) {
+        return a.every((val) => b.includes(val));
+    }
+    if (!Array.isArray(a) && Array.isArray(b)) {
+        return b.includes(a);
+    }
+    if (Array.isArray(a) && !Array.isArray(b)) {
+        return a.includes(b);
+    }
+    return false;
+};
+export const comparatorOptions = {
     $noop: () => true,
+    $sd: () => true,
     $eq: (a, b) => equalsComparator(a, b),
-    $in: (a, b) => b.includes(a),
-    $nin: (a, b) => !b.includes(a),
-    $gt: (a, b) => a > b,
-    $lt: (a, b) => a < b,
-    $ne: (a, b) => !equalsComparator(a, b)
+    $in: (a, b) => inOperator(a, b),
+    $nin: (a, b) => !inOperator(a, b),
+    $gt: (a, b) => greaterThan(a, b),
+    $lt: (a, b) => !greaterThan(a, b),
+    $ne: (a, b) => !equalsComparator(a, b),
+    $gte: (a, b) => greaterThanOrEqual(a, b),
+    $lte: (a, b) => lessThanOrEqual(a, b)
 };
 /**
  * credential search path resolver
@@ -110,8 +172,6 @@ export const StandardJSONCredentialsQueryFilter = (query) => {
                 return acc.concat(new FilterQuery('credentialSubject.id', comparatorOptions.$eq, queryValue));
             case 'schema':
                 return acc.concat(new FilterQuery('credentialSchema.id', comparatorOptions.$eq, queryValue));
-            case 'skipClaimRevocationCheck':
-                return acc;
             case 'credentialSubject': {
                 const reqFilters = Object.keys(queryValue).reduce((acc, fieldKey) => {
                     const fieldParams = queryValue[fieldKey];
@@ -129,8 +189,13 @@ export const StandardJSONCredentialsQueryFilter = (query) => {
                 }, []);
                 return acc.concat(reqFilters);
             }
+            case 'proofType':
+            case 'groupId':
+            case 'skipClaimRevocationCheck': {
+                return acc;
+            }
             default:
-                throw new Error(SearchError.NotDefinedQueryKey);
+                throw new Error(`${queryKey} : ${SearchError.NotDefinedQueryKey}`);
         }
     }, []);
 };

package/dist/node/esm/utils/did-helper.js

@@ -0,0 +1,10 @@
+import { Hex } from '@iden3/js-crypto';
+import { Id, buildDIDType, genesisFromEthAddress } from '@iden3/js-iden3-core';
+export const buildVerifierId = (address, info) => {
+    address = address.replace('0x', '');
+    const ethAddrBytes = Hex.decodeString(address);
+    const ethAddr = ethAddrBytes.slice(0, 20);
+    const genesis = genesisFromEthAddress(ethAddr);
+    const tp = buildDIDType(info.method, info.blockchain, info.networkId);
+    return new Id(tp, genesis);
+};

package/dist/node/esm/utils/index.js

@@ -1 +1,3 @@
 export * from './encoding';
+export * from './object';
+export * from './did-helper';

package/dist/node/esm/utils/object.js

@@ -0,0 +1,38 @@
+export function mergeObjects(credSubject, otherCredSubject) {
+    let result = {};
+    const credSubjectKeys = Object.keys(credSubject);
+    for (const key of credSubjectKeys) {
+        if (typeof otherCredSubject[key] !== 'undefined') {
+            if (typeof credSubject[key] !== 'object' && typeof otherCredSubject[key] !== 'object') {
+                throw new Error('Invalid query');
+            }
+            const subjectProperty = credSubject[key];
+            const otherSubjectProperty = otherCredSubject[key];
+            const propertyOperators = Object.keys(subjectProperty);
+            const subjectPropertyResult = {};
+            for (const operatorKey of propertyOperators) {
+                if (typeof otherSubjectProperty[operatorKey] !== 'undefined') {
+                    const operatorValue1 = subjectProperty[operatorKey];
+                    const operatorValue2 = otherSubjectProperty[operatorKey];
+                    subjectPropertyResult[operatorKey] = [
+                        ...new Set([
+                            ...(subjectPropertyResult[operatorKey] ?? []),
+                            operatorValue1,
+                            ...(Array.isArray(operatorValue2) ? operatorValue2 : [operatorValue2])
+                        ])
+                    ];
+                }
+                else {
+                    subjectPropertyResult[operatorKey] = subjectProperty[operatorKey];
+                }
+            }
+            result[key] = {
+                ...otherCredSubject[key],
+                ...subjectPropertyResult
+            };
+        }
+    }
+    // Add remaining keys from obj2
+    result = { ...credSubject, ...otherCredSubject, ...result };
+    return result;
+}

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

@@ -15,19 +15,23 @@ export const stringByPath = (obj, path) => {
     }
     return value.toString();
 };
-export const buildQueryPath = async (contextURL, contextType, field, opts) => {
-    let resp;
-    try {
-        resp = await (await fetch(contextURL)).json();
+export const buildFieldPath = async (ldSchema, contextType, field, opts) => {
+    let path = new Path();
+    if (field) {
+        path = await Path.getContextPathKey(ldSchema, contextType, field, opts);
     }
-    catch (error) {
-        throw new Error(`context not found: ${error.message}`);
-    }
-    const path = await Path.getContextPathKey(JSON.stringify(resp), contextType, field, opts);
     path.prepend([VerifiableConstants.CREDENTIAL_SUBJECT_PATH]);
     return path;
 };
-export const createVerifiablePresentation = (context, tp, path, value) => {
+export const findValue = (fieldName, credential) => {
+    const [first, ...rest] = fieldName.split('.');
+    let v = credential.credentialSubject[first];
+    for (const part of rest) {
+        v = v[part];
+    }
+    return v;
+};
+export const createVerifiablePresentation = (context, tp, credential, queries) => {
     const baseContext = [VerifiableConstants.JSONLD_SCHEMA.W3C_CREDENTIAL_2018];
     const ldContext = baseContext[0] === context ? baseContext : [...baseContext, context];
     const vc = VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_CREDENTIAL;
@@ -35,34 +39,31 @@ export const createVerifiablePresentation = (context, tp, path, value) => {
     if (tp !== vc) {
         vcTypes.push(tp);
     }
-    const [first, ...rest] = path.split('.');
-    const obj = rest.reduceRight((acc, key) => ({ [key]: acc }), value);
-    return {
+    const skeleton = {
         '@context': baseContext,
         '@type': VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_PRESENTATION,
         verifiableCredential: {
             '@context': ldContext,
             '@type': vcTypes,
             credentialSubject: {
-                '@type': tp,
-                [first]: obj
+                '@type': tp
             }
         }
     };
-};
-export const verifiablePresentationFromCred = async (w3cCred, requestObj, field, opts) => {
-    const mz = await w3cCred.merklize(opts);
-    const request = requestObj;
-    const contextType = stringByPath(request, 'type');
-    const hasher = mz.hasher;
-    const contextURL = stringByPath(request, 'context');
-    const path = await buildQueryPath(contextURL, contextType, field, opts);
-    const dataType = await mz.jsonLDType(path);
-    const rawValue = mz.rawValue(path);
-    const { value } = await mz.proof(path);
-    const vp = createVerifiablePresentation(contextURL, contextType, field, rawValue);
-    if (!value) {
-        throw new Error(`can't merklize verifiable presentation`);
+    let result = {};
+    for (const query of queries) {
+        const parts = query.fieldName.split('.');
+        const current = parts.reduceRight((acc, part) => {
+            if (result[part]) {
+                return { [part]: { ...result[part], ...acc } };
+            }
+            return { [part]: acc };
+        }, findValue(query.fieldName, credential));
+        result = { ...result, ...current };
     }
-    return { vp, mzValue: value, dataType, hasher };
+    skeleton.verifiableCredential.credentialSubject = {
+        ...skeleton.verifiableCredential.credentialSubject,
+        ...result
+    };
+    return skeleton;
 };

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

@@ -42,6 +42,7 @@ export class Iden3SparseMerkleTreeProof {
             mtp: this.mtp.toJSON()
         };
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static fromJSON(obj) {
         let mtp;
         if (obj?.mtp?.notEmpties && obj?.mtp?.depth && obj?.mtp?.siblings) {
@@ -120,6 +121,7 @@ export class BJJSignatureProof2021 {
      * fromJSON is a method to deserialize BJJSignatureProof2021 from json
      * @param obj
      */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static fromJSON(obj) {
         return new BJJSignatureProof2021({
             issuerData: {

package/dist/types/circuits/atomic-query-mtp-v2.d.ts

@@ -38,20 +38,20 @@ export declare class AtomicQueryMTPV2Inputs extends BaseConfig {
  * @extends {BaseConfig}
  */
 export declare class AtomicQueryMTPV2PubSignals extends BaseConfig {
-    requestID?: bigint;
-    userID?: Id;
-    issuerID?: Id;
-    issuerClaimIdenState?: Hash;
-    issuerClaimNonRevState?: Hash;
-    claimSchema?: SchemaHash;
-    slotIndex?: number;
-    operator?: number;
+    requestID: bigint;
+    userID: Id;
+    issuerID: Id;
+    issuerClaimIdenState: Hash;
+    issuerClaimNonRevState: Hash;
+    claimSchema: SchemaHash;
+    slotIndex: number;
+    operator: number;
     value: bigint[];
-    timestamp?: number;
-    merklized?: number;
-    claimPathKey?: bigint;
-    claimPathNotExists?: number;
-    isRevocationChecked?: number;
+    timestamp: number;
+    merklized: number;
+    claimPathKey: bigint;
+    claimPathNotExists: number;
+    isRevocationChecked: number;
     /**
      * PubSignalsUnmarshal unmarshal credentialAtomicQueryMTP.circom public signals array to AtomicQueryMTPPubSignals
      *

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

@@ -0,0 +1,142 @@
+import { Claim, Id } from '@iden3/js-iden3-core';
+import { BaseConfig } from './common';
+import { GISTProof, Query, TreeState } from './models';
+import { Hash, Proof } from '@iden3/js-merkletree';
+import { ClaimWithSigAndMTPProof } from './atomic-query-v3';
+import { Signature } from '@iden3/js-crypto';
+import { ProofType } from '../verifiable';
+/**
+ * AtomicQueryV3OnChainInputs ZK private inputs for credentialAtomicQueryV3OnChain.circom
+ *
+ * @beta
+ * @class AtomicQueryV3OnChainInputs
+ * @extends {BaseConfig}
+ */
+export declare class AtomicQueryV3OnChainInputs extends BaseConfig {
+    requestID: bigint;
+    id: Id;
+    profileNonce: bigint;
+    claimSubjectProfileNonce: bigint;
+    claim: ClaimWithSigAndMTPProof;
+    skipClaimRevocationCheck: boolean;
+    authClaim: Claim;
+    authClaimIncMtp: Proof;
+    authClaimNonRevMtp: Proof;
+    treeState: TreeState;
+    gistProof: GISTProof;
+    signature: Signature;
+    challenge: bigint;
+    query: Query;
+    currentTimeStamp: number;
+    proofType: ProofType;
+    linkNonce: bigint;
+    verifierID?: Id;
+    nullifierSessionID: bigint;
+    authEnabled: number;
+    validate(): void;
+    fillMTPProofsWithZero(s: Partial<AtomicQueryV3OnChainCircuitInputs>): void;
+    fillSigProofWithZero(s: Partial<AtomicQueryV3OnChainCircuitInputs>): void;
+    fillAuthWithZero(s: Partial<AtomicQueryV3OnChainCircuitInputs>): void;
+    inputsMarshal(): Uint8Array;
+}
+/**
+ * @beta
+ * AtomicQueryV3OnChainCircuitInputs type represents credentialAtomicQueryV3OnChain.circom private inputs required by prover
+ */
+interface AtomicQueryV3OnChainCircuitInputs {
+    requestID: string;
+    userGenesisID: string;
+    profileNonce: string;
+    claimSubjectProfileNonce: string;
+    issuerID: string;
+    issuerClaim: string[];
+    issuerClaimNonRevClaimsTreeRoot: string;
+    issuerClaimNonRevRevTreeRoot: string;
+    issuerClaimNonRevRootsTreeRoot: string;
+    issuerClaimNonRevState: string;
+    issuerClaimNonRevMtp: string[];
+    issuerClaimNonRevMtpAuxHi: string;
+    issuerClaimNonRevMtpAuxHv: string;
+    issuerClaimNonRevMtpNoAux: string;
+    claimSchema: string;
+    issuerClaimSignatureR8x: string;
+    issuerClaimSignatureR8y: string;
+    issuerClaimSignatureS: string;
+    issuerAuthClaim: string[];
+    issuerAuthClaimMtp: string[];
+    issuerAuthClaimNonRevMtp: string[];
+    issuerAuthClaimNonRevMtpAuxHi: string;
+    issuerAuthClaimNonRevMtpAuxHv: string;
+    issuerAuthClaimNonRevMtpNoAux: string;
+    issuerAuthClaimsTreeRoot: string;
+    issuerAuthRevTreeRoot: string;
+    issuerAuthRootsTreeRoot: string;
+    issuerAuthState: string;
+    isRevocationChecked: number;
+    claimPathNotExists: number;
+    claimPathMtp: string[];
+    claimPathMtpNoAux: string;
+    claimPathMtpAuxHi: string;
+    claimPathMtpAuxHv: string;
+    claimPathKey: string;
+    claimPathValue: string;
+    operator: number;
+    slotIndex: number;
+    timestamp: number;
+    value: string[];
+    issuerClaimMtp: string[];
+    issuerClaimClaimsTreeRoot: string;
+    issuerClaimRevTreeRoot: string;
+    issuerClaimRootsTreeRoot: string;
+    issuerClaimIdenState: string;
+    proofType: string;
+    authClaim?: string[];
+    authClaimIncMtp?: string[];
+    authClaimNonRevMtp: string[];
+    authClaimNonRevMtpAuxHi?: string;
+    authClaimNonRevMtpAuxHv?: string;
+    authClaimNonRevMtpNoAux: string;
+    challenge: string;
+    challengeSignatureR8x: string;
+    challengeSignatureR8y: string;
+    challengeSignatureS: string;
+    userClaimsTreeRoot?: string;
+    userRevTreeRoot?: string;
+    userRootsTreeRoot?: string;
+    userState?: string;
+    gistRoot?: string;
+    gistMtp: string[];
+    gistMtpAuxHi?: string;
+    gistMtpAuxHv?: string;
+    gistMtpNoAux: string;
+    linkNonce: string;
+    verifierID: string;
+    nullifierSessionID: string;
+    authEnabled: string;
+}
+/**
+ * @beta
+ * AtomicQueryV3OnChainPubSignals public inputs
+ */
+export declare class AtomicQueryV3OnChainPubSignals extends BaseConfig {
+    requestID: bigint;
+    userID: Id;
+    issuerID: Id;
+    issuerState: Hash;
+    issuerClaimNonRevState: Hash;
+    timestamp: number;
+    merklized: number;
+    isRevocationChecked: number;
+    circuitQueryHash: bigint;
+    challenge: bigint;
+    gistRoot: Hash;
+    proofType: number;
+    linkID: bigint;
+    nullifier: bigint;
+    operatorOutput: bigint;
+    verifierID: Id;
+    nullifierSessionID: bigint;
+    authEnabled: number;
+    pubSignalsUnmarshal(data: Uint8Array): AtomicQueryV3OnChainPubSignals;
+}
+export {};

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

@@ -0,0 +1,120 @@
+import { Claim, Id, SchemaHash } from '@iden3/js-iden3-core';
+import { BaseConfig } from './common';
+import { BJJSignatureProof, MTProof, Query } from './models';
+import { Hash } from '@iden3/js-merkletree';
+import { ProofType } from '../verifiable';
+export interface ClaimWithSigAndMTPProof {
+    issuerID: Id;
+    claim: Claim;
+    nonRevProof: MTProof;
+    signatureProof?: BJJSignatureProof;
+    incProof?: MTProof;
+}
+/**
+ * AtomicQueryV3Inputs ZK private inputs for credentialAtomicQueryV3.circom
+ *
+ * @beta
+ * @class AtomicQueryV3Inputs
+ * @extends {BaseConfig}
+ */
+export declare class AtomicQueryV3Inputs extends BaseConfig {
+    requestID: bigint;
+    id: Id;
+    profileNonce: bigint;
+    claimSubjectProfileNonce: bigint;
+    claim: ClaimWithSigAndMTPProof;
+    skipClaimRevocationCheck: boolean;
+    query: Query;
+    currentTimeStamp: number;
+    proofType: ProofType;
+    linkNonce: bigint;
+    verifierID?: Id;
+    nullifierSessionID: bigint;
+    validate(): void;
+    fillMTPProofsWithZero(s: Partial<AtomicQueryV3CircuitInputs>): void;
+    fillSigProofWithZero(s: Partial<AtomicQueryV3CircuitInputs>): void;
+    inputsMarshal(): Uint8Array;
+}
+/**
+ * @beta
+ * AtomicQueryV3CircuitInputs type represents credentialAtomicQueryV3.circom private inputs required by prover
+ */
+interface AtomicQueryV3CircuitInputs {
+    requestID: string;
+    userGenesisID: string;
+    profileNonce: string;
+    claimSubjectProfileNonce: string;
+    issuerID: string;
+    issuerClaim: string[];
+    issuerClaimNonRevClaimsTreeRoot: string;
+    issuerClaimNonRevRevTreeRoot: string;
+    issuerClaimNonRevRootsTreeRoot: string;
+    issuerClaimNonRevState: string;
+    issuerClaimNonRevMtp: string[];
+    issuerClaimNonRevMtpAuxHi: string;
+    issuerClaimNonRevMtpAuxHv: string;
+    issuerClaimNonRevMtpNoAux: string;
+    claimSchema: string;
+    issuerClaimSignatureR8x: string;
+    issuerClaimSignatureR8y: string;
+    issuerClaimSignatureS: string;
+    issuerAuthClaim: string[];
+    issuerAuthClaimMtp: string[];
+    issuerAuthClaimNonRevMtp: string[];
+    issuerAuthClaimNonRevMtpAuxHi: string;
+    issuerAuthClaimNonRevMtpAuxHv: string;
+    issuerAuthClaimNonRevMtpNoAux: string;
+    issuerAuthClaimsTreeRoot: string;
+    issuerAuthRevTreeRoot: string;
+    issuerAuthRootsTreeRoot: string;
+    issuerAuthState: string;
+    isRevocationChecked: number;
+    claimPathNotExists: number;
+    claimPathMtp: string[];
+    claimPathMtpNoAux: string;
+    claimPathMtpAuxHi: string;
+    claimPathMtpAuxHv: string;
+    claimPathKey: string;
+    claimPathValue: string;
+    operator: number;
+    slotIndex: number;
+    timestamp: number;
+    value: string[];
+    issuerClaimMtp: string[];
+    issuerClaimClaimsTreeRoot: string;
+    issuerClaimRevTreeRoot: string;
+    issuerClaimRootsTreeRoot: string;
+    issuerClaimIdenState: string;
+    proofType: string;
+    linkNonce: string;
+    verifierID: string;
+    nullifierSessionID: string;
+}
+/**
+ * @beta
+ * AtomicQueryV3PubSignals public inputs
+ */
+export declare class AtomicQueryV3PubSignals extends BaseConfig {
+    requestID: bigint;
+    userID: Id;
+    issuerID: Id;
+    issuerState: Hash;
+    issuerClaimNonRevState: Hash;
+    claimSchema: SchemaHash;
+    slotIndex: number;
+    operator: number;
+    value: bigint[];
+    timestamp: number;
+    merklized: number;
+    claimPathKey: bigint;
+    claimPathNotExists: number;
+    isRevocationChecked: number;
+    proofType: number;
+    linkID: bigint;
+    nullifier: bigint;
+    operatorOutput: bigint;
+    verifierID: Id;
+    nullifierSessionID: bigint;
+    pubSignalsUnmarshal(data: Uint8Array): AtomicQueryV3PubSignals;
+}
+export {};

package/dist/types/circuits/common.d.ts

@@ -3,7 +3,7 @@ import { TreeState } from './models';
 export declare const defaultMTLevels = 40;
 export declare const defaultValueArraySize = 64;
 export declare const defaultMTLevelsOnChain = 64;
-export declare const defaultMTLevelsClaimsMerklization = 32;
+export declare const defaultMTLevelsClaim = 32;
 export declare const ErrorEmptyAuthClaimProof = "empty auth claim mtp proof";
 export declare const ErrorEmptyAuthClaimNonRevProof = "empty auth claim non-revocation mtp proof";
 export declare const ErrorEmptyChallengeSignature = "empty challenge signature";
@@ -23,7 +23,7 @@ export declare class BaseConfig {
     mtLevel: number;
     valueArraySize: number;
     mtLevelOnChain: number;
-    mtLevelClaimsMerklization: number;
+    mtLevelClaim: number;
     /**
      *  getMTLevel max circuit MT levels
      *
@@ -31,11 +31,11 @@ export declare class BaseConfig {
      */
     getMTLevel(): number;
     /**
-     *  getMTLevel max circuit MT levels
+     *  GetMTLevelsClaim max jsonld Claim levels
      *
      * @returns number
      */
-    getMTLevelsClaimMerklization(): number;
+    getMTLevelsClaim(): number;
     /**
      * GetValueArrSize return size of circuits value array size
      *

package/dist/types/circuits/comparer.d.ts

@@ -1,3 +1,17 @@
+/**
+ * Represents the XSD namespace and its corresponding data types.
+ */
+export declare enum XSDNS {
+    Boolean = "http://www.w3.org/2001/XMLSchema#boolean",
+    Integer = "http://www.w3.org/2001/XMLSchema#integer",
+    NonNegativeInteger = "http://www.w3.org/2001/XMLSchema#nonNegativeInteger",
+    NonPositiveInteger = "http://www.w3.org/2001/XMLSchema#nonPositiveInteger",
+    NegativeInteger = "http://www.w3.org/2001/XMLSchema#negativeInteger",
+    PositiveInteger = "http://www.w3.org/2001/XMLSchema#positiveInteger",
+    DateTime = "http://www.w3.org/2001/XMLSchema#dateTime",
+    Double = "http://www.w3.org/2001/XMLSchema#double",
+    String = "http://www.w3.org/2001/XMLSchema#string"
+}
 /**
  * List of available operators.
  *
@@ -10,7 +24,12 @@ export declare enum Operators {
     GT = 3,
     IN = 4,
     NIN = 5,
-    NE = 6
+    NE = 6,
+    LTE = 7,
+    GTE = 8,
+    BETWEEN = 9,
+    SD = 16,
+    NULLIFY = 17
 }
 /** QueryOperators represents operators for atomic circuits */
 export declare const QueryOperators: {
@@ -21,7 +40,20 @@ export declare const QueryOperators: {
     $in: Operators;
     $nin: Operators;
     $ne: Operators;
+    $lte: Operators;
+    $gte: Operators;
+    $between: Operators;
+    $sd: Operators;
+    $nullify: Operators;
 };
+export declare const availableTypesOperators: Map<string, Operators[]>;
+/**
+ * Checks if the given operation is valid for the specified datatype.
+ * @param datatype - The datatype to check the operation for.
+ * @param op - The operation to check.
+ * @returns True if the operation is valid, false otherwise.
+ */
+export declare const isValidOperation: (datatype: string, op: number) => boolean;
 export interface IComparer {
     compare(int: number): boolean;
 }

package/dist/types/circuits/index.d.ts

@@ -4,6 +4,10 @@ export * from './comparer';
 export * from './atomic-query-mtp-v2';
 export * from './atomic-query-mtp-v2-on-chain';
 export * from './atomic-query-sig-v2';
+export * from './atomic-query-v3';
+export * from './atomic-query-v3-on-chain';
 export * from './atomic-query-sig-v2-on-chain';
 export * from './auth-v2';
 export * from './state-transition';
+export * from './linked-nullifier';
+export * from './linked-multi-query';