@0xpolygonid/js-sdk 1.5.1 → 1.6.0

package/dist/node/cjs/credentials/utils.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getUserDIDFromCredential = void 0;
+const js_iden3_core_1 = require("@iden3/js-iden3-core");
+/**
+ * Retrieves the user DID from a given credential.
+ * If the credential does not have a credentialSubject.id property, the issuer DID is returned.
+ * If the credentialSubject.id is not a string, an error is thrown.
+ * @param issuerDID The DID of the issuer.
+ * @param credential The credential object.
+ * @returns The user DID parsed from the credential.
+ * @throws Error if the credentialSubject.id is not a string.
+ */
+const getUserDIDFromCredential = (issuerDID, credential) => {
+    if (!credential.credentialSubject.id) {
+        return issuerDID;
+    }
+    if (typeof credential.credentialSubject.id !== 'string') {
+        throw new Error('credential subject `id` is not a string');
+    }
+    return js_iden3_core_1.DID.parse(credential.credentialSubject.id);
+};
+exports.getUserDIDFromCredential = getUserDIDFromCredential;

package/dist/node/cjs/iden3comm/handlers/auth.js

@@ -30,6 +30,7 @@ const js_iden3_core_1 = require("@iden3/js-iden3-core");
 const js_jwz_1 = require("@iden3/js-jwz");
 const uuid = __importStar(require("uuid"));
 const utils_1 = require("../../utils");
