@0xpolygonid/js-sdk 1.5.1 → 1.6.0

package/dist/node/esm/proof/proof-service.js

@@ -1,13 +1,14 @@
-import { Hex, Poseidon, Signature } from '@iden3/js-crypto';
-import { BytesHelper, DID, getUnixTimestamp, MerklizedRootPosition } from '@iden3/js-iden3-core';
+import { Poseidon } from '@iden3/js-crypto';
+import { BytesHelper, DID, MerklizedRootPosition } from '@iden3/js-iden3-core';
 import { Hash } from '@iden3/js-merkletree';
-import { AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainInputs, AuthV2Inputs, CircuitClaim, CircuitId, Query, QueryOperators, StateTransitionInputs, ValueProof } from '../circuits';
-import { createVerifiablePresentation, ProofType, verifiablePresentationFromCred } from '../verifiable';
-import { toClaimNonRevStatus, toGISTProof } from './common';
+import { AuthV2Inputs, CircuitId, Operators, Query, StateTransitionInputs, ValueProof } from '../circuits';
+import { createVerifiablePresentation } from '../verifiable';
+import { parseCredentialSubject, parseQueryMetadata, toGISTProof, transformQueryValueToBigInts } from './common';
 import { NativeProver } from './prover';
-import { Merklizer, Path, getDocumentLoader } from '@iden3/js-jsonld-merklization';
-import { Parser, cacheLoader } from '../schema-processor';
+import { getDocumentLoader } from '@iden3/js-jsonld-merklization';
+import { cacheLoader } from '../schema-processor';
 import { byteDecoder, byteEncoder } from '../utils/encoding';
+import { InputGenerator } from './inputs-generator';
 /**
  * Proof service is an implementation of IProofService
  * that works with a native groth16 prover
@@ -30,6 +31,7 @@ export class ProofService {
         this._stateStorage = _stateStorage;
         this._prover = opts?.prover ?? new NativeProver(_circuitStorage);
         this._ldOptions = { ...opts, documentLoader: opts?.documentLoader ?? cacheLoader(opts) };
+        this._inputsGenerator = new InputGenerator(_identityWallet, _credentialWallet, _stateStorage);
     }
     /** {@inheritdoc IProofService.verifyProof} */
     async verifyProof(zkp, circuitId) {
@@ -43,20 +45,61 @@ export class ProofService {
                 challenge: 0n
             };
         }
-        // find credential
-        const credential = opts.credential ?? (await this.findCredential(identifier, proofReq.query));
+        let credentialWithRevStatus = { cred: opts.credential, revStatus: opts.credentialRevocationStatus };
+        if (!opts.credential) {
+            credentialWithRevStatus = await this.findCredentialByProofQuery(identifier, proofReq.query);
+        }
+        if (opts.credential && !opts.credentialRevocationStatus && !opts.skipRevocation) {
+            const revStatus = await this._credentialWallet.getRevocationStatusFromCredential(opts.credential);
+            credentialWithRevStatus = { cred: opts.credential, revStatus };
+        }
+        if (!credentialWithRevStatus.cred) {
+            throw new Error(`credential not found for query ${JSON.stringify(proofReq.query)}`);
+        }
+        const credentialCoreClaim = await this._identityWallet.getCoreClaimFromCredential(credentialWithRevStatus.cred);
         const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(identifier);
-        const preparedCredential = await this.getPreparedCredential(credential);
+        const preparedCredential = {
+            credential: credentialWithRevStatus.cred,
+            credentialCoreClaim,
+            revStatus: credentialWithRevStatus.revStatus
+        };
         const subjectDID = DID.parse(preparedCredential.credential.credentialSubject['id']);
         const { nonce: credentialSubjectProfileNonce, genesisDID: subjectGenesisDID } = await this._identityWallet.getGenesisDIDMetadata(subjectDID);
         if (subjectGenesisDID.string() !== genesisDID.string()) {
             throw new Error('subject and auth profiles are not derived from the same did');
         }
