@0xpolygonid/js-sdk 1.7.4 → 1.8.0

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

@@ -1,22 +1,31 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InputGenerator = void 0;
+exports.InputGenerator = exports.circuitValidator = void 0;
 const js_iden3_core_1 = require("@iden3/js-iden3-core");
-const verifiable_1 = require("../verifiable");
-const circuits_1 = require("../circuits");
-const common_1 = require("./common");
-const credentials_1 = require("../credentials");
-const circuitValidator = {
-    [circuits_1.CircuitId.AtomicQueryMTPV2]: { maxQueriesCount: 1 },
-    [circuits_1.CircuitId.AtomicQueryMTPV2OnChain]: { maxQueriesCount: 1 },
-    [circuits_1.CircuitId.AtomicQuerySigV2]: { maxQueriesCount: 1 },
-    [circuits_1.CircuitId.AtomicQuerySigV2OnChain]: { maxQueriesCount: 1 },
-    [circuits_1.CircuitId.AtomicQueryV3]: { maxQueriesCount: 1 },
-    [circuits_1.CircuitId.AtomicQueryV3OnChain]: { maxQueriesCount: 1 },
-    [circuits_1.CircuitId.AuthV2]: { maxQueriesCount: 0 },
-    [circuits_1.CircuitId.StateTransition]: { maxQueriesCount: 0 },
-    [circuits_1.CircuitId.LinkedNullifier]: { maxQueriesCount: 1 },
-    [circuits_1.CircuitId.LinkedMultiQuery10]: { maxQueriesCount: 10 }
+const verifiable_1 = require("../../verifiable");
+const circuits_1 = require("../../circuits");
+const common_1 = require("../common");
+const credentials_1 = require("../../credentials");
+const allOperations = Object.values(circuits_1.QueryOperators);
+const v2Operations = [
+    circuits_1.Operators.NOOP,
+    circuits_1.Operators.EQ,
+    circuits_1.Operators.LT,
+    circuits_1.Operators.GT,
+    circuits_1.Operators.IN,
+    circuits_1.Operators.NIN,
+    circuits_1.Operators.NE
+];
+exports.circuitValidator = {
+    [circuits_1.CircuitId.AtomicQueryMTPV2]: { maxQueriesCount: 1, supportedOperations: v2Operations },
+    [circuits_1.CircuitId.AtomicQueryMTPV2OnChain]: { maxQueriesCount: 1, supportedOperations: v2Operations },
+    [circuits_1.CircuitId.AtomicQuerySigV2]: { maxQueriesCount: 1, supportedOperations: v2Operations },
+    [circuits_1.CircuitId.AtomicQuerySigV2OnChain]: { maxQueriesCount: 1, supportedOperations: v2Operations },
+    [circuits_1.CircuitId.AtomicQueryV3]: { maxQueriesCount: 1, supportedOperations: allOperations },
+    [circuits_1.CircuitId.AtomicQueryV3OnChain]: { maxQueriesCount: 1, supportedOperations: allOperations },
+    [circuits_1.CircuitId.AuthV2]: { maxQueriesCount: 0, supportedOperations: [] },
+    [circuits_1.CircuitId.StateTransition]: { maxQueriesCount: 0, supportedOperations: [] },
+    [circuits_1.CircuitId.LinkedMultiQuery10]: { maxQueriesCount: 10, supportedOperations: allOperations }
 };
 class InputGenerator {
     constructor(_identityWallet, _credentialWallet, _stateStorage) {
@@ -30,7 +39,7 @@ class InputGenerator {
             circuitInputs.id = js_iden3_core_1.DID.idFromDID(identifier);
             circuitInputs.requestID = BigInt(proofReq.id);
             const query = circuitQueries[0];
-            query.operator = query.operator === circuits_1.Operators.SD ? circuits_1.Operators.EQ : query.operator;
+            query.operator = this.transformV2QueryOperator(query.operator);
             circuitInputs.query = query;
             circuitInputs.claim = {
                 issuerID: circuitClaimData.issuerId,
@@ -77,7 +86,7 @@ class InputGenerator {
             circuitInputs.signature = signature;
             circuitInputs.challenge = params.challenge;
             const query = circuitQueries[0];
-            query.operator = query.operator === circuits_1.Operators.SD ? circuits_1.Operators.EQ : query.operator;
+            query.operator = this.transformV2QueryOperator(query.operator);
             circuitInputs.query = query;
             circuitInputs.claim = {
                 issuerID: circuitClaimData.issuerId,
@@ -107,7 +116,7 @@ class InputGenerator {
             circuitInputs.profileNonce = BigInt(params.authProfileNonce);
             circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
             const query = circuitQueries[0];
-            query.operator = query.operator === circuits_1.Operators.SD ? circuits_1.Operators.EQ : query.operator;
+            query.operator = this.transformV2QueryOperator(query.operator);
             circuitInputs.query = query;
             circuitInputs.currentTimeStamp = (0, js_iden3_core_1.getUnixTimestamp)(new Date());
             return circuitInputs.inputsMarshal();
@@ -134,7 +143,7 @@ class InputGenerator {
             circuitInputs.profileNonce = BigInt(params.authProfileNonce);
             circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
             const query = circuitQueries[0];
-            query.operator = query.operator === circuits_1.Operators.SD ? circuits_1.Operators.EQ : query.operator;
+            query.operator = this.transformV2QueryOperator(query.operator);
             circuitInputs.query = query;
             circuitInputs.currentTimeStamp = (0, js_iden3_core_1.getUnixTimestamp)(new Date());
             if (authClaimData.treeState) {
@@ -196,7 +205,10 @@ class InputGenerator {
             circuitInputs.profileNonce = BigInt(params.authProfileNonce);
             circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
             const query = circuitQueries[0];
-            query.values = query.operator === circuits_1.Operators.SD ? new Array(64).fill(0) : query.values;
+            query.values =
+                query.operator === circuits_1.Operators.SD || query.operator === circuits_1.Operators.NOOP
+                    ? new Array(circuits_1.defaultValueArraySize).fill(0)
+                    : query.values;
             circuitInputs.query = query;
             circuitInputs.currentTimeStamp = (0, js_iden3_core_1.getUnixTimestamp)(new Date());
             circuitInputs.proofType = proofType;
@@ -244,7 +256,10 @@ class InputGenerator {
             circuitInputs.profileNonce = BigInt(params.authProfileNonce);
             circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
             const query = circuitQueries[0];
-            query.values = query.operator === circuits_1.Operators.SD ? new Array(64).fill(0) : query.values;
+            query.values =
+                query.operator === circuits_1.Operators.SD || query.operator === circuits_1.Operators.NOOP
+                    ? new Array(circuits_1.defaultValueArraySize).fill(0)
+                    : query.values;
             circuitInputs.query = query;
             circuitInputs.currentTimeStamp = (0, js_iden3_core_1.getUnixTimestamp)(new Date());
             circuitInputs.proofType = proofType;
@@ -284,28 +299,13 @@ class InputGenerator {
             }
             return circuitInputs.inputsMarshal();
         };
-        this.linkedNullifierPrepareInputs = async ({ preparedCredential, identifier, proofReq, params }) => {
-            const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
-            circuitClaimData.nonRevProof = (0, common_1.toClaimNonRevStatus)(preparedCredential.revStatus);
-            const circuitInputs = new circuits_1.LinkedNullifierInputs();
-            circuitInputs.linkNonce = params.linkNonce ?? BigInt(0);
-            circuitInputs.issuerClaim = circuitClaimData.claim;
-            circuitInputs.id = js_iden3_core_1.DID.idFromDID(identifier);
-            circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
-            circuitInputs.verifierID = params.verifierDid ? js_iden3_core_1.DID.idFromDID(params.verifierDid) : undefined;
-            circuitInputs.nullifierSessionID = proofReq.params?.nullifierSessionID
-                ? BigInt(proofReq.params?.nullifierSessionID?.toString())
-                : BigInt(0);
-            return circuitInputs.inputsMarshal();
-        };
-        this.linkedMultiQuery10PrepareInputs = async ({ preparedCredential, proofReq, params, circuitQueries }) => {
+        this.linkedMultiQuery10PrepareInputs = async ({ preparedCredential, params, circuitQueries }) => {
             const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
             circuitClaimData.nonRevProof = (0, common_1.toClaimNonRevStatus)(preparedCredential.revStatus);
             const circuitInputs = new circuits_1.LinkedMultiQueryInputs();
             circuitInputs.linkNonce = params.linkNonce ?? BigInt(0);
             circuitInputs.claim = circuitClaimData.claim;
             circuitInputs.query = circuitQueries;
-            circuitInputs.queryLength = circuitValidator[proofReq.circuitId].maxQueriesCount;
             return circuitInputs.inputsMarshal();
         };
     }
@@ -313,8 +313,8 @@ class InputGenerator {
         const { circuitId } = ctx.proofReq;
         const fnName = `${circuitId.split('-')[0]}PrepareInputs`;
         const queriesLength = ctx.circuitQueries.length;
-        if (queriesLength > circuitValidator[circuitId].maxQueriesCount) {
-            throw new Error(`circuit ${circuitId} supports only ${circuitValidator[circuitId].maxQueriesCount} queries`);
+        if (queriesLength > exports.circuitValidator[circuitId].maxQueriesCount) {
+            throw new Error(`circuit ${circuitId} supports only ${exports.circuitValidator[circuitId].maxQueriesCount} queries`);
         }
         const fn = this[fnName];
         if (!fn) {
@@ -389,5 +389,8 @@ class InputGenerator {
             coreClaim: authCoreClaim
         };
     }
+    transformV2QueryOperator(operator) {
+        return operator === circuits_1.Operators.SD || operator === circuits_1.Operators.NOOP ? circuits_1.Operators.EQ : operator;
+    }
 }
 exports.InputGenerator = InputGenerator;

package/dist/node/cjs/proof/{prover.js → provers/prover.js}

@@ -2,9 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NativeProver = void 0;
 const witness_calculator_1 = require("./witness_calculator");
-const utils_1 = require("../utils");
 const snarkjs_1 = require("snarkjs");
 const ffjavascript_1 = require("ffjavascript");
+const utils_1 = require("../../utils");
 /**
  *  NativeProver service responsible for zk generation and verification of groth16 algorithm with bn128 curve
  * @public

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

@@ -0,0 +1,18 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./pub-signals-verifier"), exports);
+__exportStar(require("./query"), exports);

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

@@ -0,0 +1,344 @@
+"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");
+const verifiable_1 = require("../../verifiable");
+const atomic_query_mtp_v2_1 = require("../../circuits/atomic-query-mtp-v2");
+const atomic_query_sig_v2_1 = require("../../circuits/atomic-query-sig-v2");
+const atomic_query_v3_1 = require("../../circuits/atomic-query-v3");
+const auth_v2_1 = require("../../circuits/auth-v2");
+const common_1 = require("../../circuits/common");
+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");
+exports.userStateError = new Error(`user state is not valid`);
+const zeroInt = 0n;
+const defaultProofVerifyOpts = 1 * 60 * 60 * 1000; // 1 hour
+const defaultAuthVerifyOpts = 5 * 60 * 1000; // 5 minutes
+/**
+ * PubSignalsVerifier provides verify method
+ * @public
+ * @class PubSignalsVerifier
+ */
+class PubSignalsVerifier {
+    /**
+     * Creates an instance of PubSignalsVerifier.
+     * @param {DocumentLoader} _documentLoader document loader
+     * @param {IStateStorage} _stateStorage state storage
+     */
+    constructor(_documentLoader, _stateStorage) {
+        this._documentLoader = _documentLoader;
+        this._stateStorage = _stateStorage;
+        this.credentialAtomicQueryMTPV2Verify = async ({ query, verifiablePresentation, sender, challenge, pubSignals, opts }) => {
+            let mtpv2PubSignals = new atomic_query_mtp_v2_1.AtomicQueryMTPV2PubSignals();
+            mtpv2PubSignals = mtpv2PubSignals.pubSignalsUnmarshal(utils_1.byteEncoder.encode(JSON.stringify(pubSignals)));
+            if (!mtpv2PubSignals.userID) {
+                throw new Error('user id is not presented in proof public signals');
+            }
+            if (!mtpv2PubSignals.requestID) {
+                throw new Error('requestId is not presented in proof public signals');
+            }
+            this.userId = mtpv2PubSignals.userID;
+            this.challenge = mtpv2PubSignals.requestID;
+            // verify query
+            const outs = {
+                issuerId: mtpv2PubSignals.issuerID,
+                schemaHash: mtpv2PubSignals.claimSchema,
+                slotIndex: mtpv2PubSignals.slotIndex,
+                operator: mtpv2PubSignals.operator,
+                value: mtpv2PubSignals.value,
+                timestamp: mtpv2PubSignals.timestamp,
+                merklized: mtpv2PubSignals.merklized,
+                claimPathKey: mtpv2PubSignals.claimPathKey,
+                claimPathNotExists: mtpv2PubSignals.claimPathNotExists,
+                valueArraySize: mtpv2PubSignals.getValueArrSize(),
+                isRevocationChecked: mtpv2PubSignals.isRevocationChecked
+            };
+            await (0, query_1.checkQueryRequest)(query, outs, models_1.CircuitId.AtomicQueryMTPV2, this._documentLoader, verifiablePresentation, opts);
+            // verify state
+            await this.checkStateExistenceForId(mtpv2PubSignals.issuerID, mtpv2PubSignals.issuerClaimIdenState);
+            if (mtpv2PubSignals.isRevocationChecked !== 0) {
+                await this.checkRevocationState(mtpv2PubSignals.issuerID, mtpv2PubSignals.issuerClaimNonRevState, opts);
+            }
+            // verify ID ownership
+            this.verifyIdOwnership(sender, challenge);
+            return mtpv2PubSignals;
+        };
+        this.credentialAtomicQuerySigV2Verify = async ({ query, verifiablePresentation, sender, challenge, pubSignals, opts }) => {
+            let sigV2PubSignals = new atomic_query_sig_v2_1.AtomicQuerySigV2PubSignals();
+            sigV2PubSignals = sigV2PubSignals.pubSignalsUnmarshal(utils_1.byteEncoder.encode(JSON.stringify(pubSignals)));
+            this.userId = sigV2PubSignals.userID;
+            this.challenge = sigV2PubSignals.requestID;
+            // verify query
+            const outs = {
+                issuerId: sigV2PubSignals.issuerID,
+                schemaHash: sigV2PubSignals.claimSchema,
+                slotIndex: sigV2PubSignals.slotIndex,
+                operator: sigV2PubSignals.operator,
+                value: sigV2PubSignals.value,
+                timestamp: sigV2PubSignals.timestamp,
+                merklized: sigV2PubSignals.merklized,
+                claimPathKey: sigV2PubSignals.claimPathKey,
+                claimPathNotExists: sigV2PubSignals.claimPathNotExists,
+                valueArraySize: sigV2PubSignals.getValueArrSize(),
+                isRevocationChecked: sigV2PubSignals.isRevocationChecked
+            };
+            await (0, query_1.checkQueryRequest)(query, outs, models_1.CircuitId.AtomicQuerySigV2, this._documentLoader, verifiablePresentation, opts);
+            // verify state
+            await this.checkStateExistenceForId(sigV2PubSignals.issuerID, sigV2PubSignals.issuerAuthState);
+            if (sigV2PubSignals.isRevocationChecked !== 0) {
+                await this.checkRevocationState(sigV2PubSignals.issuerID, sigV2PubSignals.issuerClaimNonRevState, opts);
+            }
+            // verify Id ownership
+            this.verifyIdOwnership(sender, challenge);
+            return sigV2PubSignals;
+        };
+        this.credentialAtomicQueryV3Verify = async ({ query, verifiablePresentation, sender, challenge, pubSignals, opts, params }) => {
+            let v3PubSignals = new atomic_query_v3_1.AtomicQueryV3PubSignals();
+            v3PubSignals = v3PubSignals.pubSignalsUnmarshal(utils_1.byteEncoder.encode(JSON.stringify(pubSignals)));
+            this.userId = v3PubSignals.userID;
+            this.challenge = v3PubSignals.requestID;
+            // verify query
+            const outs = {
+                issuerId: v3PubSignals.issuerID,
+                schemaHash: v3PubSignals.claimSchema,
+                slotIndex: v3PubSignals.slotIndex,
+                operator: v3PubSignals.operator,
+                value: v3PubSignals.value,
+                timestamp: v3PubSignals.timestamp,
+                merklized: v3PubSignals.merklized,
+                claimPathKey: v3PubSignals.claimPathKey,
+                claimPathNotExists: v3PubSignals.claimPathNotExists,
+                valueArraySize: v3PubSignals.getValueArrSize(),
+                isRevocationChecked: v3PubSignals.isRevocationChecked
+            };
+            await (0, query_1.checkQueryRequest)(query, outs, models_1.CircuitId.AtomicQueryV3, this._documentLoader, verifiablePresentation, opts);
+            const { proofType, verifierID, nullifier, nullifierSessionID, linkID } = v3PubSignals;
+            switch (query.proofType) {
+                case verifiable_1.ProofType.BJJSignature:
+                    if (proofType !== 1) {
+                        throw new Error('wrong proof type for BJJSignature');
+                    }
+                    break;
+                case verifiable_1.ProofType.Iden3SparseMerkleTreeProof:
+                    if (proofType !== 2) {
+                        throw new Error('wrong proof type for Iden3SparseMerkleTreeProof');
+                    }
+                    break;
+                default:
+                    throw new Error('invalid proof type');
+            }
+            const nSessionId = BigInt(params?.nullifierSessionId ?? 0);
+            if (nSessionId !== 0n) {
+                if (BigInt(nullifier ?? 0) === 0n) {
+                    throw new Error('nullifier should be provided for nullification and should not be 0');
+                }
+                // verify nullifier information
+                const verifierDIDParam = params?.verifierDid;
+                if (!verifierDIDParam) {
+                    throw new Error('verifierDid is required');
+                }
+                const id = js_iden3_core_1.DID.idFromDID(verifierDIDParam);
+                if (verifierID.bigInt() != id.bigInt()) {
+                    throw new Error('wrong verifier is used for nullification');
+                }
+                if (nullifierSessionID !== nSessionId) {
+                    throw new Error(`wrong verifier session id is used for nullification, expected ${nSessionId}, got ${nullifierSessionID}`);
+                }
+            }
+            else if (nullifierSessionID !== 0n) {
+                throw new Error(`Nullifier id is generated but wasn't requested`);
+            }
+            if (!query.groupId && linkID !== 0n) {
+                throw new Error(`proof contains link id, but group id is not provided`);
+            }
+            if (query.groupId && linkID === 0n) {
+                throw new Error("proof doesn't contain link id, but group id is provided");
+            }
+            // verify state
+            await this.checkStateExistenceForId(v3PubSignals.issuerID, v3PubSignals.issuerState);
+            if (v3PubSignals.isRevocationChecked !== 0) {
+                await this.checkRevocationState(v3PubSignals.issuerID, v3PubSignals.issuerClaimNonRevState, opts);
+            }
+            this.verifyIdOwnership(sender, challenge);
+            return v3PubSignals;
+        };
+        this.authV2Verify = async ({ sender, challenge, pubSignals, opts }) => {
+            let authV2PubSignals = new auth_v2_1.AuthV2PubSignals();
+            authV2PubSignals = authV2PubSignals.pubSignalsUnmarshal(utils_1.byteEncoder.encode(JSON.stringify(pubSignals)));
+            this.userId = authV2PubSignals.userID;
+            this.challenge = authV2PubSignals.challenge;
+            // no query verification
+            // verify state
+            const gist = await this.checkGlobalState(authV2PubSignals.GISTRoot);
+            let acceptedStateTransitionDelay = defaultAuthVerifyOpts;
+            if (opts?.acceptedStateTransitionDelay) {
+                acceptedStateTransitionDelay = opts.acceptedStateTransitionDelay;
+            }
+            if (!gist.latest) {
+                const timeDiff = Date.now() - (0, js_iden3_core_1.getDateFromUnixTimestamp)(Number(gist.transitionTimestamp)).getTime();
+                if (timeDiff > acceptedStateTransitionDelay) {
+                    throw new Error('global state is outdated');
+                }
+            }
+            // verify Id ownership
+            this.verifyIdOwnership(sender, challenge);
+            return new common_1.BaseConfig();
+        };
+        this.linkedMultiQuery10Verify = async ({ query, pubSignals }) => {
+            let multiQueryPubSignals = new linked_multi_query_1.LinkedMultiQueryPubSignals();
+            multiQueryPubSignals = multiQueryPubSignals.pubSignalsUnmarshal(utils_1.byteEncoder.encode(JSON.stringify(pubSignals)));
+            // verify query
+            let schema;
+            const ldOpts = { documentLoader: this._documentLoader };
+            try {
+                schema = (await ldOpts.documentLoader(query.context || '')).document;
+            }
+            catch (e) {
+                throw new Error(`can't load schema for request query`);
+            }
+            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 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');
+            }
+            return multiQueryPubSignals;
+        };
+        this.verifyIdOwnership = (sender, challenge) => {
+            const senderId = js_iden3_core_1.DID.idFromDID(js_iden3_core_1.DID.parse(sender));
+            if (senderId.string() !== this.userId.string()) {
+                throw new Error(`sender id is not used for proof creation, expected ${sender}, user from public signals: ${this.userId.string()}`);
+            }
+            if (challenge !== this.challenge) {
+                throw new Error(`challenge is not used for proof creation, expected ${challenge}, challenge from public signals: ${this.challenge}  `);
+            }
+        };
+        this.checkStateExistenceForId = async (userId, userState) => {
+            const { latest } = await this.resolve(userId, userState.bigInt());
+            if (!latest) {
+                throw exports.userStateError;
+            }
+        };
+        this.checkGlobalState = async (state) => {
+            const gistStateResolved = await this.rootResolve(state.bigInt());
+            return gistStateResolved;
+        };
+        this.checkRevocationStateForId = async (issuerId, issuerClaimNonRevState) => {
+            const issuerNonRevStateResolved = await this.resolve(issuerId, issuerClaimNonRevState.bigInt());
+            return issuerNonRevStateResolved;
+        };
+        this.checkRevocationState = async (issuerID, issuerClaimNonRevState, opts) => {
+            const issuerNonRevStateResolved = await this.checkRevocationStateForId(issuerID, issuerClaimNonRevState);
+            const acceptedStateTransitionDelay = opts?.acceptedStateTransitionDelay ?? defaultProofVerifyOpts;
+            if (!issuerNonRevStateResolved.latest) {
+                const timeDiff = Date.now() -
+                    (0, js_iden3_core_1.getDateFromUnixTimestamp)(Number(issuerNonRevStateResolved.transitionTimestamp)).getTime();
+                if (timeDiff > acceptedStateTransitionDelay) {
+                    throw new Error('issuer state is outdated');
+                }
+            }
+        };
+    }
+    /**
+     * verify public signals
+     *
+     * @param {string} circuitId circuit id
+     * @param {VerifyContext} ctx verification parameters
+     * @returns `Promise<BaseConfig>`
+     */
+    async verify(circuitId, ctx) {
+        const fnName = `${circuitId.split('-')[0]}Verify`;
+        const fn = this[fnName];
+        if (!fn) {
+            throw new Error(`public signals verifier for ${circuitId} not found`);
+        }
+        return fn(ctx);
+    }
+    async resolve(id, state) {
+        const idBigInt = id.bigInt();
+        const did = js_iden3_core_1.DID.parseFromId(id);
+        // check if id is genesis
+        const isGenesis = (0, utils_1.isGenesisState)(did, state);
+        let contractState;
+        try {
+            contractState = await this._stateStorage.getStateInfoByIdAndState(idBigInt, state);
+        }
+        catch (e) {
+            if (e.errorArgs[0] === 'State does not exist') {
+                if (isGenesis) {
+                    return {
+                        latest: true,
+                        transitionTimestamp: 0
+                    };
+                }
+                throw new Error('State is not genesis and not registered in the smart contract');
+            }
+            throw e;
+        }
+        if (!contractState.id || contractState.id.toString() !== idBigInt.toString()) {
+            throw new Error(`state was recorded for another identity`);
+        }
+        if (!contractState.state || contractState.state.toString() !== state.toString()) {
+            if (!contractState.replacedAtTimestamp ||
+                contractState.replacedAtTimestamp.toString() === zeroInt.toString()) {
+                throw new Error(`no information about state transition`);
+            }
+            return {
+                latest: false,
+                transitionTimestamp: contractState.replacedAtTimestamp.toString()
+            };
+        }
+        return { latest: true, transitionTimestamp: 0 };
+    }
+    async rootResolve(state) {
+        let globalStateInfo;
+        try {
+            globalStateInfo = await this._stateStorage.getGISTRootInfo(state);
+        }
+        catch (e) {
+            if (e.errorArgs[0] === 'Root does not exist') {
+                throw new Error('GIST root does not exist in the smart contract');
+            }
+            throw e;
+        }
+        if (globalStateInfo.root.toString() !== state.toString()) {
+            throw new Error(`gist info contains invalid state`);
+        }
+        if (globalStateInfo.replacedByRoot.toString() !== zeroInt.toString()) {
+            if (globalStateInfo.replacedAtTimestamp.toString() === zeroInt.toString()) {
+                throw new Error(`state was replaced, but replaced time unknown`);
+            }
+            return {
+                latest: false,
+                transitionTimestamp: globalStateInfo.replacedAtTimestamp.toString()
+            };
+        }
+        return {
+            latest: true,
+            transitionTimestamp: 0
+        };
+    }
+}
+exports.PubSignalsVerifier = PubSignalsVerifier;