+const js_crypto_1 = require("@iden3/js-crypto");
 /**
  *
  * Allows to process AuthorizationRequest protocol message and produce JWZ response.
@@ -105,15 +106,55 @@ class AuthHandler {
             from: did.string(),
             to: authRequest.from
         };
-        for (const proofReq of authRequest.body.scope) {
-            const zkpReq = {
-                id: proofReq.id,
-                circuitId: proofReq.circuitId,
-                query: proofReq.query
-            };
+        const requestScope = authRequest.body.scope;
+        const combinedQueries = requestScope.reduce((acc, proofReq) => {
+            const groupId = proofReq.query.groupId;
+            if (!groupId) {
+                return acc;
+            }
+            const existedData = acc.get(groupId);
+            if (!existedData) {
+                const seed = (0, js_crypto_1.getRandomBytes)(12);
+                const dataView = new DataView(seed.buffer);
+                const linkNonce = dataView.getUint32(0);
+                acc.set(groupId, { query: proofReq.query, linkNonce });
+                return acc;
+            }
+            const credentialSubject = (0, utils_1.mergeObjects)(existedData.query.credentialSubject, proofReq.query.credentialSubject);
+            acc.set(groupId, {
+                ...existedData,
+                query: {
+                    skipClaimRevocationCheck: existedData.query.skipClaimRevocationCheck || proofReq.query.skipClaimRevocationCheck,
+                    ...existedData.query,
+                    credentialSubject
+                }
+            });
+            return acc;
+        }, new Map());
+        const groupedCredentialsCache = new Map();
+        for (const proofReq of requestScope) {
             const query = proofReq.query;
-            const zkpRes = await this._proofService.generateProof(zkpReq, did, {
-                skipRevocation: query.skipClaimRevocationCheck ?? false
+            const groupId = query.groupId;
+            const combinedQueryData = combinedQueries.get(groupId);
+            if (groupId) {
+                if (!combinedQueryData) {
+                    throw new Error(`Invalid group id ${query.groupId}`);
+                }
+                const combinedQuery = combinedQueryData.query;
+                if (!groupedCredentialsCache.has(groupId)) {
+                    const credWithRevStatus = await this._proofService.findCredentialByProofQuery(did, combinedQueryData.query);
+                    if (!credWithRevStatus.cred) {
+                        throw new Error(`Credential not found for query ${JSON.stringify(combinedQuery)}`);
+                    }
+                    groupedCredentialsCache.set(groupId, credWithRevStatus);
+                }
+            }
+            const credWithRevStatus = groupedCredentialsCache.get(groupId);
+            const zkpRes = await this._proofService.generateProof(proofReq, did, {
+                skipRevocation: Boolean(query.skipClaimRevocationCheck),
+                credential: credWithRevStatus?.cred,
+                credentialRevocationStatus: credWithRevStatus?.revStatus,
+                linkNonce: combinedQueryData?.linkNonce ? BigInt(combinedQueryData.linkNonce) : undefined
             });
             authResponse.body.scope.push(zkpRes);
         }

package/dist/node/cjs/iden3comm/handlers/contract-request.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContractRequestHandler = void 0;
 const models_1 = require("../../circuits/models");
 const constants_1 = require("../constants");
+const js_iden3_core_1 = require("@iden3/js-iden3-core");
+const utils_1 = require("../../utils");
 /**
  *
  * Allows to process ContractInvokeRequest protocol message
@@ -26,7 +28,8 @@ class ContractRequestHandler {
         this._zkpVerifier = _zkpVerifier;
         this._allowedCircuits = [
             models_1.CircuitId.AtomicQueryMTPV2OnChain,
-            models_1.CircuitId.AtomicQuerySigV2OnChain
+            models_1.CircuitId.AtomicQuerySigV2OnChain,
+            models_1.CircuitId.AtomicQueryV3OnChain
         ];
     }
     /**
@@ -60,19 +63,28 @@ class ContractRequestHandler {
             throw new Error("Can't sign transaction. Provide Signer in options.");
         }
         const zkRequests = [];
+        const { contract_address, chain_id } = ciRequest.body.transaction_data;
+        const networkFlag = Object.keys(js_iden3_core_1.ChainIds).find((key) => js_iden3_core_1.ChainIds[key] === chain_id);
+        if (!networkFlag) {
+            throw new Error(`Invalid chain id ${chain_id}`);
+        }
+        const [blockchain, networkId] = networkFlag.split(':');
+        const verifierId = (0, utils_1.buildVerifierId)(contract_address, {
+            blockchain,
+            networkId,
+            // DidMethod.Iden3 is used based on discussions: all onchain issuers have iden3 did method by default. This can be changed in the release of v3 circuit.
+            method: js_iden3_core_1.DidMethod.Iden3
+        });
+        const verifierDid = js_iden3_core_1.DID.parseFromId(verifierId);
         for (const proofReq of ciRequest.body.scope) {
             if (!this._allowedCircuits.includes(proofReq.circuitId)) {
                 throw new Error(`Can't handle circuit ${proofReq.circuitId}. Only onchain circuits are allowed.`);
             }
-            const zkpReq = {
-                id: proofReq.id,
-                circuitId: proofReq.circuitId,
-                query: proofReq.query
-            };
             const query = proofReq.query;
-            const zkpRes = await this._proofService.generateProof(zkpReq, did, {
+            const zkpRes = await this._proofService.generateProof(proofReq, did, {
                 skipRevocation: query.skipClaimRevocationCheck ?? false,
-                challenge: opts.challenge
+                challenge: opts.challenge,
+                verifierDid
             });
             zkRequests.push(zkpRes);
         }

package/dist/node/cjs/proof/common.js

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.toGISTProof = exports.toClaimNonRevStatus = void 0;
+exports.transformQueryValueToBigInts = exports.parseQueriesMetadata = exports.parseQueryMetadata = exports.parseCredentialSubject = exports.toGISTProof = exports.toClaimNonRevStatus = void 0;
 const js_merkletree_1 = require("@iden3/js-merkletree");
 const circuits_1 = require("../circuits");
+const verifiable_1 = require("../verifiable");
+const js_jsonld_merklization_1 = require("@iden3/js-jsonld-merklization");
+const json_1 = require("../schema-processor/json");
+const utils_1 = require("../utils");
+const js_crypto_1 = require("@iden3/js-crypto");
 /**
  * converts verifiable RevocationStatus model to circuits structure
  *
@@ -10,6 +15,18 @@ const circuits_1 = require("../circuits");
  * @returns {ClaimNonRevStatus}
  */
 const toClaimNonRevStatus = (s) => {
+    if (!s) {
+        const hash = js_crypto_1.poseidon.hash(new Array(3).fill(0n));
+        return {
+            proof: new js_merkletree_1.Proof(),
+            treeState: {
+                state: js_merkletree_1.Hash.fromBigInt(hash),
+                claimsRoot: js_merkletree_1.ZERO_HASH,
+                revocationRoot: js_merkletree_1.ZERO_HASH,
+                rootOfRoots: js_merkletree_1.ZERO_HASH
+            }
+        };
+    }
     return {
         proof: s.mtp,
         treeState: (0, circuits_1.buildTreeState)(s.issuer.state, s.issuer.claimsTreeRoot, s.issuer.revocationTreeRoot, s.issuer.rootOfRoots)
@@ -45,3 +62,89 @@ const toGISTProof = (smtProof) => {
     };
 };
 exports.toGISTProof = toGISTProof;
+const parseCredentialSubject = (credentialSubject) => {
+    // credentialSubject is empty
+    if (!credentialSubject) {
+        return [{ operator: circuits_1.QueryOperators.$eq, fieldName: '' }];
+    }
+    const queries = [];
+    const entries = Object.entries(credentialSubject);
+    if (!entries.length) {
+        throw new Error(`query must have at least 1 predicate`);
+    }
+    for (const [fieldName, fieldReq] of entries) {
+        const fieldReqEntries = Object.entries(fieldReq);
+        const isSelectiveDisclosure = fieldReqEntries.length === 0;
+        if (isSelectiveDisclosure) {
+            queries.push({ operator: circuits_1.QueryOperators.$sd, fieldName: fieldName });
+            continue;
+        }
+        for (const [operatorName, operatorValue] of fieldReqEntries) {
+            if (!circuits_1.QueryOperators[operatorName]) {
+                throw new Error(`operator is not supported by lib`);
+            }
+            const operator = circuits_1.QueryOperators[operatorName];
+            queries.push({ operator, fieldName, operatorValue });
+        }
+    }
+    return queries;
+};
+exports.parseCredentialSubject = parseCredentialSubject;
+const parseQueryMetadata = async (propertyQuery, ldContextJSON, credentialType, options) => {
+    const datatype = await js_jsonld_merklization_1.Path.newTypeFromContext(ldContextJSON, `${credentialType}.${propertyQuery.fieldName}`, options);
+    const query = {
+        ...propertyQuery,
+        slotIndex: 0,
+        merklizedSchema: false,
+        datatype: datatype,
+        claimPathKey: BigInt(0),
+        values: [],
+        path: new js_jsonld_merklization_1.Path()
+    };
+    const serAttr = await json_1.Parser.getSerializationAttrFromContext(JSON.parse(ldContextJSON), options, credentialType);
+    if (!serAttr) {
+        query.merklizedSchema = true;
+    }
+    // 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
+    if (!query.merklizedSchema) {
+        query.slotIndex = await json_1.Parser.getFieldSlotIndex(propertyQuery.fieldName, credentialType, utils_1.byteEncoder.encode(ldContextJSON));
+    }
+    else {
+        try {
+            const path = await (0, verifiable_1.buildFieldPath)(ldContextJSON, credentialType, propertyQuery.fieldName, options);
+            query.claimPathKey = await path.mtEntry();
+            query.path = path;
+        }
+        catch (e) {
+            throw new Error(`field does not exist in the schema ${e.message}`);
+        }
+    }
+    if (propertyQuery.operatorValue) {
+        if (!(0, circuits_1.isValidOperation)(datatype, propertyQuery.operator)) {
+            throw new Error(`operator ${propertyQuery.operator} is not supported for datatype ${datatype}`);
+        }
+        query.values = await (0, exports.transformQueryValueToBigInts)(propertyQuery.operatorValue, datatype);
+    }
+    return query;
+};
+exports.parseQueryMetadata = parseQueryMetadata;
+const parseQueriesMetadata = async (credentialType, ldContextJSON, credentialSubject, options) => {
+    const queriesMetadata = (0, exports.parseCredentialSubject)(credentialSubject);
+    return Promise.all(queriesMetadata.map((m) => (0, exports.parseQueryMetadata)(m, ldContextJSON, credentialType, options)));
+};
+exports.parseQueriesMetadata = parseQueriesMetadata;
+const transformQueryValueToBigInts = async (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 js_jsonld_merklization_1.Merklizer.hashValue(ldType, value[index]);
+        }
+    }
+    else {
+        values[0] = await js_jsonld_merklization_1.Merklizer.hashValue(ldType, value);
+    }
+    return values;
+};
+exports.transformQueryValueToBigInts = transformQueryValueToBigInts;

