@0xpolygonid/js-sdk 1.5.0 → 1.6.0

package/dist/node/esm/circuits/index.js

@@ -4,6 +4,10 @@ export * from './comparer';
 export * from './atomic-query-mtp-v2';
 export * from './atomic-query-mtp-v2-on-chain';
 export * from './atomic-query-sig-v2';
+export * from './atomic-query-v3';
+export * from './atomic-query-v3-on-chain';
 export * from './atomic-query-sig-v2-on-chain';
 export * from './auth-v2';
 export * from './state-transition';
+export * from './linked-nullifier';
+export * from './linked-multi-query';

package/dist/node/esm/circuits/linked-multi-query.js

@@ -0,0 +1,123 @@
+import { byteDecoder, byteEncoder } from '../utils';
+import { BaseConfig, bigIntArrayToStringArray, existenceToInt, getNodeAuxValue, prepareCircuitArrayValues, prepareSiblingsStr } from './common';
+/**
+ * LinkedMultiQuery circuit representation
+ * Inputs and public signals declaration, marshalling and parsing
+ *
+ * @beta
+ * @class LinkedMultiQueryInputs
+ */
+export class LinkedMultiQueryInputs extends BaseConfig {
+    // InputsMarshal returns Circom private inputs for linkedMultiQueryInputs.circom
+    inputsMarshal() {
+        const enabled = [];
+        const claimPathNotExists = [];
+        const claimPathMtp = [];
+        const claimPathMtpNoAux = [];
+        const claimPathMtpAuxHi = [];
+        const claimPathMtpAuxHv = [];
+        const claimPathKey = [];
+        const claimPathValue = [];
+        const slotIndex = [];
+        const operator = [];
+        const value = [];
+        for (let i = 0; i < this.queryLength; i++) {
+            if (!this.query) {
+                enabled.push(0);
+                claimPathNotExists.push(0);
+                claimPathMtp.push([]);
+                claimPathMtpNoAux.push('0');
+                claimPathMtpAuxHi.push('0');
+                claimPathMtpAuxHv.push('0');
+                claimPathKey.push('0');
+                claimPathValue.push('0');
+                slotIndex.push(0);
+                operator.push(0);
+                const valuesArr = prepareCircuitArrayValues([], this.getValueArrSize());
+                value.push(bigIntArrayToStringArray(valuesArr));
+                continue;
+            }
+            enabled.push(1);
+            const valueProof = this.query[i].valueProof;
+            claimPathNotExists.push(existenceToInt(valueProof.mtp.existence));
+            claimPathMtp.push(prepareSiblingsStr(valueProof.mtp, this.getMTLevelsClaim()));
+            const nodAuxJSONLD = getNodeAuxValue(valueProof.mtp);
+            claimPathMtpNoAux.push(nodAuxJSONLD.noAux);
+            claimPathMtpAuxHi.push(nodAuxJSONLD.key.bigInt().toString());
+            claimPathMtpAuxHv.push(nodAuxJSONLD.value.bigInt().toString());
+            claimPathKey.push(valueProof.path.toString());
+            claimPathValue.push(valueProof.value.toString());
+            slotIndex.push(this.query[i].slotIndex);
+            operator.push(this.query[i].operator);
+            const valuesArr = prepareCircuitArrayValues(this.query[i].values, this.getValueArrSize());
+            value.push(bigIntArrayToStringArray(valuesArr));
+        }
+        const s = {
+            linkNonce: this.linkNonce.toString(),
+            issuerClaim: this.claim.marshalJson(),
+            enabled,
+            claimSchema: this.claim.getSchemaHash().bigInt().toString(),
+            claimPathNotExists,
+            claimPathMtp,
+            claimPathMtpNoAux,
+            claimPathMtpAuxHi,
+            claimPathMtpAuxHv,
+            claimPathKey,
+            claimPathValue,
+            slotIndex,
+            operator,
+            value
+        };
+        return byteEncoder.encode(JSON.stringify(s));
+    }
+}
+// LinkedMultiQueryPubSignals linkedMultiQuery.circom public signals
+/**
+ * public signals
+ *
+ * @beta
+ * @class LinkedMultiQueryPubSignals
+ */
+export class LinkedMultiQueryPubSignals {
+    /**
+     * PubSignalsUnmarshal unmarshal linkedMultiQuery.circom public inputs to LinkedMultiQueryPubSignals
+     *
+     * @beta
+     * @param {Uint8Array} data
+     * @returns LinkedMultiQueryPubSignals
+     */
+    pubSignalsUnmarshal(data, queryLength) {
+        const len = queryLength * 3 + 2;
+        const sVals = JSON.parse(byteDecoder.decode(data));
+        if (sVals.length !== len) {
+            throw new Error(`invalid number of Output values expected ${len} got ${sVals.length}`);
+        }
+        let fieldIdx = 0;
+        // -- linkID
+        this.linkID = BigInt(sVals[fieldIdx]);
+        fieldIdx++;
+        // -- merklized
+        this.merklized = parseInt(sVals[fieldIdx]);
+        fieldIdx++;
+        // - operatorOutput
+        this.operatorOutput = [];
+        for (let i = 0; i < queryLength; i++) {
+            this.operatorOutput.push(BigInt(sVals[fieldIdx]));
+            fieldIdx++;
+        }
+        // - circuitQueryHash
+        this.circuitQueryHash = [];
+        for (let i = 0; i < queryLength; i++) {
+            this.circuitQueryHash.push(BigInt(sVals[fieldIdx]));
+            fieldIdx++;
+        }
+        // - enabled
+        this.enabled = [];
+        for (let i = 0; i < queryLength; i++) {
+            const enabledNum = parseInt(sVals[fieldIdx]);
+            this.enabled.push(enabledNum === 1);
+            fieldIdx++;
+        }
+        return this;
+    }
+}

