@0xpolygonid/js-sdk 1.7.4 → 1.8.0

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

@@ -0,0 +1,190 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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");
+const comparer_1 = require("../../circuits/comparer");
+const verifiable_1 = require("../../verifiable");
+const common_1 = require("../common");
+const provers_1 = require("../provers");
+const defaultProofGenerationDelayOpts = 24 * 60 * 60 * 1000; // 24 hours
+async function checkQueryRequest(query, outputs, circuitId, schemaLoader, verifiablePresentation, opts) {
+    // validate issuer
+    const userDID = js_iden3_core_1.DID.parseFromId(outputs.issuerId);
+    const issuerAllowed = !query.allowedIssuers ||
+        query.allowedIssuers?.some((issuer) => issuer === '*' || issuer === userDID.string());
+    if (!issuerAllowed) {
+        throw new Error('issuer is not in allowed list');
+    }
+    // validate schema
+    let schema;
+    try {
+        const loader = schemaLoader ?? (0, js_jsonld_merklization_1.getDocumentLoader)();
+        schema = (await loader(query.context ?? '')).document;
+    }
+    catch (e) {
+        throw new Error(`can't load schema for request query`);
+    }
+    if (!query.type) {
+        throw new Error(`proof query type is undefined`);
+    }
+    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));
+    if (schemaHash.bigInt() !== outputs.schemaHash.bigInt()) {
+        throw new Error(`schema that was used is not equal to requested in query`);
+    }
+    if (!query.skipClaimRevocationCheck && outputs.isRevocationChecked === 0) {
+        throw new Error(`check revocation is required`);
+    }
+    const queriesMetadata = await (0, common_1.parseQueriesMetadata)(query.type, JSON.stringify(schema), query.credentialSubject, {
+        documentLoader: schemaLoader
+    });
+    const circuitValidationData = provers_1.circuitValidator[circuitId];
+    if (queriesMetadata.length > circuitValidationData.maxQueriesCount) {
+        throw new Error(`circuit ${circuitId} supports only ${provers_1.circuitValidator[circuitId].maxQueriesCount} queries`);
+    }
+    const notSupportedOpIndx = queriesMetadata.findIndex((i) => !circuitValidationData.supportedOperations.includes(i.operator));
+    if (notSupportedOpIndx > -1) {
+        throw new Error(`circuit ${circuitId} not support ${queriesMetadata[notSupportedOpIndx].operator} operator`);
+    }
+    queriesMetadata.forEach(async (metadata) => {
+        if (!query.type) {
+            throw new Error(`proof query type is undefined`);
+        }
+        // validate selective disclosure
+        if (metadata.operator === comparer_1.Operators.SD) {
+            try {
+                await validateDisclosure(metadata, outputs, verifiablePresentation, schemaLoader);
+            }
+            catch (e) {
+                throw new Error(`failed to validate selective disclosure: ${e.message}`);
+            }
+        }
+        else if (!metadata.fieldName && metadata.operator == comparer_1.Operators.NOOP) {
+            try {
+                await validateEmptyCredentialSubject(metadata, outputs);
+                return;
+            }
+            catch (e) {
+                throw new Error(`failed to validate operators: ${e.message}`);
+            }
+        }
+        else {
+            try {
+                await validateOperators(metadata, outputs);
+            }
+            catch (e) {
+                throw new Error(`failed to validate operators: ${e.message}`);
+            }
+        }
+        // verify claim
+        if (outputs.merklized === 1) {
+            if (outputs.claimPathNotExists === 1) {
+                throw new Error(`proof doesn't contains target query key`);
+            }
+            if (outputs.claimPathKey !== metadata.claimPathKey) {
+                throw new Error(`proof was generated for another path`);
+            }
+        }
+        else {
+            if (outputs.slotIndex !== metadata.slotIndex) {
+                throw new Error(`wrong claim slot was used in claim`);
+            }
+        }
+        // verify timestamp
+        let acceptedProofGenerationDelay = defaultProofGenerationDelayOpts;
+        if (opts?.acceptedProofGenerationDelay) {
+            acceptedProofGenerationDelay = opts.acceptedProofGenerationDelay;
+        }
+        const timeDiff = Date.now() - (0, js_iden3_core_1.getDateFromUnixTimestamp)(Number(outputs.timestamp)).getTime();
+        if (timeDiff > acceptedProofGenerationDelay) {
+            throw new Error('generated proof is outdated');
+        }
+    });
+    return;
+}
+exports.checkQueryRequest = checkQueryRequest;
+async function validateEmptyCredentialSubject(cq, outputs) {
+    if (outputs.operator !== comparer_1.Operators.EQ) {
+        throw new Error('empty credentialSubject request available only for equal operation');
+    }
+    for (let index = 1; index < outputs.value.length; index++) {
+        if (outputs.value[index] !== 0n) {
+            throw new Error(`empty credentialSubject request not available for array of values`);
+        }
+    }
+    const path = js_jsonld_merklization_1.Path.newPath([verifiable_1.VerifiableConstants.CREDENTIAL_SUBJECT_PATH]);
+    const subjectEntry = await path.mtEntry();
+    if (outputs.claimPathKey !== subjectEntry) {
+        throw new Error(`proof doesn't contain credentialSubject in claimPathKey`);
+    }
+    return;
+}
+async function validateOperators(cq, outputs) {
+    if (outputs.operator !== cq.operator) {
+        throw new Error(`operator that was used is not equal to request`);
+    }
+    if (outputs.operator === comparer_1.Operators.NOOP) {
+        // for noop operator slot and value are not used in this case
+        return;
+    }
+    for (let index = 0; index < outputs.value.length; index++) {
+        if (outputs.value[index] !== cq.values[index]) {
+            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`);
+    }
+    for (let index = 1; index < outputs.value.length; index++) {
+        if (outputs.value[index] !== 0n) {
+            throw new Error(`selective disclosure not available for array of values`);
+        }
+    }
+    let mz;
+    const strVerifiablePresentation = JSON.stringify(verifiablePresentation);
+    try {
+        mz = await js_jsonld_merklization_1.Merklizer.merklizeJSONLD(strVerifiablePresentation, {
+            documentLoader: ldLoader
+        });
+    }
+    catch (e) {
+        throw new Error(`can't merklize verifiablePresentation`);
+    }
+    let merklizedPath;
+    try {
+        const p = `verifiableCredential.credentialSubject.${cq.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`);
+    }
+    let proof;
+    let value;
+    try {
+        ({ proof, value } = await mz.proof(merklizedPath));
+    }
+    catch (e) {
+        throw new Error(`can't get value by path '${cq.fieldName}'`);
+    }
+    if (!value) {
+        throw new Error(`can't get merkle value for field '${cq.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`);
+    }
+}