-        const { inputs, vp } = await this.generateInputs(preparedCredential, genesisDID, proofReq, {
+        const propertiesMetadata = parseCredentialSubject(proofReq.query.credentialSubject);
+        if (!propertiesMetadata.length) {
+            throw new Error('no queries in zkp request');
+        }
+        const mtPosition = preparedCredential.credentialCoreClaim.getMerklizedPosition();
+        let mk;
+        if (mtPosition !== MerklizedRootPosition.None) {
+            mk = await preparedCredential.credential.merklize(this._ldOptions);
+        }
+        const context = proofReq.query['context'];
+        const groupId = proofReq.query['groupId'];
+        const ldContext = await this.loadLdContext(context);
+        const credentialType = proofReq.query['type'];
+        const queriesMetadata = [];
+        const circuitQueries = [];
+        for (const propertyMetadata of propertiesMetadata) {
+            const queryMetadata = await parseQueryMetadata(propertyMetadata, byteDecoder.decode(ldContext), credentialType, this._ldOptions);
+            queriesMetadata.push(queryMetadata);
+            const circuitQuery = await this.toCircuitsQuery(preparedCredential.credential, queryMetadata, mk);
+            circuitQueries.push(circuitQuery);
+        }
+        const inputs = await this.generateInputs(preparedCredential, genesisDID, proofReq, {
             ...opts,
             authProfileNonce,
-            credentialSubjectProfileNonce
-        });
+            credentialSubjectProfileNonce,
+            linkNonce: groupId ? opts.linkNonce : 0n
+        }, circuitQueries);
+        const sdQueries = queriesMetadata.filter((q) => q.operator === Operators.SD);
+        let vp;
+        if (sdQueries.length) {
+            vp = createVerifiablePresentation(context, credentialType, preparedCredential.credential, sdQueries);
+        }
         const { proof, pub_signals } = await this._prover.generate(inputs, proofReq.circuitId);
         return {
             id: proofReq.id,
@@ -68,7 +111,7 @@ export class ProofService {
     }
     /** {@inheritdoc IProofService.transitState} */
     async transitState(did, oldTreeState, isOldStateGenesis, stateStorage, ethSigner) {
-        const authInfo = await this.prepareAuthBJJCredential(did, oldTreeState);
+        const authInfo = await this._inputsGenerator.prepareAuthBJJCredential(did, oldTreeState);
         const newTreeModel = await this._identityWallet.getDIDTreeModel(did);
         const claimsRoot = await newTreeModel.claimsTree.root();
         const rootOfRoots = await newTreeModel.rootsTree.root();
@@ -80,17 +123,17 @@ export class ProofService {
             rootOfRoots
         };
         const challenge = Poseidon.hash([oldTreeState.state.bigInt(), newTreeState.state.bigInt()]);
-        const signature = await this._identityWallet.signChallenge(challenge, authInfo.authCredential);
+        const signature = await this._identityWallet.signChallenge(challenge, authInfo.credential);
         const circuitInputs = new StateTransitionInputs();
         circuitInputs.id = DID.idFromDID(did);
         circuitInputs.signature = signature;
         circuitInputs.isOldStateGenesis = isOldStateGenesis;
-        const authClaimIncProofNewState = await this._identityWallet.generateCredentialMtp(did, authInfo.authCredential, newTreeState);
+        const authClaimIncProofNewState = await this._identityWallet.generateCredentialMtp(did, authInfo.credential, newTreeState);
         circuitInputs.newTreeState = authClaimIncProofNewState.treeState;
         circuitInputs.authClaimNewStateIncProof = authClaimIncProofNewState.proof;
         circuitInputs.oldTreeState = oldTreeState;
         circuitInputs.authClaim = {
-            claim: authInfo.authCoreClaim,
+            claim: authInfo.coreClaim,
             incProof: authInfo.incProof,
             nonRevProof: authInfo.nonRevProof
         };
@@ -100,370 +143,65 @@ export class ProofService {
         await this._identityWallet.updateIdentityState(did, true, newTreeState);
         return txId;
     }
-    async getPreparedCredential(credential) {
-        const revStatus = await this._credentialWallet.getRevocationStatusFromCredential(credential);
-        const credCoreClaim = await this._identityWallet.getCoreClaimFromCredential(credential);
-        return { credential, revStatus, credentialCoreClaim: credCoreClaim };
-    }
-    async prepareAuthBJJCredential(did, treeStateInfo) {
-        const authCredential = await this._credentialWallet.getAuthBJJCredential(did);
-        const incProof = await this._identityWallet.generateCredentialMtp(did, authCredential, treeStateInfo);
-        const nonRevProof = await this._identityWallet.generateNonRevocationMtp(did, authCredential, treeStateInfo);
-        const authCoreClaim = authCredential.getCoreClaimFromProof(ProofType.Iden3SparseMerkleTreeProof);
-        if (!authCoreClaim) {
-            throw new Error('auth core claim is not defined for auth bjj credential');
-        }
-        return { authCredential, incProof, nonRevProof, authCoreClaim };
-    }
-    async generateInputs(preparedCredential, identifier, proofReq, params) {
-        let generateInputFn;
-        switch (proofReq.circuitId) {
-            case CircuitId.AtomicQueryMTPV2:
-                generateInputFn = this.generateMTPV2Inputs.bind(this);
-                break;
-            case CircuitId.AtomicQueryMTPV2OnChain:
-                generateInputFn = this.generateMTPV2OnChainInputs.bind(this);
-                break;
-            case CircuitId.AtomicQuerySigV2:
-                generateInputFn = this.generateQuerySigV2Inputs.bind(this);
-                break;
-            case CircuitId.AtomicQuerySigV2OnChain:
-                generateInputFn = this.generateQuerySigV2OnChainInputs.bind(this);
-                break;
-            default:
-                throw new Error(`circuit with id ${proofReq.circuitId} is not supported by issuer`);
-        }
-        return generateInputFn(preparedCredential, identifier, proofReq, params);
-    }
-    async generateMTPV2Inputs(preparedCredential, identifier, proofReq, params) {
-        const circuitClaimData = await this.newCircuitClaimData(preparedCredential.credential, preparedCredential.credentialCoreClaim);
-        circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
-        const circuitInputs = new AtomicQueryMTPV2Inputs();
-        circuitInputs.id = DID.idFromDID(identifier);
-        circuitInputs.requestID = BigInt(proofReq.id);
-        const { query, vp } = await this.toCircuitsQuery(proofReq.query, preparedCredential.credential, preparedCredential.credentialCoreClaim);
-        circuitInputs.query = query;
-        circuitInputs.claim = {
-            issuerID: circuitClaimData.issuerId,
-            claim: circuitClaimData.claim,
-            incProof: { proof: circuitClaimData.proof, treeState: circuitClaimData.treeState },
-            nonRevProof: circuitClaimData.nonRevProof
-        };
-        circuitInputs.currentTimeStamp = getUnixTimestamp(new Date());
-        circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
-        circuitInputs.profileNonce = BigInt(params.authProfileNonce);
-        circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
-        return { inputs: circuitInputs.inputsMarshal(), vp };
-    }
-    async generateMTPV2OnChainInputs(preparedCredential, identifier, proofReq, params) {
-        const circuitClaimData = await this.newCircuitClaimData(preparedCredential.credential, preparedCredential.credentialCoreClaim);
-        const authPrepared = await this.prepareAuthBJJCredential(identifier);
-        const authClaimData = await this.newCircuitClaimData(authPrepared.authCredential, authPrepared.authCoreClaim);
-        circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
-        const circuitInputs = new AtomicQueryMTPV2OnChainInputs();
-        const id = DID.idFromDID(identifier);
-        circuitInputs.id = DID.idFromDID(identifier);
-        circuitInputs.requestID = BigInt(proofReq.id);
-        const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
-        const gistProof = toGISTProof(stateProof);
-        circuitInputs.gistProof = gistProof;
-        if (authClaimData?.treeState) {
-            circuitInputs.treeState = {
-                state: authClaimData?.treeState?.state,
-                claimsRoot: authClaimData?.treeState?.claimsRoot,
-                revocationRoot: authClaimData?.treeState?.revocationRoot,
-                rootOfRoots: authClaimData?.treeState?.rootOfRoots
-            };
-        }
-        circuitInputs.authClaim = authClaimData.claim;
-        circuitInputs.authClaimIncMtp = authClaimData.proof;
-        circuitInputs.authClaimNonRevMtp = authPrepared.nonRevProof.proof;
-        if (!params.challenge) {
-            throw new Error('challenge must be provided for onchain circuits');
-        }
-        const signature = await this._identityWallet.signChallenge(params.challenge, authPrepared.authCredential);
-        circuitInputs.signature = signature;
-        circuitInputs.challenge = params.challenge;
-        const { query, vp } = await this.toCircuitsQuery(proofReq.query, preparedCredential.credential, preparedCredential.credentialCoreClaim);
-        circuitInputs.query = query;
-        circuitInputs.claim = {
-            issuerID: circuitClaimData.issuerId,
-            claim: circuitClaimData.claim,
-            incProof: { proof: circuitClaimData.proof, treeState: circuitClaimData.treeState },
-            nonRevProof: circuitClaimData.nonRevProof
-        };
-        circuitInputs.currentTimeStamp = getUnixTimestamp(new Date());
-        circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
-        circuitInputs.profileNonce = BigInt(params.authProfileNonce);
-        circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
-        return { inputs: circuitInputs.inputsMarshal(), vp };
-    }
-    async generateQuerySigV2Inputs(preparedCredential, identifier, proofReq, params) {
-        const circuitClaimData = await this.newCircuitClaimData(preparedCredential.credential, preparedCredential.credentialCoreClaim);
-        circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
-        const circuitInputs = new AtomicQuerySigV2Inputs();
-        circuitInputs.id = DID.idFromDID(identifier);
-        circuitInputs.claim = {
-            issuerID: circuitClaimData?.issuerId,
-            signatureProof: circuitClaimData.signatureProof,
-            claim: circuitClaimData.claim,
-            nonRevProof: circuitClaimData.nonRevProof
-        };
-        circuitInputs.requestID = BigInt(proofReq.id);
-        circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
-        circuitInputs.profileNonce = BigInt(params.authProfileNonce);
-        circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
-        const { query, vp } = await this.toCircuitsQuery(proofReq.query, preparedCredential.credential, preparedCredential.credentialCoreClaim);
-        circuitInputs.query = query;
-        circuitInputs.currentTimeStamp = getUnixTimestamp(new Date());
-        return { inputs: circuitInputs.inputsMarshal(), vp };
+    async generateInputs(preparedCredential, identifier, proofReq, params, circuitQueries) {
+        return this._inputsGenerator.generateInputs({
+            preparedCredential,
+            identifier,
+            proofReq,
+            params,
+            circuitQueries
+        });
     }
-    async generateQuerySigV2OnChainInputs(preparedCredential, identifier, proofReq, params) {
-        const circuitClaimData = await this.newCircuitClaimData(preparedCredential.credential, preparedCredential.credentialCoreClaim);
-        const authPrepared = await this.prepareAuthBJJCredential(identifier);
-        const authClaimData = await this.newCircuitClaimData(authPrepared.authCredential, authPrepared.authCoreClaim);
-        circuitClaimData.nonRevProof = toClaimNonRevStatus(preparedCredential.revStatus);
-        const circuitInputs = new AtomicQuerySigV2OnChainInputs();
-        const id = DID.idFromDID(identifier);
-        circuitInputs.id = id;
-        circuitInputs.claim = {
-            issuerID: circuitClaimData.issuerId,
-            signatureProof: circuitClaimData.signatureProof,
-            claim: circuitClaimData.claim,
-            nonRevProof: circuitClaimData.nonRevProof
-        };
-        circuitInputs.requestID = BigInt(proofReq.id);
-        circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
-        circuitInputs.profileNonce = BigInt(params.authProfileNonce);
-        circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
-        const { query, vp } = await this.toCircuitsQuery(proofReq.query, preparedCredential.credential, preparedCredential.credentialCoreClaim);
-        circuitInputs.query = query;
-        circuitInputs.currentTimeStamp = getUnixTimestamp(new Date());
-        if (authClaimData.treeState) {
-            circuitInputs.treeState = {
-                state: authClaimData.treeState?.state,
-                claimsRoot: authClaimData.treeState?.claimsRoot,
-                revocationRoot: authClaimData.treeState?.revocationRoot,
-                rootOfRoots: authClaimData.treeState?.rootOfRoots
-            };
+    async toCircuitsQuery(credential, queryMetadata, merklizedCredential) {
+        if (queryMetadata.merklizedSchema && !merklizedCredential) {
+            throw new Error('merklized root position is set to None for merklized schema');
         }
-        const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
-        const gistProof = toGISTProof(stateProof);
-        circuitInputs.gistProof = gistProof;
-        circuitInputs.authClaim = authClaimData.claim;
-        circuitInputs.authClaimIncMtp = authClaimData.proof;
-        circuitInputs.authClaimNonRevMtp = authPrepared.nonRevProof.proof;
-        if (!params.challenge) {
-            throw new Error('challenge must be provided for onchain circuits');
-        }
-        const signature = await this._identityWallet.signChallenge(params.challenge, authPrepared.authCredential);
-        circuitInputs.signature = signature;
-        circuitInputs.challenge = params.challenge;
-        return { inputs: circuitInputs.inputsMarshal(), vp };
-    }
-    // NewCircuitClaimData generates circuits claim structure
-    async newCircuitClaimData(credential, coreClaim) {
-        const smtProof = credential.getIden3SparseMerkleTreeProof();
-        const circuitClaim = new CircuitClaim();
-        circuitClaim.claim = coreClaim;
-        circuitClaim.issuerId = DID.idFromDID(DID.parse(credential.issuer));
-        if (smtProof) {
-            circuitClaim.proof = smtProof.mtp;
-            circuitClaim.treeState = {
-                state: smtProof.issuerData.state.value,
-                claimsRoot: smtProof.issuerData.state.claimsTreeRoot,
-                revocationRoot: smtProof.issuerData.state.revocationTreeRoot,
-                rootOfRoots: smtProof.issuerData.state.rootOfRoots
-            };
+        if (!queryMetadata.merklizedSchema && merklizedCredential) {
+            throw new Error('merklized root position is not set to None for non-merklized schema');
         }
-        const sigProof = credential.getBJJSignature2021Proof();
-        if (sigProof) {
-            const issuerDID = sigProof.issuerData.id;
-            let userDID;
-            if (!credential.credentialSubject.id) {
-                userDID = issuerDID;
-            }
-            else {
-                if (typeof credential.credentialSubject.id !== 'string') {
-                    throw new Error('credential status `id` is not a string');
-                }
-                userDID = DID.parse(credential.credentialSubject.id);
-            }
-            if (!sigProof.issuerData.credentialStatus) {
-                throw new Error("can't check the validity of issuer auth claim: no credential status in proof");
+        const query = new Query();
+        query.slotIndex = queryMetadata.slotIndex;
+        query.operator = queryMetadata.operator;
+        query.values = queryMetadata.values;
+        if (queryMetadata.merklizedSchema && merklizedCredential) {
+            const { proof, value: mtValue } = await merklizedCredential.proof(queryMetadata.path);
+            query.valueProof = new ValueProof();
+            query.valueProof.mtp = proof;
+            query.valueProof.path = queryMetadata.claimPathKey;
+            const mtEntry = await mtValue?.mtEntry();
+            if (!mtEntry) {
+                throw new Error(`can't merklize credential: no merkle tree entry found`);
             }
-            const opts = {
-                issuerGenesisState: sigProof.issuerData.state,
-                issuerDID,
-                userDID
-            };
-            const rs = await this._credentialWallet.getRevocationStatus(sigProof.issuerData.credentialStatus, opts);
-            if (!rs) {
-                throw new Error("can't fetch the credential status of issuer auth claim");
+            query.valueProof.value = mtEntry;
+            if (!queryMetadata.fieldName) {
+                query.values = [mtEntry];
+                return query;
             }
-            const issuerAuthNonRevProof = toClaimNonRevStatus(rs);
-            if (!sigProof.issuerData.mtp) {
-                throw new Error('issuer auth credential must have a mtp proof');
+        }
+        if (queryMetadata.operator === Operators.SD) {
+            const [first, ...rest] = queryMetadata.fieldName.split('.');
+            let v = credential.credentialSubject[first];
+            for (const part of rest) {
+                v = v[part];
             }
-            if (!sigProof.issuerData.authCoreClaim) {
-                throw new Error('issuer auth credential must have a core claim proof');
+            if (typeof v === 'undefined') {
+                throw new Error(`credential doesn't contain value for field ${queryMetadata.fieldName}`);
             }
-            circuitClaim.signatureProof = {
-                signature: sigProof.signature,
-                issuerAuthIncProof: {
-                    proof: sigProof.issuerData.mtp,
-                    treeState: {
-                        state: sigProof.issuerData.state.value,
-                        claimsRoot: sigProof.issuerData.state.claimsTreeRoot,
-                        revocationRoot: sigProof.issuerData.state.revocationTreeRoot,
-                        rootOfRoots: sigProof.issuerData.state.rootOfRoots
-                    }
-                },
-                issuerAuthClaim: sigProof.issuerData.authCoreClaim,
-                issuerAuthNonRevProof
-            };
+            query.values = await transformQueryValueToBigInts(v, queryMetadata.datatype);
         }
-        return circuitClaim;
-    }
-    async toCircuitsQuery(query, credential, coreClaim) {
-        const mtPosition = coreClaim.getMerklizedPosition();
-        return mtPosition === MerklizedRootPosition.None
-            ? this.prepareNonMerklizedQuery(query, credential)
-            : this.prepareMerklizedQuery(query, credential);
+        return query;
     }
-    async prepareMerklizedQuery(query, credential) {
-        const parsedQuery = await this.parseRequest(query.credentialSubject);
-        const ldContext = await this.loadLdContextFromJSONSchema(credential.credentialSchema.id);
-        let path = new Path();
-        if (parsedQuery.fieldName) {
-            path = await Path.getContextPathKey(byteDecoder.decode(ldContext), credential.type[1], parsedQuery.fieldName, this._ldOptions);
-        }
-        path.prepend(['https://www.w3.org/2018/credentials#credentialSubject']);
-        const mk = await credential.merklize(this._ldOptions);
-        const { proof, value: mtValue } = await mk.proof(path);
-        const pathKey = await path.mtEntry();
-        parsedQuery.query.valueProof = new ValueProof();
-        parsedQuery.query.valueProof.mtp = proof;
-        parsedQuery.query.valueProof.path = pathKey;
-        parsedQuery.query.valueProof.mtp = proof;
-        const mtEntry = await mtValue?.mtEntry();
-        if (!mtEntry) {
-            throw new Error(`can't merklize credential: no merkle tree entry found`);
-        }
-        parsedQuery.query.valueProof.value = mtEntry;
-        // for merklized credentials slotIndex in query must be equal to zero
-        // and not a position of merklization root.
-        // it has no influence on check in the off-chain circuits, but it aligns with onchain verification standard
-        parsedQuery.query.slotIndex = 0;
-        if (!parsedQuery.fieldName) {
-            const resultQuery = parsedQuery.query;
-            resultQuery.operator = QueryOperators.$eq;
-            resultQuery.values = [mtEntry];
-            return { query: resultQuery };
-        }
-        if (parsedQuery.isSelectiveDisclosure) {
-            const rawValue = mk.rawValue(path);
-            const vp = createVerifiablePresentation(query.context ?? '', query.type ?? '', parsedQuery.fieldName, rawValue);
-            const resultQuery = parsedQuery.query;
-            resultQuery.operator = QueryOperators.$eq;
-            resultQuery.values = [mtEntry];
-            return { query: resultQuery, vp };
-        }
-        if (parsedQuery.rawValue === null || parsedQuery.rawValue === undefined) {
-            throw new Error('value is not presented in the query');
-        }
-        const ldType = await mk.jsonLDType(path);
-        parsedQuery.query.values = await this.transformQueryValueToBigInts(parsedQuery.rawValue, ldType);
-        return { query: parsedQuery.query };
-    }
-    async prepareNonMerklizedQuery(query, credential) {
-        const ldContext = await this.loadLdContextFromJSONSchema(credential.credentialSchema.id);
-        if (query.credentialSubject && Object.keys(query.credentialSubject).length > 1) {
-            throw new Error('multiple requests are not supported');
-        }
-        const parsedQuery = await this.parseRequest(query.credentialSubject);
-        if (!query.type) {
-            throw new Error('query type is not defined');
-        }
-        parsedQuery.query.slotIndex = await Parser.getFieldSlotIndex(parsedQuery.fieldName, query.type, ldContext);
-        const { vp, mzValue, dataType } = await verifiablePresentationFromCred(credential, query, parsedQuery.fieldName, this._ldOptions);
-        if (parsedQuery.isSelectiveDisclosure) {
-            const resultQuery = parsedQuery.query;
-            resultQuery.operator = QueryOperators.$eq;
-            resultQuery.values = [await mzValue.mtEntry()];
-            return { query: resultQuery, vp };
-        }
-        if (parsedQuery.rawValue === null || parsedQuery.rawValue === undefined) {
-            throw new Error('value is not presented in the query');
-        }
-        parsedQuery.query.values = await this.transformQueryValueToBigInts(parsedQuery.rawValue, dataType);
-        return { query: parsedQuery.query };
-    }
-    async loadLdContextFromJSONSchema(jsonSchemaURL) {
+    async loadLdContext(context) {
         const loader = getDocumentLoader(this._ldOptions);
-        let schema;
-        try {
-            schema = (await loader(jsonSchemaURL)).document;
-        }
-        catch (e) {
-            throw new Error(`can't load credential schema ${jsonSchemaURL}`);
-        }
-        const jsonSchema = schema;
         let ldSchema;
-        let ldContextUrl = '';
         try {
-            ldContextUrl = jsonSchema.$metadata.uris['jsonLdContext'];
-            if (!ldContextUrl) {
-                throw new Error('ldContext is not defined in json schema metadata');
-            }
-            ldSchema = (await loader(ldContextUrl)).document;
+            ldSchema = (await loader(context)).document;
         }
         catch (e) {
-            throw new Error(`can't load ld context from url ${ldContextUrl}`);
+            throw new Error(`can't load ld context from url ${context}`);
         }
         return byteEncoder.encode(JSON.stringify(ldSchema));
     }
-    async parseRequest(req) {
-        if (!req) {
-            const query = new Query();
-            query.operator = QueryOperators.$eq;
-            return { query, fieldName: '' };
-        }
-        const entries = Object.entries(req);
-        if (entries.length > 1) {
-            throw new Error(`multiple requests  not supported`);
-        }
-        const [fieldName, fieldReq] = entries[0];
-        const fieldReqEntries = Object.entries(fieldReq);
-        if (fieldReqEntries.length > 1) {
-            throw new Error(`multiple predicates for one field not supported`);
-        }
-        const isSelectiveDisclosure = fieldReqEntries.length === 0;
-        const query = new Query();
-        if (isSelectiveDisclosure) {
-            return { query, fieldName, isSelectiveDisclosure };
-        }
-        let operator = 0;
-        const [key, value] = fieldReqEntries[0];
-        if (!QueryOperators[key]) {
-            throw new Error(`operator is not supported by lib`);
-        }
-        operator = QueryOperators[key];
-        query.operator = operator;
-        return { query, fieldName, rawValue: value };
-    }
-    async transformQueryValueToBigInts(value, ldType) {
-        const values = new Array(64).fill(BigInt(0));
-        if (Array.isArray(value)) {
-            for (let index = 0; index < value.length; index++) {
-                values[index] = await Merklizer.hashValue(ldType, value[index]);
-            }
-        }
-        else {
-            values[0] = await Merklizer.hashValue(ldType, value);
-        }
-        return values;
-    }
     /** {@inheritdoc IProofService.generateAuthV2Inputs} */
     async generateAuthV2Inputs(hash, did, circuitId) {
         if (circuitId !== CircuitId.AuthV2) {
@@ -471,9 +209,12 @@ export class ProofService {
         }
         const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(did);
         const challenge = BytesHelper.bytesToInt(hash.reverse());
-        const authPrepared = await this.prepareAuthBJJCredential(genesisDID);
-        const authClaimData = await this.newCircuitClaimData(authPrepared.authCredential, authPrepared.authCoreClaim);
-        const signature = await this._identityWallet.signChallenge(challenge, authPrepared.authCredential);
+        const authPrepared = await this._inputsGenerator.prepareAuthBJJCredential(genesisDID);
+        const authClaimData = await this._inputsGenerator.newCircuitClaimData({
+            credential: authPrepared.credential,
+            credentialCoreClaim: authPrepared.coreClaim
+        });
+        const signature = await this._identityWallet.signChallenge(challenge, authPrepared.credential);
         const id = DID.idFromDID(genesisDID);
         const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
         const gistProof = toGISTProof(stateProof);
@@ -509,7 +250,7 @@ export class ProofService {
         }
         return true;
     }
-    async findCredential(did, query) {
+    async findCredentialByProofQuery(did, query) {
         const credentials = await this._identityWallet.findOwnedCredentialsByDID(did, query);
         if (!credentials.length) {
             throw new Error(`no credentials belong to did or its profiles`);
@@ -517,15 +258,8 @@ export class ProofService {
         //  For EQ / IN / NIN / LT / GT operations selective if credential satisfies query - we can get any.
         // TODO: choose credential for selective credentials
         const credential = query.skipClaimRevocationCheck
-            ? credentials[0]
-            : (await this._credentialWallet.findNonRevokedCredential(credentials)).cred;
+            ? { cred: credentials[0], revStatus: undefined }
+            : await this._credentialWallet.findNonRevokedCredential(credentials);
         return credential;
     }
 }
-// BJJSignatureFromHexString converts hex to  babyjub.Signature
-export const bJJSignatureFromHexString = async (sigHex) => {
-    const signatureBytes = Hex.decodeString(sigHex);
-    const compressedSig = Uint8Array.from(signatureBytes).slice(0, 64);
-    const bjjSig = Signature.newFromCompressed(compressedSig);
-    return bjjSig;
-};

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

@@ -126,6 +126,13 @@ export class Parser {
         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.
+    static async getSerializationAttrFromContext(context, opts, tp) {
+        const ldCtx = await jsonld.processContext(ldcontext.getInitialContext({}), context, opts);
+        return Parser.getSerializationAttrFromParsedContext(ldCtx, tp);
+    }
     static async getSerializationAttrFromParsedContext(ldCtx, tp) {
         const termDef = ldCtx.mappings;
         if (!termDef) {

package/dist/node/esm/schema-processor/json/validator.js

@@ -42,6 +42,7 @@ export class JsonSchemaValidator {
         const validate = (schema.$id ? validator.getSchema(schema.$id) : undefined) || validator.compile(schema);
         const valid = validate(data);
         if (!valid) {
+            // TODO: extract correct error messages
             throw new Error(validate.errors?.map((e) => e.message).join(', '));
         }
         return true;