@0xpolygonid/js-sdk 1.7.5 → 1.8.0

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

@@ -0,0 +1,340 @@
+import { poseidon } from '@iden3/js-crypto';
+import { DID, getDateFromUnixTimestamp } from '@iden3/js-iden3-core';
+import { Path } from '@iden3/js-jsonld-merklization';
+import { bigIntCompare, byteEncoder, isGenesisState } from '../../utils';
+import { caclulateCoreSchemaHash, ProofType } from '../../verifiable';
+import { AtomicQueryMTPV2PubSignals } from '../../circuits/atomic-query-mtp-v2';
+import { AtomicQuerySigV2PubSignals } from '../../circuits/atomic-query-sig-v2';
+import { AtomicQueryV3PubSignals } from '../../circuits/atomic-query-v3';
+import { AuthV2PubSignals } from '../../circuits/auth-v2';
+import { BaseConfig } from '../../circuits/common';
+import { LinkedMultiQueryPubSignals } from '../../circuits/linked-multi-query';
+import { CircuitId } from '../../circuits/models';
+import { checkQueryRequest } from './query';
+import { parseQueriesMetadata } from '../common';
+export const 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
+ */
+export 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 AtomicQueryMTPV2PubSignals();
+            mtpv2PubSignals = mtpv2PubSignals.pubSignalsUnmarshal(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 checkQueryRequest(query, outs, 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 AtomicQuerySigV2PubSignals();
+            sigV2PubSignals = sigV2PubSignals.pubSignalsUnmarshal(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 checkQueryRequest(query, outs, 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 AtomicQueryV3PubSignals();
+            v3PubSignals = v3PubSignals.pubSignalsUnmarshal(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 checkQueryRequest(query, outs, CircuitId.AtomicQueryV3, this._documentLoader, verifiablePresentation, opts);
+            const { proofType, verifierID, nullifier, nullifierSessionID, linkID } = v3PubSignals;
+            switch (query.proofType) {
+                case ProofType.BJJSignature:
+                    if (proofType !== 1) {
+                        throw new Error('wrong proof type for BJJSignature');
+                    }
+                    break;
+                case 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 = 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 AuthV2PubSignals();
+            authV2PubSignals = authV2PubSignals.pubSignalsUnmarshal(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() - getDateFromUnixTimestamp(Number(gist.transitionTimestamp)).getTime();
+                if (timeDiff > acceptedStateTransitionDelay) {
+                    throw new Error('global state is outdated');
+                }
+            }
+            // verify Id ownership
+            this.verifyIdOwnership(sender, challenge);
+            return new BaseConfig();
+        };
+        this.linkedMultiQuery10Verify = async ({ query, pubSignals }) => {
+            let multiQueryPubSignals = new LinkedMultiQueryPubSignals();
+            multiQueryPubSignals = multiQueryPubSignals.pubSignalsUnmarshal(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 Path.getTypeIDFromContext(JSON.stringify(schema), query.type || '', ldOpts);
+            const schemaHash = caclulateCoreSchemaHash(byteEncoder.encode(schemaId));
+            const queriesMetadata = await parseQueriesMetadata(query.type || '', ldContextJSON, credentialSubject, ldOpts);
+            const queryHashes = queriesMetadata.map((queryMeta) => {
+                const valueHash = poseidon.spongeHashX(queryMeta.values, 6);
+                return poseidon.hash([
+                    schemaHash.bigInt(),
+                    BigInt(queryMeta.slotIndex),
+                    BigInt(queryMeta.operator),
+                    BigInt(queryMeta.claimPathKey),
+                    queryMeta.merklizedSchema ? 0n : 1n,
+                    valueHash
+                ]);
+            });
+            const circuitQueryHashes = multiQueryPubSignals.circuitQueryHash
+                .filter((i) => i !== 0n)
+                .sort(bigIntCompare);
+            queryHashes.sort(bigIntCompare);
+            if (!queryHashes.every((queryHash, i) => queryHash === circuitQueryHashes[i])) {
+                throw new Error('query hashes do not match');
+            }
+            return multiQueryPubSignals;
+        };
+        this.verifyIdOwnership = (sender, challenge) => {
+            const senderId = DID.idFromDID(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 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() -
+                    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 = DID.parseFromId(id);
+        // check if id is genesis
+        const isGenesis = 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
+        };
+    }
+}

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

@@ -0,0 +1,186 @@
+import { DID, getDateFromUnixTimestamp } from '@iden3/js-iden3-core';
+import { getDocumentLoader, Merklizer, Path } from '@iden3/js-jsonld-merklization';
+import { byteEncoder } from '../../utils';
+import { Operators } from '../../circuits/comparer';
+import { caclulateCoreSchemaHash, VerifiableConstants } from '../../verifiable';
+import { parseQueriesMetadata } from '../common';
+import { circuitValidator } from '../provers';
+const defaultProofGenerationDelayOpts = 24 * 60 * 60 * 1000; // 24 hours
+export async function checkQueryRequest(query, outputs, circuitId, schemaLoader, verifiablePresentation, opts) {
+    // validate issuer
+    const userDID = 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 ?? 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 Path.getTypeIDFromContext(JSON.stringify(schema), query.type, {
+        documentLoader: schemaLoader
+    });
+    const schemaHash = caclulateCoreSchemaHash(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 parseQueriesMetadata(query.type, JSON.stringify(schema), query.credentialSubject, {
+        documentLoader: schemaLoader
+    });
+    const circuitValidationData = circuitValidator[circuitId];
+    if (queriesMetadata.length > circuitValidationData.maxQueriesCount) {
+        throw new Error(`circuit ${circuitId} supports only ${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 === 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 == 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() - getDateFromUnixTimestamp(Number(outputs.timestamp)).getTime();
+        if (timeDiff > acceptedProofGenerationDelay) {
+            throw new Error('generated proof is outdated');
+        }
+    });
+    return;
+}
+async function validateEmptyCredentialSubject(cq, outputs) {
+    if (outputs.operator !== 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 = Path.newPath([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 === 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 !== 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 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 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`);
+    }
+}