package/dist/node/cjs/schema-processor/json/parser.js

@@ -25,18 +25,8 @@ var __importStar = (this && this.__importStar) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Parser = void 0;
 const verifiable_1 = require("../../verifiable");
-const js_iden3_core_1 = require("@iden3/js-iden3-core");
-const utils_1 = require("../utils");
-const utils_2 = require("../../utils");
-const js_jsonld_merklization_1 = require("@iden3/js-jsonld-merklization");
 const jsonld = __importStar(require("jsonld/lib"));
 const ldcontext = __importStar(require("jsonld/lib/context"));
-const credentialSubjectFullKey = 'https://www.w3.org/2018/credentials#credentialSubject';
-const verifiableCredentialFullKey = 'https://www.w3.org/2018/credentials#VerifiableCredential';
-const typeFullKey = '@type';
-const contextFullKey = '@context';
-const serializationFullKey = 'iden3_serialization';
-const fieldPrefix = 'iden3:v1:';
 /**
  * Parser can parse claim and schema data according to specification
  *
@@ -45,6 +35,7 @@ const fieldPrefix = 'iden3:v1:';
  */
 class Parser {
     /**
+     *  @deprecated The method should not be used. Use credential.toCoreClaim instead.
      *  ParseClaim creates core.Claim object from W3CCredential
      *
      * @param {W3CCredential} credential - Verifiable Credential
@@ -52,163 +43,53 @@ class Parser {
      * @returns `Promise<CoreClaim>`
      */
     static async parseClaim(credential, opts) {
-        if (!opts) {
-            opts = {
-                revNonce: 0,
-                version: 0,
-                subjectPosition: verifiable_1.SubjectPosition.Index,
-                merklizedRootPosition: verifiable_1.MerklizedRootPosition.None,
-                updatable: false,
-                merklizeOpts: {}
-            };
-        }
-        const mz = await credential.merklize(opts.merklizeOpts);
-        const credentialType = Parser.findCredentialType(mz);
-        const subjectId = credential.credentialSubject['id'];
-        const { slots, nonMerklized } = await this.parseSlots(mz, credential, credentialType);
-        // if schema is for non merklized credential, root position must be set to none ('')
-        // otherwise default position for merklized position is index.
-        if (nonMerklized && opts.merklizedRootPosition !== verifiable_1.MerklizedRootPosition.None) {
-            throw new Error('merklized root position is not supported for non-merklized claims');
-        }
-        if (!nonMerklized && opts.merklizedRootPosition === verifiable_1.MerklizedRootPosition.None) {
-            opts.merklizedRootPosition = verifiable_1.MerklizedRootPosition.Index;
-        }
-        const schemaHash = (0, utils_1.createSchemaHash)(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);
-        }
-        if (credential.expirationDate) {
-            claim.setExpirationDate(new Date(credential.expirationDate));
-        }
-        if (subjectId) {
-            const did = js_iden3_core_1.DID.parse(subjectId.toString());
-            const id = js_iden3_core_1.DID.idFromDID(did);
-            switch (opts.subjectPosition) {
-                case '':
-                case verifiable_1.SubjectPosition.Index:
-                    claim.setIndexId(id);
-                    break;
-                case verifiable_1.SubjectPosition.Value:
-                    claim.setValueId(id);
-                    break;
-                default:
-                    throw new Error('unknown subject position');
-            }
-        }
-        switch (opts.merklizedRootPosition) {
-            case verifiable_1.MerklizedRootPosition.Index: {
-                const mk = await credential.merklize(opts.merklizeOpts);
-                claim.setIndexMerklizedRoot((await mk.root()).bigInt());
-                break;
-            }
-            case verifiable_1.MerklizedRootPosition.Value: {
-                const mk = await credential.merklize(opts.merklizeOpts);
-                claim.setValueMerklizedRoot((await mk.root()).bigInt());
-                break;
-            }
-            case verifiable_1.MerklizedRootPosition.None:
-                break;
-            default:
-                throw new Error('unknown merklized root position');
-        }
-        return claim;
+        return credential.toCoreClaim(opts);
     }