package/dist/node/cjs/proof/inputs-generator.js

@@ -0,0 +1,393 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InputGenerator = 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 }
+};
+class InputGenerator {
+    constructor(_identityWallet, _credentialWallet, _stateStorage) {
+        this._identityWallet = _identityWallet;
+        this._credentialWallet = _credentialWallet;
+        this._stateStorage = _stateStorage;
+        this.credentialAtomicQueryMTPV2PrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
+            const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+            circuitClaimData.nonRevProof = (0, common_1.toClaimNonRevStatus)(preparedCredential.revStatus);
+            const circuitInputs = new circuits_1.AtomicQueryMTPV2Inputs();
+            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;
+            circuitInputs.query = query;
+            circuitInputs.claim = {
+                issuerID: circuitClaimData.issuerId,
+                claim: circuitClaimData.claim,
+                incProof: { proof: circuitClaimData.proof, treeState: circuitClaimData.treeState },
+                nonRevProof: circuitClaimData.nonRevProof
+            };
+            circuitInputs.currentTimeStamp = (0, js_iden3_core_1.getUnixTimestamp)(new Date());
+            circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
+            circuitInputs.profileNonce = BigInt(params.authProfileNonce);
+            circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
+            return circuitInputs.inputsMarshal();
+        };
+        this.credentialAtomicQueryMTPV2OnChainPrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
+            const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+            const authInfo = await this.prepareAuthBJJCredential(identifier);
+            const authClaimData = await this.newCircuitClaimData({
+                credential: authInfo.credential,
+                credentialCoreClaim: authInfo.coreClaim
+            });
+            circuitClaimData.nonRevProof = (0, common_1.toClaimNonRevStatus)(preparedCredential.revStatus);
+            const circuitInputs = new circuits_1.AtomicQueryMTPV2OnChainInputs();
+            const id = js_iden3_core_1.DID.idFromDID(identifier);
+            circuitInputs.id = js_iden3_core_1.DID.idFromDID(identifier);
+            circuitInputs.requestID = BigInt(proofReq.id);
+            const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
+            const gistProof = (0, common_1.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 = authInfo.nonRevProof.proof;
+            if (!params.challenge) {
+                throw new Error('challenge must be provided for onchain circuits');
+            }
+            const signature = await this._identityWallet.signChallenge(params.challenge, authInfo.credential);
+            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;
+            circuitInputs.query = query;
+            circuitInputs.claim = {
+                issuerID: circuitClaimData.issuerId,
+                claim: circuitClaimData.claim,
+                incProof: { proof: circuitClaimData.proof, treeState: circuitClaimData.treeState },
+                nonRevProof: circuitClaimData.nonRevProof
+            };
+            circuitInputs.currentTimeStamp = (0, js_iden3_core_1.getUnixTimestamp)(new Date());
+            circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
+            circuitInputs.profileNonce = BigInt(params.authProfileNonce);
+            circuitInputs.skipClaimRevocationCheck = params.skipRevocation;
+            return circuitInputs.inputsMarshal();
+        };
+        this.credentialAtomicQuerySigV2PrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
+            const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+            circuitClaimData.nonRevProof = (0, common_1.toClaimNonRevStatus)(preparedCredential.revStatus);
+            const circuitInputs = new circuits_1.AtomicQuerySigV2Inputs();
+            circuitInputs.id = js_iden3_core_1.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 = circuitQueries[0];
+            query.operator = query.operator === circuits_1.Operators.SD ? circuits_1.Operators.EQ : query.operator;
+            circuitInputs.query = query;
+            circuitInputs.currentTimeStamp = (0, js_iden3_core_1.getUnixTimestamp)(new Date());
+            return circuitInputs.inputsMarshal();
+        };
+        this.credentialAtomicQuerySigV2OnChainPrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
+            const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+            const authInfo = await this.prepareAuthBJJCredential(identifier);
+            const authClaimData = await this.newCircuitClaimData({
+                credential: authInfo.credential,
+                credentialCoreClaim: authInfo.coreClaim
+            });
+            circuitClaimData.nonRevProof = (0, common_1.toClaimNonRevStatus)(preparedCredential.revStatus);
+            const circuitInputs = new circuits_1.AtomicQuerySigV2OnChainInputs();
+            const id = js_iden3_core_1.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 = circuitQueries[0];
+            query.operator = query.operator === circuits_1.Operators.SD ? circuits_1.Operators.EQ : query.operator;
+            circuitInputs.query = query;
+            circuitInputs.currentTimeStamp = (0, js_iden3_core_1.getUnixTimestamp)(new Date());
+            if (authClaimData.treeState) {
+                circuitInputs.treeState = {
+                    state: authClaimData.treeState?.state,
+                    claimsRoot: authClaimData.treeState?.claimsRoot,
+                    revocationRoot: authClaimData.treeState?.revocationRoot,
+                    rootOfRoots: authClaimData.treeState?.rootOfRoots
+                };
+            }
+            const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
+            const gistProof = (0, common_1.toGISTProof)(stateProof);
+            circuitInputs.gistProof = gistProof;
+            circuitInputs.authClaim = authClaimData.claim;
+            circuitInputs.authClaimIncMtp = authClaimData.proof;
+            circuitInputs.authClaimNonRevMtp = authInfo.nonRevProof.proof;
+            if (!params.challenge) {
+                throw new Error('challenge must be provided for onchain circuits');
+            }
+            const signature = await this._identityWallet.signChallenge(params.challenge, authInfo.credential);
+            circuitInputs.signature = signature;
+            circuitInputs.challenge = params.challenge;
+            return circuitInputs.inputsMarshal();
+        };
+        this.credentialAtomicQueryV3PrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
+            const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+            circuitClaimData.nonRevProof = (0, common_1.toClaimNonRevStatus)(preparedCredential.revStatus);
+            let proofType;
+            switch (proofReq.query.proofType) {
+                case verifiable_1.ProofType.BJJSignature:
+                    proofType = verifiable_1.ProofType.BJJSignature;
+                    break;
+                case verifiable_1.ProofType.Iden3SparseMerkleTreeProof:
+                    proofType = verifiable_1.ProofType.Iden3SparseMerkleTreeProof;
+                    break;
+                default:
+                    if (circuitClaimData.proof) {
+                        proofType = verifiable_1.ProofType.Iden3SparseMerkleTreeProof;
+                    }
+                    else if (circuitClaimData.signatureProof) {
+                        proofType = verifiable_1.ProofType.BJJSignature;
+                    }
+                    else {
+                        throw Error('claim has no MTP or signature proof');
+                    }
+                    break;
+            }
+            const circuitInputs = new circuits_1.AtomicQueryV3Inputs();
+            circuitInputs.id = js_iden3_core_1.DID.idFromDID(identifier);
+            circuitInputs.claim = {
+                issuerID: circuitClaimData?.issuerId,
+                signatureProof: circuitClaimData.signatureProof,
+                claim: circuitClaimData.claim,
+                nonRevProof: circuitClaimData.nonRevProof,
+                incProof: { proof: circuitClaimData.proof, treeState: circuitClaimData.treeState }
+            };
+            circuitInputs.requestID = BigInt(proofReq.id);
+            circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
+            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;
+            circuitInputs.query = query;
+            circuitInputs.currentTimeStamp = (0, js_iden3_core_1.getUnixTimestamp)(new Date());
+            circuitInputs.proofType = proofType;
+            circuitInputs.linkNonce = params.linkNonce ?? BigInt(0);
+            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.credentialAtomicQueryV3OnChainPrepareInputs = async ({ preparedCredential, identifier, proofReq, params, circuitQueries }) => {
+            const circuitClaimData = await this.newCircuitClaimData(preparedCredential);
+            circuitClaimData.nonRevProof = (0, common_1.toClaimNonRevStatus)(preparedCredential.revStatus);
+            let proofType;
+            switch (proofReq.query.proofType) {
+                case verifiable_1.ProofType.BJJSignature:
+                    proofType = verifiable_1.ProofType.BJJSignature;
+                    break;
+                case verifiable_1.ProofType.Iden3SparseMerkleTreeProof:
+                    proofType = verifiable_1.ProofType.Iden3SparseMerkleTreeProof;
+                    break;
+                default:
+                    if (circuitClaimData.proof) {
+                        proofType = verifiable_1.ProofType.Iden3SparseMerkleTreeProof;
+                    }
+                    else if (circuitClaimData.signatureProof) {
+                        proofType = verifiable_1.ProofType.BJJSignature;
+                    }
+                    else {
+                        throw Error('claim has no MTP or signature proof');
+                    }
+                    break;
+            }
+            const circuitInputs = new circuits_1.AtomicQueryV3OnChainInputs();
+            circuitInputs.id = js_iden3_core_1.DID.idFromDID(identifier);
+            circuitInputs.claim = {
+                issuerID: circuitClaimData?.issuerId,
+                signatureProof: circuitClaimData.signatureProof,
+                claim: circuitClaimData.claim,
+                nonRevProof: circuitClaimData.nonRevProof,
+                incProof: { proof: circuitClaimData.proof, treeState: circuitClaimData.treeState }
+            };
+            circuitInputs.requestID = BigInt(proofReq.id);
+            circuitInputs.claimSubjectProfileNonce = BigInt(params.credentialSubjectProfileNonce);
+            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;
+            circuitInputs.query = query;
+            circuitInputs.currentTimeStamp = (0, js_iden3_core_1.getUnixTimestamp)(new Date());
+            circuitInputs.proofType = proofType;
+            circuitInputs.linkNonce = params.linkNonce ?? BigInt(0);
+            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);
+            let isEthIdentity = true;
+            try {
+                js_iden3_core_1.Id.ethAddressFromId(circuitInputs.id);
+            }
+            catch {
+                isEthIdentity = false;
+            }
+            circuitInputs.authEnabled = isEthIdentity ? 0 : 1;
+            circuitInputs.challenge = BigInt(params.challenge ?? 0);
+            const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(identifier);
+            const id = js_iden3_core_1.DID.idFromDID(genesisDID);
+            const stateProof = await this._stateStorage.getGISTProof(id.bigInt());
+            const gistProof = (0, common_1.toGISTProof)(stateProof);
+            circuitInputs.gistProof = gistProof;
+            // auth inputs
+            if (circuitInputs.authEnabled === 1) {
+                const authPrepared = await this.prepareAuthBJJCredential(genesisDID);
+                const authClaimData = await this.newCircuitClaimData({
+                    credential: authPrepared.credential,
+                    credentialCoreClaim: authPrepared.coreClaim
+                });
+                const signature = await this._identityWallet.signChallenge(circuitInputs.challenge, authPrepared.credential);
+                circuitInputs.profileNonce = BigInt(authProfileNonce);
+                circuitInputs.authClaim = authClaimData.claim;
+                circuitInputs.authClaimIncMtp = authClaimData.proof;
+                circuitInputs.authClaimNonRevMtp = authPrepared.nonRevProof.proof;
+                circuitInputs.treeState = authClaimData.treeState;
+                circuitInputs.signature = signature;
+            }
+            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 }) => {
+            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();
+        };
+    }
+    async generateInputs(ctx) {
+        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`);
+        }
+        const fn = this[fnName];
+        if (!fn) {
+            throw new Error(`inputs generator for ${circuitId} not found`);
+        }
+        return fn(ctx);
+    }
+    async newCircuitClaimData(preparedCredential) {
+        const smtProof = preparedCredential.credential.getIden3SparseMerkleTreeProof();
+        const circuitClaim = new circuits_1.CircuitClaim();
+        circuitClaim.claim = preparedCredential.credentialCoreClaim;
+        circuitClaim.issuerId = js_iden3_core_1.DID.idFromDID(js_iden3_core_1.DID.parse(preparedCredential.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
+            };
+        }
+        const sigProof = preparedCredential.credential.getBJJSignature2021Proof();
+        if (sigProof) {
+            const issuerDID = sigProof.issuerData.id;
+            const userDID = (0, credentials_1.getUserDIDFromCredential)(issuerDID, preparedCredential.credential);
+            const { credentialStatus, mtp, authCoreClaim } = sigProof.issuerData;
+            if (!credentialStatus) {
+                throw new Error("can't check the validity of issuer auth claim: no credential status in proof");
+            }
+            if (!mtp) {
+                throw new Error('issuer auth credential must have a mtp proof');
+            }
+            if (!authCoreClaim) {
+                throw new Error('issuer auth credential must have a core claim proof');
+            }
+            const opts = {
+                issuerGenesisState: sigProof.issuerData.state,
+                issuerDID,
+                userDID
+            };
+            const rs = await this._credentialWallet.getRevocationStatus(credentialStatus, opts);
+            const issuerAuthNonRevProof = (0, common_1.toClaimNonRevStatus)(rs);
+            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
+            };
+        }
+        return circuitClaim;
+    }
+    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(verifiable_1.ProofType.Iden3SparseMerkleTreeProof);
+        if (!authCoreClaim) {
+            throw new Error('auth core claim is not defined for auth bjj credential');
+        }
+        return {
+            credential: authCredential,
+            incProof,
+            nonRevProof,
+            coreClaim: authCoreClaim
+        };
+    }
+}
+exports.InputGenerator = InputGenerator;