package/dist/node/esm/circuits/linked-nullifier.js

@@ -0,0 +1,52 @@
+import { Id } from '@iden3/js-iden3-core';
+import { byteDecoder, byteEncoder } from '../utils';
+/**
+ * LinkedNullifier circuit representation
+ * Inputs and public signals declaration, marshalling and parsing
+ *
+ * @beta
+ * @class LinkedNullifierInputs
+ */
+export class LinkedNullifierInputs {
+    // InputsMarshal returns Circom private inputs for nullifier.circom
+    inputsMarshal() {
+        const s = {
+            linkNonce: this.linkNonce.toString(),
+            issuerClaim: this.issuerClaim.marshalJson(),
+            userGenesisID: this.id.bigInt().toString(),
+            claimSubjectProfileNonce: this.claimSubjectProfileNonce.toString(),
+            claimSchema: this.issuerClaim.getSchemaHash().bigInt().toString(),
+            verifierID: this.verifierID?.bigInt().toString() ?? '0',
+            nullifierSessionID: this.nullifierSessionID.toString()
+        };
+        return byteEncoder.encode(JSON.stringify(s));
+    }
+}
+// LinkedNullifierPubSignals nullifier.circom public signals
+/**
+ * public signals
+ *
+ * @beta
+ * @class LinkedNullifierPubSignals
+ */
+export class LinkedNullifierPubSignals {
+    /**
+     * PubSignalsUnmarshal unmarshal nullifier.circom public inputs to LinkedNullifierPubSignals
+     *
+     * @beta
+     * @param {Uint8Array} data
+     * @returns LinkedNullifierPubSignals
+     */
+    pubSignalsUnmarshal(data) {
+        const len = 4;
+        const sVals = JSON.parse(byteDecoder.decode(data));
+        if (sVals.length !== len) {
+            throw new Error(`invalid number of Output values expected ${len} got ${sVals.length}`);
+        }
+        this.nullifier = BigInt(sVals[0]);
+        this.linkID = BigInt(sVals[1]);
+        this.verifierID = Id.fromBigInt(BigInt(sVals[2]));
+        this.nullifierSessionID = BigInt(sVals[3]);
+        return this;
+    }
+}

package/dist/node/esm/circuits/models.js

@@ -12,7 +12,9 @@ export class Query {
      *
      */
     validate() {
-        if (this.operator !== QueryOperators.$noop && this.values?.some((v) => typeof v !== 'bigint'))
+        if (this.operator !== QueryOperators.$noop &&
+            this.operator !== QueryOperators.$sd &&
+            this.values?.some((v) => typeof v !== 'bigint'))
             throw new Error(CircuitError.EmptyQueryValue);
     }
 }
@@ -35,6 +37,26 @@ export var CircuitId;
     CircuitId["AtomicQuerySigV2"] = "credentialAtomicQuerySigV2";
     // AtomicQuerySigOnChain is a type for credentialAtomicQuerySigOnChain.circom
     CircuitId["AtomicQuerySigV2OnChain"] = "credentialAtomicQuerySigV2OnChain";