+    /**
+     * @deprecated The method should not be used. Use findCredentialType from verifiable.
+     */
     static findCredentialType(mz) {
-        const opts = mz.options;
-        try {
-            // try to look into credentialSubject.@type to get type of credentials
-            const path1 = new js_jsonld_merklization_1.Path([credentialSubjectFullKey, typeFullKey], opts.hasher);
-            const e = mz.rawValue(path1);
-            return e;
-        }
-        catch (err) {
-            // if type of credentials not found in credentialSubject.@type, loop at
-            // top level @types if it contains two elements: type we are looking for
-            // and "VerifiableCredential" type.
-            const path2 = new js_jsonld_merklization_1.Path([typeFullKey], opts.hasher);
-            const topLevelTypes = mz.rawValue(path2);
-            if (!Array.isArray(topLevelTypes)) {
-                throw new Error('top level @type expected to be an array');
-            }
-            if (topLevelTypes.length !== 2) {
-                throw new Error('top level @type expected to be of length 2');
-            }
-            switch (verifiableCredentialFullKey) {
-                case topLevelTypes[0]:
-                    return topLevelTypes[1];
-                case topLevelTypes[1]:
-                    return topLevelTypes[0];
-                default:
-                    throw new Error('@type(s) are expected to contain VerifiableCredential type');
-            }
-        }
+        return (0, verifiable_1.findCredentialType)(mz);
     }
