@0xpolygonid/js-sdk 1.30.0 → 1.31.1

package/dist/browser/umd/index.js

@@ -11388,7 +11388,26 @@ var PolygonIdSdk = (function (exports) {
             CONTEXT_TYPE_IS_EMPTY: 'ctxType is empty',
             // ErrStateNotFound issuer state is genesis state.
             IDENTITY_DOES_NOT_EXIST: 'Identity does not exist',
-            NO_AUTH_CRED_FOUND: 'no auth credentials found'
+            NO_AUTH_CRED_FOUND: 'no auth credentials found',
+            // identity wallet
+            ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY: 'no credential satisfied query',
+            ID_WALLET_SIGNER_IS_REQUIRED: 'Ethereum signer is required to create Ethereum identities in order to transit state',
+            ID_WALLET_PROVER_IS_REQUIRED: 'prover is required to generate proofs for non ethereum identities',
+            ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF: 'credential must have coreClaim representation in the signature proof',
+            ID_WALLET_CORE_CLAIM_REQUIRED_IN_ANY_PROOF: 'credential must have coreClaim representation in proofs',
+            ID_WALLET_CORE_CLAIM_MISMATCH: 'core claim representations is set in both proofs but they are not equal',
+            ID_WALLET_CORE_CLAIM_IS_NOT_SET: 'core claim is not set in credential proofs',
+            ID_WALLET_PROFILE_OR_IDENTITY_NOT_FOUND: 'profile or identity not found',
+            ID_WALLET_PROFILE_ALREADY_EXISTS: 'profile with given nonce or verifier already exists',
+            ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_ANY_PROOF: 'issuer auth credential must have proof',
+            ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_MTP_PROOF: 'mtp is required for auth bjj key to issue new credentials',
+            // proof service
+            PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE: 'no credentials belong to did or its profiles',
+            PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY: 'credential not found for query',
+            PROOF_SERVICE_PROFILE_GENESIS_DID_MISMATCH: 'subject and auth profiles are not derived from the same did',
+            PROOF_SERVICE_NO_QUERIES_IN_ZKP_REQUEST: 'no queries in zkp request',
+            // credential wallet
+            CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED: 'all claims are revoked'
         },
         CREDENTIAL_TYPE: {
             // VerifiableCredential is a W3C verifiable credential type
@@ -37772,12 +37791,12 @@ var PolygonIdSdk = (function (exports) {
         }
         const skeleton = {
             '@context': baseContext,
-            '@type': VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_PRESENTATION,
+            type: VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_PRESENTATION,
             verifiableCredential: {
                 '@context': ldContext,
-                '@type': vcTypes,
+                type: vcTypes,
                 credentialSubject: {
-                    '@type': tp
+                    type: tp
                 }
             }
         };
@@ -48209,6 +48228,7 @@ var PolygonIdSdk = (function (exports) {
             validator = ajv ?? defaultJSONSchemaValidator;
             if (validator.formats && !Object.keys(validator.formats).length) {
                 addFormats(validator);
+                addCustomFormats(validator);
             }
             const validate = (schema.$id ? validator.getSchema(schema.$id) : undefined) || validator.compile(schema);
             const valid = validate(data);
@@ -48219,6 +48239,16 @@ var PolygonIdSdk = (function (exports) {
             return true;
         }
     }
+    function addCustomFormats(validator) {
+        validator.addFormat('positive-integer', {
+            type: 'string',
+            validate: (positiveIntegerStr) => /^[1-9]\d*$/.test(positiveIntegerStr)
+        });
+        validator.addFormat('non-negative-integer', {
+            type: 'string',
+            validate: (nonNegativeIntegerStr) => /^(0|[1-9]\d*)$/.test(nonNegativeIntegerStr)
+        });
+    }
 
     /* eslint-disable @typescript-eslint/no-var-requires */
     /**
@@ -57574,6 +57604,82 @@ var PolygonIdSdk = (function (exports) {
         }))) + "00";
     }
 
+    const regexBytes = new RegExp("^bytes([0-9]+)$");
+    const regexNumber = new RegExp("^(u?int)([0-9]*)$");
+    const regexArray = new RegExp("^(.*)\\[([0-9]*)\\]$");
+    function _pack(type, value, isArray) {
+        switch (type) {
+            case "address":
+                if (isArray) {
+                    return getBytes(zeroPadValue(value, 32));
+                }
+                return getBytes(getAddress(value));
+            case "string":
+                return toUtf8Bytes(value);
+            case "bytes":
+                return getBytes(value);
+            case "bool":
+                value = (!!value ? "0x01" : "0x00");
+                if (isArray) {
+                    return getBytes(zeroPadValue(value, 32));
+                }
+                return getBytes(value);
+        }
+        let match = type.match(regexNumber);
+        if (match) {
+            let signed = (match[1] === "int");
+            let size = parseInt(match[2] || "256");
+            assertArgument((!match[2] || match[2] === String(size)) && (size % 8 === 0) && size !== 0 && size <= 256, "invalid number type", "type", type);
+            if (isArray) {
+                size = 256;
+            }
+            if (signed) {
+                value = toTwos(value, size);
+            }
+            return getBytes(zeroPadValue(toBeArray(value), size / 8));
+        }
+        match = type.match(regexBytes);
+        if (match) {
+            const size = parseInt(match[1]);
+            assertArgument(String(size) === match[1] && size !== 0 && size <= 32, "invalid bytes type", "type", type);
+            assertArgument(dataLength(value) === size, `invalid value for ${type}`, "value", value);
+            if (isArray) {
+                return getBytes(zeroPadBytes(value, 32));
+            }
+            return value;
+        }
+        match = type.match(regexArray);
+        if (match && Array.isArray(value)) {
+            const baseType = match[1];
+            const count = parseInt(match[2] || String(value.length));
+            assertArgument(count === value.length, `invalid array length for ${type}`, "value", value);
+            const result = [];
+            value.forEach(function (value) {
+                result.push(_pack(baseType, value, true));
+            });
+            return getBytes(concat(result));
+        }
+        assertArgument(false, "invalid type", "type", type);
+    }
+    // @TODO: Array Enum
+    /**
+     *   Computes the [[link-solc-packed]] representation of %%values%%
+     *   respectively to their %%types%%.
+     *
+     *   @example:
+     *       addr = "0x8ba1f109551bd432803012645ac136ddd64dba72"
+     *       solidityPacked([ "address", "uint" ], [ addr, 45 ]);
+     *       //_result:
+     */
+    function solidityPacked(types, values) {
+        assertArgument(types.length === values.length, "wrong number of values; expected ${ types.length }", "values", values);
+        const tight = [];
+        types.forEach(function (type, index) {
+            tight.push(_pack(type, values[index]));
+        });
+        return hexlify(concat(tight));
+    }
+
     //import { TypedDataDomain, TypedDataField } from "@ethersproject/providerabstract-signer";
     const padding = new Uint8Array(32);
     padding.fill(0);
@@ -92676,34 +92782,60 @@ var PolygonIdSdk = (function (exports) {
         const groupedCredentialsCache = new Map();
         const zkpResponses = [];
         for (const proofReq of requestScope) {
-            if (!opts.supportedCircuits.includes(proofReq.circuitId)) {
-                throw new Error(`Circuit ${proofReq.circuitId} is not allowed`);
-            }
-            const query = proofReq.query;
-            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 proofService.findCredentialByProofQuery(to, combinedQueryData.query);
-                    if (!credWithRevStatus.cred) {
-                        throw new Error(`Credential not found for query ${JSON.stringify(combinedQuery)}`);
+            let zkpRes;
+            try {
+                const isCircuitSupported = opts.supportedCircuits.includes(proofReq.circuitId);
+                if (!isCircuitSupported) {
+                    if (proofReq.optional) {
+                        continue;
                     }
-                    groupedCredentialsCache.set(groupId, credWithRevStatus);
+                    throw new Error(`Circuit ${proofReq.circuitId} is not allowed`);
                 }
+                const query = proofReq.query;
+                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 proofService.findCredentialByProofQuery(to, combinedQueryData.query);
+                        if (!credWithRevStatus.cred) {
+                            if (proofReq.optional) {
+                                continue;
+                            }
+                            throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY +
+                                `${JSON.stringify(combinedQuery)}`);
+                        }
+                        groupedCredentialsCache.set(groupId, credWithRevStatus);
+                    }
+                }
+                const credWithRevStatus = groupedCredentialsCache.get(groupId);
+                zkpRes = await proofService.generateProof(proofReq, to, {
+                    verifierDid: from,
+                    challenge: opts.challenge,
+                    skipRevocation: Boolean(query.skipClaimRevocationCheck),
+                    credential: credWithRevStatus?.cred,
+                    credentialRevocationStatus: credWithRevStatus?.revStatus,
+                    linkNonce: combinedQueryData?.linkNonce ? BigInt(combinedQueryData.linkNonce) : undefined
+                });
+            }
+            catch (error) {
+                const expectedErrors = [
+                    VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE,
+                    VerifiableConstants.ERRORS.ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY,
+                    VerifiableConstants.ERRORS.CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED
+                ];
+                // handle only errors in case credential is not found and it is optional proof request - otherwise throw
+                if (error instanceof Error &&
+                    (expectedErrors.includes(error.message) ||
+                        error.message.includes(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY)) &&
+                    proofReq.optional) {
+                    continue;
+                }
+                throw error;
             }
-            const credWithRevStatus = groupedCredentialsCache.get(groupId);
-            const zkpRes = await proofService.generateProof(proofReq, to, {
-                verifierDid: from,
-                challenge: opts.challenge,
-                skipRevocation: Boolean(query.skipClaimRevocationCheck),
-                credential: credWithRevStatus?.cred,
-                credentialRevocationStatus: credWithRevStatus?.revStatus,
-                linkNonce: combinedQueryData?.linkNonce ? BigInt(combinedQueryData.linkNonce) : undefined
-            });
             zkpResponses.push(zkpRes);
         }
         return zkpResponses;
@@ -94371,7 +94503,7 @@ var PolygonIdSdk = (function (exports) {
                 }
                 return { cred, revStatus };
             }
-            throw new Error('all claims are revoked');
+            throw new Error(VerifiableConstants.ERRORS.CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED);
         }
     }
 
@@ -102524,6 +102656,26 @@ var PolygonIdSdk = (function (exports) {
         }
         return await value.mtEntry();
     };
+    function calculateGroupId(requestIds) {
+        const types = Array(requestIds.length).fill('uint256');
+        const groupID = BigInt(keccak256(solidityPacked(types, requestIds))) &
+            // It should fit in a field number in the circuit (max 253 bits). With this we truncate to 252 bits for the group ID
+            BigInt('0x0FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF');
+        return groupID;
+    }
+    function calculateRequestId(requestParams, creatorAddress) {
+        // 0x0000000000000000FFFF...FF. Reserved first 8 bytes for the request Id type and future use
+        // 0x00010000000000000000...00. First 2 bytes for the request Id type
+        //    - 0x0000... for old request Ids with uint64
+        //    - 0x0001... for new request Ids with uint256
+        const requestId = (BigInt(keccak256(solidityPacked(['bytes', 'address'], [requestParams, creatorAddress]))) &
+            BigInt('0x0000000000000000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF')) +
+            BigInt('0x0001000000000000000000000000000000000000000000000000000000000000');
+        return requestId;
+    }
+    function calculateMultiRequestId(requestIds, groupIds, creatorAddress) {
+        return BigInt(keccak256(solidityPacked(['uint256[]', 'uint256[]', 'address'], [requestIds, groupIds, creatorAddress])));
+    }
 
     function calculateQueryHashV2(values, schema, slotIndex, operator, claimPathKey, claimPathNotExists) {
         const expValue = prepareCircuitArrayValues(values, 64);
@@ -103057,7 +103209,8 @@ var PolygonIdSdk = (function (exports) {
                 credentialWithRevStatus = { cred: opts.credential, revStatus };
             }
             if (!credentialWithRevStatus.cred) {
-                throw new Error(`credential not found for query ${JSON.stringify(proofReq.query)}`);
+                throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_QUERY +
+                    ` ${JSON.stringify(proofReq.query)}`);
             }
             const credentialCoreClaim = await this._identityWallet.getCoreClaimFromCredential(credentialWithRevStatus.cred);
             const { nonce: authProfileNonce, genesisDID } = await this._identityWallet.getGenesisDIDMetadata(identifier);
@@ -103069,11 +103222,11 @@ var PolygonIdSdk = (function (exports) {
             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');
+                throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_PROFILE_GENESIS_DID_MISMATCH);
             }
             const propertiesMetadata = parseCredentialSubject(proofReq.query.credentialSubject);
             if (!propertiesMetadata.length) {
-                throw new Error('no queries in zkp request');
+                throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_QUERIES_IN_ZKP_REQUEST);
             }
             const mtPosition = preparedCredential.credentialCoreClaim.getMerklizedPosition();
             let mk;
@@ -103257,7 +103410,7 @@ var PolygonIdSdk = (function (exports) {
         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`);
+                throw new Error(VerifiableConstants.ERRORS.PROOF_SERVICE_NO_CREDENTIAL_FOR_IDENTITY_OR_PROFILE);
             }
             //  For EQ / IN / NIN / LT / GT operations selective if credential satisfies query - we can get any.
             // TODO: choose credential for selective credentials
@@ -103456,7 +103609,7 @@ var PolygonIdSdk = (function (exports) {
             let credential;
             const ethSigner = opts.ethSigner;
             if (opts.createBjjCredential && !ethSigner) {
-                throw new Error('Ethereum signer is required to create Ethereum identities in order to transit state');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_SIGNER_IS_REQUIRED);
             }
             const currentState = ZERO_HASH; // In Ethereum identities we don't have an initial state with the auth credential
             const didType = buildDIDType(opts.method || DidMethod.Iden3, opts.blockchain || Blockchain.Polygon, opts.networkId || NetworkId.Amoy);
@@ -103494,7 +103647,7 @@ var PolygonIdSdk = (function (exports) {
             }
             const profile = await this._storage.identity.getProfileById(did.string());
             if (!profile) {
-                throw new Error('profile or identity not found');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROFILE_OR_IDENTITY_NOT_FOUND);
             }
             return { nonce: profile.nonce, genesisDID: DID.parse(profile.genesisIdentifier) };
         }
@@ -103504,7 +103657,7 @@ var PolygonIdSdk = (function (exports) {
             const identityProfiles = await this._storage.identity.getProfilesByGenesisIdentifier(did.string());
             const existingProfile = identityProfiles.find((p) => p.nonce == nonce || p.verifier == verifier);
             if (existingProfile) {
-                throw new Error('profile with given nonce or verifier already exists');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROFILE_ALREADY_EXISTS);
             }
             await this._storage.identity.saveProfile({
                 id: profileDID.string(),
@@ -103653,11 +103806,11 @@ var PolygonIdSdk = (function (exports) {
             const coreClaimHash = z$2.hash([hi, hv]);
             const signature = await this.signChallenge(coreClaimHash, issuerAuthBJJCredential);
             if (!issuerAuthBJJCredential.proof) {
-                throw new Error('issuer auth credential must have proof');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_ANY_PROOF);
             }
             const mtpAuthBJJProof = issuerAuthBJJCredential.getIden3SparseMerkleTreeProof();
             if (!mtpAuthBJJProof) {
-                throw new Error('mtp is required for auth bjj key to issue new credentials');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_ISSUER_AUTH_BJJ_CRED_MUST_HAVE_MTP_PROOF);
             }
             const sigProof = new BJJSignatureProof2021({
                 issuerData: {
@@ -103697,7 +103850,7 @@ var PolygonIdSdk = (function (exports) {
             const issuerTree = await this.getDIDTreeModel(issuerDID);
             const coreClaim = await this.getCoreClaimFromCredential(credential);
             if (!coreClaim) {
-                throw new Error('credential must have coreClaim representation in proofs');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_ANY_PROOF);
             }
             const nonce = coreClaim.getRevocationNonce();
             await issuerTree.revocationTree.add(nonce, BigInt(0));
@@ -103720,7 +103873,7 @@ var PolygonIdSdk = (function (exports) {
                 // credential must have a bjj signature proof
                 const coreClaim = credential.getCoreClaimFromProof(exports.ProofType.BJJSignature);
                 if (!coreClaim) {
-                    throw new Error('credential must have coreClaim representation in the signature proof');
+                    throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF);
                 }
                 await this._storage.mt.addToMerkleTree(issuerDID.string(), exports.MerkleTreeType.Claims, coreClaim.hIndex(), coreClaim.hValue());
             }
@@ -103752,7 +103905,7 @@ var PolygonIdSdk = (function (exports) {
                 const coreClaim = credential.getCoreClaimFromProof(exports.ProofType.BJJSignature) ||
                     (await credential.toCoreClaim(opts));
                 if (!coreClaim) {
-                    throw new Error('credential must have coreClaim representation in the signature proof');
+                    throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_REQUIRED_IN_SIG_PROOF);
                 }
                 const mtpWithProof = await this.generateCoreClaimMtp(issuerDID, coreClaim, treeState);
                 const mtpProof = new Iden3SparseMerkleTreeProof({
@@ -103820,10 +103973,10 @@ var PolygonIdSdk = (function (exports) {
             if (coreClaimFromMtpProof &&
                 coreClaimFromSigProof &&
                 coreClaimFromMtpProof.hex() !== coreClaimFromSigProof.hex()) {
-                throw new Error('core claim representations is set in both proofs but they are not equal');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_MISMATCH);
             }
             if (!coreClaimFromMtpProof && !coreClaimFromSigProof) {
-                throw new Error('core claim is not set in credential proofs');
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_CORE_CLAIM_IS_NOT_SET);
             }
             //eslint-disable-next-line  @typescript-eslint/no-non-null-assertion
             const coreClaim = coreClaimFromMtpProof ?? coreClaimFromSigProof;
@@ -103832,7 +103985,7 @@ var PolygonIdSdk = (function (exports) {
         async findOwnedCredentialsByDID(did, query) {
             const credentials = await this._credentialWallet.findByQuery(query);
             if (!credentials.length) {
-                throw new Error(`no credential satisfied query`);
+                throw new Error(VerifiableConstants.ERRORS.ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY);
             }
             const { genesisDID } = await this.getGenesisDIDMetadata(did);
             const profiles = await this.getProfilesByDID(genesisDID);
@@ -103872,7 +104025,7 @@ var PolygonIdSdk = (function (exports) {
             let txId;
             if (!isEthIdentity) {
                 if (!prover) {
-                    throw new Error('prover is required to generate proofs for non ethereum identities');
+                    throw new Error(VerifiableConstants.ERRORS.ID_WALLET_PROVER_IS_REQUIRED);
                 }
                 // generate the proof
                 const authInfo = await this._inputsGenerator.prepareAuthBJJCredential(did, oldTreeState);
@@ -104113,8 +104266,11 @@ var PolygonIdSdk = (function (exports) {
     exports.cacheLoader = cacheLoader;
     exports.calcChallengeAuthV2 = calcChallengeAuthV2;
     exports.calculateCoreSchemaHash = calculateCoreSchemaHash;
+    exports.calculateGroupId = calculateGroupId;
+    exports.calculateMultiRequestId = calculateMultiRequestId;
     exports.calculateQueryHashV2 = calculateQueryHashV2;
     exports.calculateQueryHashV3 = calculateQueryHashV3;
+    exports.calculateRequestId = calculateRequestId;
     exports.checkCircuitOperator = checkCircuitOperator;
     exports.checkCircuitQueriesLength = checkCircuitQueriesLength;
     exports.checkDataInField = checkDataInField;