+    /**
+     * @beta
+     */
+    // AtomicQueryV3CircuitID is a type for credentialAtomicQueryV3.circom
+    CircuitId["AtomicQueryV3"] = "credentialAtomicQueryV3-beta.0";
+    /**
+     * @beta
+     */
+    // AtomicQueryV3OnChainCircuitID is a type for credentialAtomicQueryV3OnChain.circom
+    CircuitId["AtomicQueryV3OnChain"] = "credentialAtomicQueryV3OnChain-beta.0";
+    /**
+     * @beta
+     */
+    // LinkedNullifier is a type for linkedNullifier.circom
+    CircuitId["LinkedNullifier"] = "linkedNullifier-beta.0";
+    /**
+     * @beta
+     */
+    // LinkedMultiQuery is a type for linkedMultiQuery.circom
+    CircuitId["LinkedMultiQuery10"] = "linkedMultiQuery10-beta.0";
 })(CircuitId || (CircuitId = {}));
 /**
  * Claim structure for circuit inputs
@@ -68,7 +90,9 @@ export var CircuitError;
     CircuitError["EmptyId"] = "empty Id";
     CircuitError["EmptyChallenge"] = "empty challenge";
     CircuitError["EmptyGISTProof"] = "empty GIST merkle tree proof";
+    CircuitError["EmptyTreeState"] = "empty tree state";
     CircuitError["EmptyRequestID"] = "empty request ID";
+    CircuitError["InvalidProofType"] = "invalid proof type";
 })(CircuitError || (CircuitError = {}));
 /**
  * ValueProof represents a Merkle Proof for a value stored as MT

package/dist/node/esm/credentials/credential-wallet.js

@@ -4,6 +4,7 @@ import * as uuid from 'uuid';
 import { CredentialStatusResolverRegistry } from './status/resolver';
 import { IssuerResolver } from './status/sparse-merkle-tree';
 import { AgentResolver } from './status/agent-revocation';
+import { getUserDIDFromCredential } from './utils';
 // ErrAllClaimsRevoked all claims are revoked.
 const ErrAllClaimsRevoked = 'all claims are revoked';
 /**
@@ -99,16 +100,7 @@ export class CredentialWallet {
             ? mtpProof.issuerData.state
             : sigProof?.issuerData.state;
         const issuerDID = DID.parse(cred.issuer);
-        let userDID;
-        if (!cred.credentialSubject.id) {
-            userDID = issuerDID;
-        }
-        else {
-            if (typeof cred.credentialSubject.id !== 'string') {
-                throw new Error('credential status `id` is not a string');
-            }
-            userDID = DID.parse(cred.credentialSubject.id);
-        }
+        const userDID = getUserDIDFromCredential(issuerDID, cred);
         const opts = {
             issuerGenesisState: stateInfo,
             issuerDID,

package/dist/node/esm/credentials/index.js

@@ -6,3 +6,4 @@ export * from './status/agent-revocation';
 export * from './status/utils';
 export * from './credential-wallet';
 export * from './rhs';
+export * from './utils';

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

@@ -0,0 +1,19 @@
+import { DID } from '@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.
+ */
+export 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 DID.parse(credential.credentialSubject.id);
+};

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

@@ -3,7 +3,8 @@ import { PROTOCOL_MESSAGE_TYPE } from '../constants';
 import { DID } from '@iden3/js-iden3-core';
 import { proving } from '@iden3/js-jwz';
 import * as uuid from 'uuid';