-    // Get `iden3_serialization` attr definition from context document either using
-    // type name like DeliverAddressMultiTestForked or by type id like
-    // urn:uuid:ac2ede19-b3b9-454d-b1a9-a7b3d5763100.
+    /**
+     *  @deprecated The method should not be used. Use credential.getSerializationAttr instead.
+     *
+     *  Get `iden3_serialization` attr definition from context document either using
+     *  type name like DeliverAddressMultiTestForked or by type id like
+     *  urn:uuid:ac2ede19-b3b9-454d-b1a9-a7b3d5763100.
+     *  */
     static async getSerializationAttr(credential, opts, tp) {
         const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), credential['@context'], opts);
         return Parser.getSerializationAttrFromParsedContext(ldCtx, tp);
     }
-    // Get `iden3_serialization` attr definition from context document either using
-    // type name like DeliverAddressMultiTestForked or by type id like
-    // urn:uuid:ac2ede19-b3b9-454d-b1a9-a7b3d5763100.
+    /**
+     * @deprecated The method should not be used. Use getSerializationAttrFromContext from verifiable.
+     *
+     *  Get `iden3_serialization` attr definition from context document either using
+     *  type name like DeliverAddressMultiTestForked or by type id like
+     *  urn:uuid:ac2ede19-b3b9-454d-b1a9-a7b3d5763100.
+     *
+     */
     static async getSerializationAttrFromContext(context, opts, tp) {
-        const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), context, opts);
-        return Parser.getSerializationAttrFromParsedContext(ldCtx, tp);
+        return (0, verifiable_1.getSerializationAttrFromContext)(context, opts, tp);
     }
+    /**
+     * @deprecated The method should not be used. Use getSerializationAttrFromParsedContext from verifiable.
+     *
+     * */
     static async getSerializationAttrFromParsedContext(ldCtx, tp) {
-        const termDef = ldCtx.mappings;
-        if (!termDef) {
-            throw new Error('terms definitions is not of correct type');
-        }
-        const term = termDef.get(tp) ?? [...termDef.values()].find((value) => value['@id'] === tp);
-        if (!term) {
-            return '';
-        }
-        const termCtx = term[contextFullKey];
-        if (!termCtx) {
-            throw new Error('type @context is not of correct type');
-        }
-        const serStr = termCtx[serializationFullKey] ?? '';
-        return serStr;
+        return (0, verifiable_1.getSerializationAttrFromParsedContext)(ldCtx, tp);
     }
