@0xpolygonid/js-sdk 1.30.0 → 1.31.1

package/dist/browser/esm/index.js

@@ -8255,7 +8255,26 @@ const VerifiableConstants = Object.freeze({
         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
@@ -21245,12 +21264,12 @@ const createVerifiablePresentation = (context, tp, credential, queries) => {
     }
     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
             }
         }
     };
@@ -31682,6 +31701,7 @@ class JsonSchemaValidator {
         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);
@@ -31692,6 +31712,16 @@ class JsonSchemaValidator {
         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 */
 /**
@@ -41047,6 +41077,82 @@ function dnsEncode(name, _maxLength) {
     }))) + "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);
@@ -55368,34 +55474,60 @@ const processZeroKnowledgeProofRequests = async (to, requests, from, proofServic
     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;
+                }
+                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);
                 }
-                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;
@@ -57063,7 +57195,7 @@ class CredentialWallet {
             }
             return { cred, revStatus };
         }
-        throw new Error('all claims are revoked');
+        throw new Error(VerifiableConstants.ERRORS.CREDENTIAL_WALLET_ALL_CREDENTIALS_ARE_REVOKED);
     }
 }
 
@@ -65216,6 +65348,26 @@ const fieldValueFromVerifiablePresentation = async (fieldName, verifiablePresent
     }
     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);
@@ -65749,7 +65901,8 @@ class ProofService {
             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);
@@ -65761,11 +65914,11 @@ class ProofService {
         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;
@@ -65949,7 +66102,7 @@ class ProofService {
     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
@@ -66148,7 +66301,7 @@ class IdentityWallet {
         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);
@@ -66186,7 +66339,7 @@ class IdentityWallet {
         }
         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) };
     }
@@ -66196,7 +66349,7 @@ class IdentityWallet {
         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(),
@@ -66345,11 +66498,11 @@ class IdentityWallet {
         const coreClaimHash = poseidon.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: {
@@ -66389,7 +66542,7 @@ class IdentityWallet {
         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));
@@ -66412,7 +66565,7 @@ class IdentityWallet {
             // credential must have a bjj signature proof
             const coreClaim = credential.getCoreClaimFromProof(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(), MerkleTreeType.Claims, coreClaim.hIndex(), coreClaim.hValue());
         }
@@ -66444,7 +66597,7 @@ class IdentityWallet {
             const coreClaim = credential.getCoreClaimFromProof(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({
@@ -66512,10 +66665,10 @@ class IdentityWallet {
         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;
@@ -66524,7 +66677,7 @@ class IdentityWallet {
     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);
@@ -66564,7 +66717,7 @@ class IdentityWallet {
         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);
@@ -66680,5 +66833,5 @@ class IdentityWallet {
     }
 }
 
-export { AbstractMessageHandler, AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthMethod, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DIDDocumentSignature, DataPrepareHandlerFunc, DidDocumentCredentialStatusResolver, DidResolverStateReadonlyStorage, DiscoverFeatureQueryType, DiscoveryProtocolFeatureType, DiscoveryProtocolHandler, DisplayMethodType, Ed25519Provider, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, FunctionSignatures, Iden3OnchainSmtCredentialStatusPublisher, Iden3SmtRhsCredentialStatusPublisher, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, InputGenerator, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, MessageBus, MessageHandler, NativeProver, OnChainResolver, OnChainRevocationStorage, OnChainZKPVerifier, OnchainIssuer, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PaymentFeatures, PaymentHandler, PaymentRequestDataType, PaymentType, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, SupportedCurrencies, SupportedDataFormat, SupportedPaymentProofType, TransactionService, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes$1 as base58ToBytes, base64ToBytes$1 as base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildAccept, buildDIDFromEthPubKey, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58$1 as bytesToBase58, bytesToBase64, bytesToBase64url$1 as bytesToBase64url, bytesToHex$3 as bytesToHex, cacheLoader, calcChallengeAuthV2, calculateCoreSchemaHash, calculateQueryHashV2, calculateQueryHashV3, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createDiscoveryFeatureDiscloseMessage, createDiscoveryFeatureQueryMessage, createPayment, createPaymentRequest, createProblemReportMessage, createProposal, createProposalRequest, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url$1 as decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fieldValueFromVerifiablePresentation, fillCoreClaimSlot, fillSlot, findCredentialType, findValue, generateProfileDID, getERC20Decimals, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getPermitSignature, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$3 as hexToBytes, isEthereumIdentity, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, packEthIdentityProof, packMetadatas, parseAcceptProfile, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processProofAuth, processProofResponse, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolveDidDocument, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, toTxDataArgs, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyEIP712TypedData, verifyExpiresTime, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
+export { AbstractMessageHandler, AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthMethod, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DIDDocumentSignature, DataPrepareHandlerFunc, DidDocumentCredentialStatusResolver, DidResolverStateReadonlyStorage, DiscoverFeatureQueryType, DiscoveryProtocolFeatureType, DiscoveryProtocolHandler, DisplayMethodType, Ed25519Provider, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, FunctionSignatures, Iden3OnchainSmtCredentialStatusPublisher, Iden3SmtRhsCredentialStatusPublisher, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, InputGenerator, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, MessageBus, MessageHandler, NativeProver, OnChainResolver, OnChainRevocationStorage, OnChainZKPVerifier, OnchainIssuer, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PaymentFeatures, PaymentHandler, PaymentRequestDataType, PaymentType, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, SupportedCurrencies, SupportedDataFormat, SupportedPaymentProofType, TransactionService, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes$1 as base58ToBytes, base64ToBytes$1 as base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildAccept, buildDIDFromEthPubKey, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58$1 as bytesToBase58, bytesToBase64, bytesToBase64url$1 as bytesToBase64url, bytesToHex$3 as bytesToHex, cacheLoader, calcChallengeAuthV2, calculateCoreSchemaHash, calculateGroupId, calculateMultiRequestId, calculateQueryHashV2, calculateQueryHashV3, calculateRequestId, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createDiscoveryFeatureDiscloseMessage, createDiscoveryFeatureQueryMessage, createPayment, createPaymentRequest, createProblemReportMessage, createProposal, createProposalRequest, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url$1 as decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fieldValueFromVerifiablePresentation, fillCoreClaimSlot, fillSlot, findCredentialType, findValue, generateProfileDID, getERC20Decimals, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getPermitSignature, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$3 as hexToBytes, isEthereumIdentity, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, packEthIdentityProof, packMetadatas, parseAcceptProfile, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processProofAuth, processProofResponse, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolveDidDocument, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, toTxDataArgs, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyEIP712TypedData, verifyExpiresTime, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
 //# sourceMappingURL=index.js.map