-import { byteDecoder, byteEncoder } from '../../utils';
+import { byteDecoder, byteEncoder, mergeObjects } from '../../utils';
+import { getRandomBytes } from '@iden3/js-crypto';
 /**
  *
  * Allows to process AuthorizationRequest protocol message and produce JWZ response.
@@ -79,15 +80,55 @@ export 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 = getRandomBytes(12);
+                const dataView = new DataView(seed.buffer);
+                const linkNonce = dataView.getUint32(0);
+                acc.set(groupId, { query: proofReq.query, linkNonce });
+                return acc;
+            }
+            const credentialSubject = 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/esm/iden3comm/handlers/contract-request.js

@@ -1,5 +1,7 @@
 import { CircuitId } from '../../circuits/models';
 import { PROTOCOL_MESSAGE_TYPE } from '../constants';
+import { DID, ChainIds, DidMethod } from '@iden3/js-iden3-core';
+import { buildVerifierId } from '../../utils';
 /**
  *
  * Allows to process ContractInvokeRequest protocol message
@@ -23,7 +25,8 @@ export class ContractRequestHandler {
         this._zkpVerifier = _zkpVerifier;
         this._allowedCircuits = [
             CircuitId.AtomicQueryMTPV2OnChain,
-            CircuitId.AtomicQuerySigV2OnChain
+            CircuitId.AtomicQuerySigV2OnChain,
+            CircuitId.AtomicQueryV3OnChain
         ];
     }
     /**
@@ -57,19 +60,28 @@ export 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(ChainIds).find((key) => ChainIds[key] === chain_id);
+        if (!networkFlag) {
+            throw new Error(`Invalid chain id ${chain_id}`);
+        }
+        const [blockchain, networkId] = networkFlag.split(':');
+        const verifierId = 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: DidMethod.Iden3
+        });
+        const verifierDid = 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/esm/proof/common.js

@@ -1,5 +1,10 @@
-import { Hash, Proof } from '@iden3/js-merkletree';
-import { buildTreeState } from '../circuits';
+import { Hash, Proof, ZERO_HASH } from '@iden3/js-merkletree';
+import { buildTreeState, isValidOperation, QueryOperators } from '../circuits';
+import { buildFieldPath } from '../verifiable';
+import { Merklizer, Path } from '@iden3/js-jsonld-merklization';
+import { Parser } from '../schema-processor/json';
+import { byteEncoder } from '../utils';
+import { poseidon } from '@iden3/js-crypto';
 /**
  * converts verifiable RevocationStatus model to circuits structure
  *
@@ -7,6 +12,18 @@ import { buildTreeState } from '../circuits';
  * @returns {ClaimNonRevStatus}
  */
 export const toClaimNonRevStatus = (s) => {
+    if (!s) {
+        const hash = poseidon.hash(new Array(3).fill(0n));
+        return {
+            proof: new Proof(),
+            treeState: {
+                state: Hash.fromBigInt(hash),
+                claimsRoot: ZERO_HASH,
+                revocationRoot: ZERO_HASH,
+                rootOfRoots: ZERO_HASH
+            }
+        };
+    }
     return {
         proof: s.mtp,
         treeState: buildTreeState(s.issuer.state, s.issuer.claimsTreeRoot, s.issuer.revocationTreeRoot, s.issuer.rootOfRoots)
@@ -40,3 +57,85 @@ export const toGISTProof = (smtProof) => {
         proof
     };
 };
+export const parseCredentialSubject = (credentialSubject) => {
+    // credentialSubject is empty
+    if (!credentialSubject) {
+        return [{ operator: 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: QueryOperators.$sd, fieldName: fieldName });
+            continue;
+        }
+        for (const [operatorName, operatorValue] of fieldReqEntries) {
+            if (!QueryOperators[operatorName]) {
+                throw new Error(`operator is not supported by lib`);
+            }
+            const operator = QueryOperators[operatorName];
+            queries.push({ operator, fieldName, operatorValue });
+        }
+    }
+    return queries;
+};
+export const parseQueryMetadata = async (propertyQuery, ldContextJSON, credentialType, options) => {
+    const datatype = await Path.newTypeFromContext(ldContextJSON, `${credentialType}.${propertyQuery.fieldName}`, options);
+    const query = {
+        ...propertyQuery,
+        slotIndex: 0,
+        merklizedSchema: false,
+        datatype: datatype,
+        claimPathKey: BigInt(0),
+        values: [],
+        path: new Path()
+    };
+    const serAttr = await 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 Parser.getFieldSlotIndex(propertyQuery.fieldName, credentialType, byteEncoder.encode(ldContextJSON));
+    }
+    else {
+        try {
+            const path = await 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 (!isValidOperation(datatype, propertyQuery.operator)) {
+            throw new Error(`operator ${propertyQuery.operator} is not supported for datatype ${datatype}`);
+        }
+        query.values = await transformQueryValueToBigInts(propertyQuery.operatorValue, datatype);
+    }
+    return query;
+};
+export const parseQueriesMetadata = async (credentialType, ldContextJSON, credentialSubject, options) => {
+    const queriesMetadata = parseCredentialSubject(credentialSubject);
+    return Promise.all(queriesMetadata.map((m) => parseQueryMetadata(m, ldContextJSON, credentialType, options)));
+};
+export 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 Merklizer.hashValue(ldType, value[index]);
+        }
+    }
+    else {
+        values[0] = await Merklizer.hashValue(ldType, value);
+    }
+    return values;
+};