+    /**
+     * @deprecated The method should not be used. Use parseSerializationAttr from verifiable.
+     *
+     */
     static parseSerializationAttr(serAttr) {
-        if (!serAttr.startsWith(fieldPrefix)) {
-            throw new Error('serialization attribute does not have correct prefix');
-        }
-        const parts = serAttr.slice(fieldPrefix.length).split('&');
-        if (parts.length > 4) {
-            throw new Error('serialization attribute has too many parts');
-        }
-        const paths = {};
-        for (const part of parts) {
-            const kv = part.split('=');
-            if (kv.length !== 2) {
-                throw new Error('serialization attribute part does not have correct format');
-            }
-            switch (kv[0]) {
-                case 'slotIndexA':
-                    paths.indexAPath = kv[1];
-                    break;
-                case 'slotIndexB':
-                    paths.indexBPath = kv[1];
-                    break;
-                case 'slotValueA':
-                    paths.valueAPath = kv[1];
-                    break;
-                case 'slotValueB':
-                    paths.valueBPath = kv[1];
-                    break;
-                default:
-                    throw new Error('unknown serialization attribute slot');
-            }
-        }
-        return paths;
+        return (0, verifiable_1.parseSerializationAttr)(serAttr);
     }
     /**
+     *
+     * @deprecated The method should not be used. Use credential.parseSlots instead.
      * ParseSlots converts payload to claim slots using provided schema
      *
      * @param {Merklizer} mz - Merklizer
@@ -217,30 +98,12 @@ class Parser {
      * @returns `ParsedSlots`
      */
     static async parseSlots(mz, credential, credentialType) {
-        // parseSlots converts payload to claim slots using provided schema
-        const slots = {
-            indexA: new Uint8Array(32),
-            indexB: new Uint8Array(32),
-            valueA: new Uint8Array(32),
-            valueB: new Uint8Array(32)
-        };
-        const jsonLDOpts = mz.options;
-        const serAttr = await Parser.getSerializationAttr(credential, jsonLDOpts, credentialType);
-        if (!serAttr) {
-            return { slots, nonMerklized: false };
-        }
-        const sPaths = Parser.parseSerializationAttr(serAttr);
-        const isSPathEmpty = !Object.values(sPaths).some(Boolean);
-        if (isSPathEmpty) {
-            return { slots, nonMerklized: true };
-        }
-        await (0, utils_1.fillSlot)(slots.indexA, mz, sPaths.indexAPath);
-        await (0, utils_1.fillSlot)(slots.indexB, mz, sPaths.indexBPath);
-        await (0, utils_1.fillSlot)(slots.valueA, mz, sPaths.valueAPath);
-        await (0, utils_1.fillSlot)(slots.valueB, mz, sPaths.valueBPath);
-        return { slots, nonMerklized: true };
+        const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), credential['@context'], mz.options);
+        return (0, verifiable_1.parseCoreClaimSlots)(ldCtx, mz, credentialType);
     }
     /**
+     * @deprecated The method should not be used. Use getFieldSlotIndex from verifiable.
+     *
      * GetFieldSlotIndex return index of slot from 0 to 7 (each claim has by default 8 slots) for non-merklized claims
      *
      * @param {string} field - field name
@@ -248,29 +111,7 @@ class Parser {
      * @returns `number`
      */
     static async getFieldSlotIndex(field, typeName, schemaBytes) {
-        let ctxDoc = JSON.parse(utils_2.byteDecoder.decode(schemaBytes));
-        ctxDoc = ctxDoc[contextFullKey];
-        if (ctxDoc === undefined) {
-            throw new Error('document has no @context');
-        }
-        const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), ctxDoc, {});
-        const serAttr = await Parser.getSerializationAttrFromParsedContext(ldCtx, typeName);
-        if (!serAttr) {
-            throw new Error('serialization attribute is not set');
-        }
-        const sPaths = Parser.parseSerializationAttr(serAttr);
-        switch (field) {
-            case sPaths.indexAPath:
-                return 2;
-            case sPaths.indexBPath:
-                return 3;
-            case sPaths.valueAPath:
-                return 6;
-            case sPaths.valueBPath:
-                return 7;
-            default:
-                throw new Error(`field ${field} not specified in serialization info`);
-        }
+        return (0, verifiable_1.getFieldSlotIndex)(field, typeName, schemaBytes);
     }
     /**
      * ExtractCredentialSubjectProperties return credential subject types from JSON schema

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

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fillSlot = exports.credentialSubjectKey = exports.createSchemaHash = exports.checkDataInField = exports.dataFillsSlot = exports.fieldToByteArray = exports.swapEndianness = void 0;
-const js_crypto_1 = require("@iden3/js-crypto");
+exports.credentialSubjectKey = exports.fillSlot = exports.createSchemaHash = exports.checkDataInField = exports.dataFillsSlot = exports.fieldToByteArray = exports.swapEndianness = void 0;
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
-const js_sha3_1 = require("js-sha3");
+const verifiable_1 = require("../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.
@@ -55,41 +54,29 @@ function checkDataInField(data) {
 }
 exports.checkDataInField = checkDataInField;
 /**
+ *
+ * @deprecated The method should not be used. Use caclulateCoreSchemaHash from verifiable.
  * Calculates schema hash
  *
  * @param {Uint8Array} schemaId
  * @returns {*}  {SchemaHash}
  */
 const createSchemaHash = (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));
+    return (0, verifiable_1.caclulateCoreSchemaHash)(schemaId);
 };
 exports.createSchemaHash = createSchemaHash;
-exports.credentialSubjectKey = 'credentialSubject';
 /**
+ *
+ * @deprecated The method should not be used. Use fillCoreClaimSlot from verifiable.
  * checks if data can fill the slot
  *
- * @param {*} data - object that contains field
- * @param {string} fieldName - field name
- * @returns Uint8Array - filled slot
+ * @param {Uint8Array} slotData - slot data
+ * @param {Merklizer} mz - merklizer
+ * @param {string} path - path
+ * @returns {void}
  */
 const fillSlot = async (slotData, mz, path) => {
-    if (!path) {
-        return;
-    }
-    path = exports.credentialSubjectKey + '.' + path;
-    try {
-        const p = await mz.resolveDocPath(path, mz.options);
-        const entry = await mz.entry(p);
-        const intVal = await entry.getValueMtEntry();
-        const bytesVal = js_iden3_core_1.BytesHelper.intToBytes(intVal);
-        slotData.set(bytesVal, 0);
-    }
-    catch (err) {
-        if (err.toString().includes('entry not found')) {
-            throw new Error(`field not found in credential ${path}`);
-        }
-        throw err;
-    }
+    return (0, verifiable_1.fillCoreClaimSlot)(slotData, mz, path);
 };
 exports.fillSlot = fillSlot;
+exports.credentialSubjectKey = 'credentialSubject';

package/dist/node/cjs/storage/blockchain/state.js

@@ -8,6 +8,7 @@ const ethers_1 = require("ethers");
 const circuits_1 = require("../../circuits");
 const utils_1 = require("../../utils");
 const State_json_1 = __importDefault(require("./abi/State.json"));
+const js_iden3_core_1 = require("@iden3/js-iden3-core");
 exports.defaultEthConnectionConfig = {
     url: 'http://localhost:8545',
     defaultGasLimit: 600000,
@@ -33,14 +34,31 @@ class EthStateStorage {
      * Creates an instance of EthStateStorage.
      * @param {EthConnectionConfig} [ethConfig=defaultEthConnectionConfig]
      */
-    constructor(ethConfig = exports.defaultEthConnectionConfig) {
+    constructor(ethConfig) {
         this.ethConfig = ethConfig;
-        this.provider = new ethers_1.JsonRpcProvider(this.ethConfig.url);
-        this.stateContract = new ethers_1.Contract(this.ethConfig.contractAddress, State_json_1.default, this.provider);
+        const config = Array.isArray(ethConfig) ? ethConfig[0] : ethConfig;
+        this.provider = new ethers_1.JsonRpcProvider(config.url);
+        this.stateContract = new ethers_1.Contract(config.contractAddress, State_json_1.default, this.provider);
     }
     /** {@inheritdoc IStateStorage.getLatestStateById} */
     async getLatestStateById(id) {
-        const rawData = await this.stateContract.getStateInfoById(id);
+        const { stateContract } = this.getStateContractAndProviderForId(id);
+        const rawData = await stateContract.getStateInfoById(id);
+        const stateInfo = {
+            id: BigInt(rawData[0]),
+            state: BigInt(rawData[1]),
+            replacedByState: BigInt(rawData[2]),
+            createdAtTimestamp: BigInt(rawData[3]),
+            replacedAtTimestamp: BigInt(rawData[4]),
+            createdAtBlock: BigInt(rawData[5]),
+            replacedAtBlock: BigInt(rawData[6])
+        };
+        return stateInfo;
+    }
+    /** {@inheritdoc IStateStorage.getStateInfoByIdAndState} */
+    async getStateInfoByIdAndState(id, state) {
+        const { stateContract } = this.getStateContractAndProviderForId(id);
+        const rawData = await stateContract.getStateInfoByIdAndState(id, state);
         const stateInfo = {
             id: BigInt(rawData[0]),
             state: BigInt(rawData[1]),
@@ -54,10 +72,11 @@ class EthStateStorage {
     }
     /** {@inheritdoc IStateStorage.publishState} */
     async publishState(proof, signer) {
-        const contract = this.stateContract.connect(signer);
         const stateTransitionPubSig = new circuits_1.StateTransitionPubSignals();
         stateTransitionPubSig.pubSignalsUnmarshal(utils_1.byteEncoder.encode(JSON.stringify(proof.pub_signals)));
         const { userId, oldUserState, newUserState, isOldStateGenesis } = stateTransitionPubSig;
+        const { stateContract, provider } = this.getStateContractAndProviderForId(userId.bigInt());
+        const contract = stateContract.connect(signer);
         const payload = [
             userId.bigInt().toString(),
             oldUserState.bigInt().toString(),
@@ -70,7 +89,7 @@ class EthStateStorage {
             ],
             proof.proof.pi_c.slice(0, 2)
         ];
-        const feeData = await this.provider.getFeeData();
+        const feeData = await provider.getFeeData();
         const maxFeePerGas = exports.defaultEthConnectionConfig.maxFeePerGas
             ? BigInt(exports.defaultEthConnectionConfig.maxFeePerGas)
             : feeData.maxFeePerGas;
@@ -100,7 +119,8 @@ class EthStateStorage {
     }
     /** {@inheritdoc IStateStorage.getGISTProof} */
     async getGISTProof(id) {
-        const data = await this.stateContract.getGISTProof(id);
+        const { stateContract } = this.getStateContractAndProviderForId(id);
+        const data = await stateContract.getGISTProof(id);
         return {
             root: BigInt(data.root.toString()),
             existence: data.existence,
@@ -114,7 +134,8 @@ class EthStateStorage {
     }
     /** {@inheritdoc IStateStorage.getGISTRootInfo} */
     async getGISTRootInfo(id) {
-        const data = await this.stateContract.getGISTRootInfo(id);
+        const { stateContract } = this.getStateContractAndProviderForId(id);
+        const data = await stateContract.getGISTRootInfo(id);
         return {
             root: BigInt(data.root.toString()),
             replacedByRoot: BigInt(data.replacedByRoot.toString()),
@@ -124,5 +145,29 @@ class EthStateStorage {
             replacedAtBlock: BigInt(data.replacedAtBlock.toString())
         };
     }
+    getStateContractAndProviderForId(id) {
+        const idTyped = js_iden3_core_1.Id.fromBigInt(id);
+        if (!Array.isArray(this.ethConfig)) {
+            return {
+                stateContract: this.stateContract,
+                provider: this.provider
+            };
+        }
+        const chainId = (0, js_iden3_core_1.getChainId)(js_iden3_core_1.DID.blockchainFromId(idTyped), js_iden3_core_1.DID.networkIdFromId(idTyped));
+        const config = this.networkByChainId(chainId);
+        const provider = new ethers_1.JsonRpcProvider(config.url);
+        const stateContract = new ethers_1.Contract(config.contractAddress, State_json_1.default, this.provider);
+        return { stateContract, provider };
+    }
+    networkByChainId(chainId) {
+        if (Array.isArray(this.ethConfig)) {
+            const network = this.ethConfig.find((c) => c.chainId === chainId);
+            if (!network) {
+                throw new Error(`chainId "${chainId}" not supported`);
+            }
+            return network;
+        }
+        return this.ethConfig;
+    }
 }
 exports.EthStateStorage = EthStateStorage;

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

@@ -163,8 +163,8 @@ const StandardJSONCredentialsQueryFilter = (query) => {
             case 'claimId':
                 return acc.concat(new FilterQuery('id', exports.comparatorOptions.$eq, queryValue));
             case 'allowedIssuers': {
-                const [first] = queryValue || [];
-                if (first && first === '*') {
+                const queryValueParam = queryValue || ['*'];
+                if (queryValueParam.includes('*')) {
                     return acc;
                 }
                 return acc.concat(new FilterQuery('issuer', exports.comparatorOptions.$in, queryValue));