@0xpolygonid/js-sdk 1.23.0 → 1.25.1

package/dist/browser/esm/index.js

@@ -1,4 +1,4 @@
-import { DID, buildDIDType, Id as Id$1, genesisFromEthAddress, BytesHelper, checkBigIntInField, Claim, SchemaHash, ClaimOptions, MerklizedRootPosition as MerklizedRootPosition$1, IdPosition, getChainId, getUnixTimestamp, ChainIds, getDateFromUnixTimestamp, DidMethod, Blockchain, NetworkId } from '@iden3/js-iden3-core';
+import { DID, buildDIDType, Id as Id$1, genesisFromEthAddress, BytesHelper, checkBigIntInField, Claim, SchemaHash, getChainId, ClaimOptions, MerklizedRootPosition as MerklizedRootPosition$1, IdPosition, chainIDfromDID, getDateFromUnixTimestamp, getUnixTimestamp, ChainIds, DidMethod, Blockchain, NetworkId } from '@iden3/js-iden3-core';
 import * as jsIden3Core from '@iden3/js-iden3-core';
 export { jsIden3Core as core };
 import { Path, Merklizer, getDocumentLoader } from '@iden3/js-jsonld-merklization';
@@ -1343,7 +1343,7 @@ const validateDIDDocumentAuth = async (did, resolverURL, state) => {
     }
 };
 const resolveDIDDocumentAuth = async (did, resolveURL, state) => {
-    let url = `${resolveURL}/${did.string().replace(/:/g, '%3A')}`;
+    let url = `${resolveURL}/${encodeURIComponent(did.string())}`;
     if (state) {
         url += `?state=${state.hex()}`;
     }
@@ -1359,11 +1359,11 @@ function emptyStateDID(did) {
     return emptyDID;
 }
 const resolveDidDocument = async (did, resolverUrl, opts) => {
-    let didString = did.string().replace(/:/g, '%3A');
+    let didString = encodeURIComponent(did.string());
     // for gist resolve we have to `hide` user did (look into resolver implementation)
     const isGistRequest = opts?.gist && !opts.state;
     if (isGistRequest) {
-        didString = emptyStateDID(did).string();
+        didString = encodeURIComponent(emptyStateDID(did).string());
     }
     let url = `${resolverUrl}/1.0/identifiers/${didString}`;
     if (opts?.signature) {
@@ -1375,9 +1375,14 @@ const resolveDidDocument = async (did, resolverUrl, opts) => {
     if (opts?.gist) {
         url += `${url.includes('?') ? '&' : '?'}gist=${opts.gist.hex()}`;
     }
-    const resp = await fetch(url);
-    const data = await resp.json();
-    return data;
+    try {
+        const resp = await fetch(url);
+        const data = await resp.json();
+        return data;
+    }
+    catch (e) {
+        throw new Error(`Failed to resolve DID document for ${did} ${e}`);
+    }
 };
 const buildDIDFromEthPubKey = (didType, pubKeyEth) => {
     // Use Keccak-256 hash function to get public key hash
@@ -7819,6 +7824,7 @@ var SupportedPaymentProofType;
 /**
  * Media types for Payment supported currencies
  * @beta
+ * @deprecated
  * @enum {string}
  */
 var SupportedCurrencies;
@@ -7827,8 +7833,7 @@ var SupportedCurrencies;
     SupportedCurrencies["ETH_WEI"] = "ETHWEI";
     SupportedCurrencies["ETH_GWEI"] = "ETHGWEI";
     SupportedCurrencies["MATIC"] = "MATIC";
-    SupportedCurrencies["USDT"] = "USDT";
-    SupportedCurrencies["USDC"] = "USDC";
+    SupportedCurrencies["POL"] = "POL";
 })(SupportedCurrencies || (SupportedCurrencies = {}));
 /**
  * Supported features for payment-request
@@ -19899,6 +19904,92 @@ class W3CCredential {
         this.credentialSubject = {};
         this.issuer = '';
     }
+    /**
+     *
+     * @param issuer - DID of the issuer
+     * @param request - Credential request
+     * @returns - W3C Credential
+     */
+    static fromCredentialRequest(issuer, request) {
+        if (!request.id) {
+            throw new Error('Credential id is required');
+        }
+        if (!request.context) {
+            throw new Error('Credential context is required');
+        }
+        const context = [
+            VerifiableConstants.JSONLD_SCHEMA.W3C_CREDENTIAL_2018,
+            VerifiableConstants.JSONLD_SCHEMA.IDEN3_CREDENTIAL,
+            ...request.context
+        ];
+        const credentialType = [
+            VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_CREDENTIAL,
+            request.type
+        ];
+        const credentialSubject = request.credentialSubject;
+        credentialSubject['type'] = request.type;
+        const cr = new W3CCredential();
+        cr.id = request.id;
+        cr['@context'] = context;
+        cr.type = credentialType;
+        cr.credentialSubject = credentialSubject;
+        cr.issuer = issuer.string();
+        cr.credentialSchema = {
+            id: request.credentialSchema,
+            type: VerifiableConstants.JSON_SCHEMA_VALIDATOR
+        };
+        cr.credentialStatus = W3CCredential.buildCredentialStatus(request, issuer);
+        request.expiration && (cr.expirationDate = new Date(request.expiration).toISOString());
+        request.refreshService && (cr.refreshService = request.refreshService);
+        request.displayMethod && (cr.displayMethod = request.displayMethod);
+        request.issuanceDate && (cr.issuanceDate = new Date(request.issuanceDate).toISOString());
+        return cr;
+    }
+    /**
+     * Builds credential status
+     * @param {CredentialRequest} request
+     * @returns `CredentialStatus`
+     */
+    static buildCredentialStatus(request, issuer) {
+        const credentialStatus = {
+            id: request.revocationOpts.id,
+            type: request.revocationOpts.type,
+            revocationNonce: request.revocationOpts.nonce
+        };
+        switch (request.revocationOpts.type) {
+            case CredentialStatusType.SparseMerkleTreeProof:
+                return {
+                    ...credentialStatus,
+                    id: `${credentialStatus.id.replace(/\/$/, '')}/${credentialStatus.revocationNonce}`
+                };
+            case CredentialStatusType.Iden3ReverseSparseMerkleTreeProof:
+                return {
+                    ...credentialStatus,
+                    id: request.revocationOpts.issuerState
+                        ? `${credentialStatus.id.replace(/\/$/, '')}/node?state=${request.revocationOpts.issuerState}`
+                        : `${credentialStatus.id.replace(/\/$/, '')}`
+                };
+            case CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023: {
+                const issuerId = DID.idFromDID(issuer);
+                const chainId = getChainId(DID.blockchainFromId(issuerId), DID.networkIdFromId(issuerId));
+                const searchParams = [
+                    ['revocationNonce', request.revocationOpts.nonce?.toString() || ''],
+                    ['contractAddress', `${chainId}:${request.revocationOpts.id}`],
+                    ['state', request.revocationOpts.issuerState || '']
+                ]
+                    .filter(([, value]) => Boolean(value))
+                    .map(([key, value]) => `${key}=${value}`)
+                    .join('&');
+                return {
+                    ...credentialStatus,
+                    // `[did]:[methodid]:[chain]:[network]:[id]/credentialStatus?(revocationNonce=value)&[contractAddress=[chainID]:[contractAddress]]&(state=issuerState)`
+                    id: `${issuer.string()}/credentialStatus?${searchParams}`
+                };
+            }
+            default:
+                return credentialStatus;
+        }
+    }
     toJSON() {
         return {
             ...this,
@@ -51143,6 +51234,12 @@ class AuthV2PubSignals {
         this.GISTRoot = Hash$2.fromString(sVals[2]);
         return this;
     }
+    getStatesInfo() {
+        return {
+            states: [],
+            gists: [{ id: this.userID, root: this.GISTRoot }]
+        };
+    }
 }
 
 /**
@@ -53459,23 +53556,8 @@ class OnChainZKPVerifier {
     constructor(_configs, _opts) {
         this._configs = _configs;
         this._opts = _opts;
-        /**
-         * supported circuits
-         */
-        this._supportedCircuits = [
-            CircuitId.AtomicQueryMTPV2OnChain,
-            CircuitId.AtomicQuerySigV2OnChain,
-            CircuitId.AtomicQueryV3OnChain
-        ];
-        /**
-         * abi coder to encode/decode structures to solidity bytes
-         */
-        this._abiCoder = new AbiCoder();
     }
-    /**
-     * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
-     */
-    async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+    static async prepareTxArgsSubmitV1(txData, zkProofResponse) {
         if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV1) {
             throw new Error(`prepareTxArgsSubmitV1 function doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV1}' is supported.`);
         }
@@ -53493,6 +53575,12 @@ class OnChainZKPVerifier {
         ];
         return payload;
     }
+    /**
+     * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
+     */
+    async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+        return OnChainZKPVerifier.prepareTxArgsSubmitV1(txData, zkProofResponse);
+    }
     /**
      * {@inheritDoc IOnChainZKPVerifier.submitZKPResponse}
      */
@@ -53582,55 +53670,60 @@ class OnChainZKPVerifier {
         const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
         return new Map().set(txnHash, zkProofResponses);
     }
-    async prepareTxArgsSubmitV2(txData, zkProofResponses) {
+    static getCrossChainResolvers(source, txDataChainId, type, didResolverUrl) {
+        return [
+            ...new Set(source.map((info) => JSON.stringify({
+                id: info.id.string(),
+                [type]: type === 'gist' ? info.root?.string() : info.state?.string()
+            })))
+        ].reduce((acc, s) => {
+            const info = JSON.parse(s);
+            const id = Id$1.fromString(info.id);
+            const chainId = chainIDfromDID(DID.parseFromId(id));
+            if (txDataChainId === chainId) {
+                return acc;
+            }
+            const promise = this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(Id$1.fromString(info.id)), didResolverUrl, {
+                [type]: Hash$2.fromString(info[type])
+            });
+            return [...acc, promise];
+        }, []);
+    }
+    static async prepareTxArgsSubmitV2(resolverUrl, txData, zkProofResponses) {
         if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV2) {
             throw new Error(`submit cross chain doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV2}' is supported.`);
         }
-        if (!this._opts?.didResolverUrl) {
-            throw new Error(`did resolver url required for crosschain verification`);
-        }
-        const gistUpdateArr = [];
-        const stateUpdateArr = [];
+        const gistUpdates = [];
+        const stateUpdates = [];
         const payload = [];
-        // Resolved gists and states to avoid duplicate requests
-        const gistUpdateResolutionsPending = [];
-        const stateUpdateResolutionsPending = [];
+        const emptyBytes = '0x';
         for (const zkProof of zkProofResponses) {
-            const requestID = zkProof.id;
-            const inputs = zkProof.pub_signals;
-            if (!this._supportedCircuits.includes(zkProof.circuitId)) {
+            const { id: requestId, pub_signals: inputs } = zkProof;
+            const proofCircuitId = zkProof.circuitId;
+            if (!this._supportedCircuits.includes(proofCircuitId)) {
                 throw new Error(`Circuit ${zkProof.circuitId} not supported by OnChainZKPVerifier`);
             }
+            if (inputs.length === 0) {
+                payload.push({
+                    requestId: requestId,
+                    zkProof: emptyBytes,
+                    data: emptyBytes
+                });
+                continue;
+            }
             const zkProofEncoded = this.packZkpProof(inputs, zkProof.proof.pi_a.slice(0, 2), [
                 [zkProof.proof.pi_b[0][1], zkProof.proof.pi_b[0][0]],
                 [zkProof.proof.pi_b[1][1], zkProof.proof.pi_b[1][0]]
             ], zkProof.proof.pi_c.slice(0, 2));
-            const stateInfo = this.getOnChainGistRootStatePubSignals(zkProof.circuitId, zkProof.pub_signals);
-            const gistUpdateResolutions = [];
-            for (const gist of stateInfo.gists) {
-                const gistResolutionPending = gistUpdateResolutionsPending.find((g) => g == JSON.stringify(gist));
-                if (gistResolutionPending) {
-                    continue;
-                }
-                gistUpdateResolutionsPending.push(JSON.stringify(gist));
-                gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(gist.id), this._opts.didResolverUrl, { gist: gist.root }));
-            }
-            const stateUpdateResolutions = [];
-            for (const state of stateInfo.states) {
-                const stateResolutionPending = stateUpdateResolutionsPending.find((s) => s == JSON.stringify(state));
-                if (stateResolutionPending) {
-                    continue;
-                }
-                stateUpdateResolutionsPending.push(JSON.stringify(state));
-                stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(state.id), this._opts.didResolverUrl, {
-                    state: state.state
-                }));
-            }
+            const stateInfo = this.getOnChainGistRootStatePubSignals(proofCircuitId, inputs);
+            const chainId = txData.chain_id;
+            const gistUpdateResolutions = this.getCrossChainResolvers(stateInfo.gists, chainId, 'gist', resolverUrl);
+            const stateUpdateResolutions = this.getCrossChainResolvers(stateInfo.states, chainId, 'state', resolverUrl);
             if (gistUpdateResolutions.length > 0) {
-                gistUpdateArr.push(...(await Promise.all(gistUpdateResolutions)));
+                gistUpdates.push(...(await Promise.all(gistUpdateResolutions)));
             }
             if (stateUpdateResolutions.length > 0) {
-                stateUpdateArr.push(...(await Promise.all(stateUpdateResolutions)));
+                stateUpdates.push(...(await Promise.all(stateUpdateResolutions)));
             }
             const metadataArr = [];
             if (zkProof.vp) {
@@ -53646,20 +53739,28 @@ class OnChainZKPVerifier {
                     });
                 }
             }
-            const metadata = metadataArr.length ? this.packMetadatas(metadataArr) : '0x';
+            const metadata = metadataArr.length ? this.packMetadatas(metadataArr) : emptyBytes;
             payload.push({
-                requestId: requestID,
+                requestId: requestId,
                 zkProof: zkProofEncoded,
                 data: metadata
             });
         }
-        const crossChainProofs = this.packCrossChainProofs(gistUpdateArr, stateUpdateArr);
+        const crossChainProofs = gistUpdates.length || stateUpdates.length
+            ? this.packCrossChainProofs(gistUpdates, stateUpdates)
+            : emptyBytes;
         return [payload, crossChainProofs];
     }
-    packZkpProof(inputs, a, b, c) {
-        return this._abiCoder.encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
+    async prepareTxArgsSubmitV2(txData, zkProofResponses) {
+        if (!this._opts?.didResolverUrl) {
+            throw new Error(`did resolver url required for crosschain verification`);
+        }
+        return OnChainZKPVerifier.prepareTxArgsSubmitV2(this._opts.didResolverUrl, txData, zkProofResponses);
+    }
+    static packZkpProof(inputs, a, b, c) {
+        return new AbiCoder().encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
     }
-    packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
+    static packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
         const proofs = [];
         for (const globalStateUpdate of gistUpdateArr) {
             proofs.push({
@@ -53673,10 +53774,10 @@ class OnChainZKPVerifier {
                 proof: this.packIdentityStateMsg(stateUpdate)
             });
         }
-        return this._abiCoder.encode(['tuple(' + 'string proofType,' + 'bytes proof' + ')[]'], [proofs]);
+        return new AbiCoder().encode(['tuple(' + 'string proofType,' + 'bytes proof' + ')[]'], [proofs]);
     }
-    packGlobalStateMsg(msg) {
-        return this._abiCoder.encode([
+    static packGlobalStateMsg(msg) {
+        return new AbiCoder().encode([
             'tuple(' +
                 'tuple(' +
                 'uint256 timestamp,' +
@@ -53688,8 +53789,8 @@ class OnChainZKPVerifier {
                 ')'
         ], [msg]);
     }
-    packIdentityStateMsg(msg) {
-        return this._abiCoder.encode([
+    static packIdentityStateMsg(msg) {
+        return new AbiCoder().encode([
             'tuple(' +
                 'tuple(' +
                 'uint256 timestamp,' +
@@ -53701,27 +53802,20 @@ class OnChainZKPVerifier {
                 ')'
         ], [msg]);
     }
-    packMetadatas(metas) {
-        return this._abiCoder.encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
+    static packMetadatas(metas) {
+        return new AbiCoder().encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
     }
-    getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
-        let atomicQueryPubSignals;
-        switch (onChainCircuitId) {
-            case CircuitId.AtomicQueryMTPV2OnChain:
-                atomicQueryPubSignals = new AtomicQueryMTPV2OnChainPubSignals();
-                break;
-            case CircuitId.AtomicQuerySigV2OnChain:
-                atomicQueryPubSignals = new AtomicQuerySigV2OnChainPubSignals();
-                break;
-            case CircuitId.AtomicQueryV3OnChain:
-                atomicQueryPubSignals = new AtomicQueryV3OnChainPubSignals();
-                break;
+    static getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
+        const PubSignals = this._supportedCircuitsPubSignalsMap[onChainCircuitId];
+        if (!PubSignals) {
+            throw new Error(`Circuit ${onChainCircuitId} not supported by OnChainZKPVerifier`);
         }
+        const atomicQueryPubSignals = new PubSignals();
         const encodedInputs = byteEncoder.encode(JSON.stringify(inputs));
         atomicQueryPubSignals.pubSignalsUnmarshal(encodedInputs);
         return atomicQueryPubSignals.getStatesInfo();
     }
-    async resolveDidDocumentEip712MessageAndSignature(did, resolverUrl, opts) {
+    static async resolveDidDocumentEip712MessageAndSignature(did, resolverUrl, opts) {
         const didDoc = await resolveDidDocument(did, resolverUrl, {
             ...opts,
             signature: DIDDocumentSignature.EthereumEip712Signature2021
@@ -53754,6 +53848,21 @@ class OnChainZKPVerifier {
         };
     }
 }
+/**
+ * supported circuits
+ */
+OnChainZKPVerifier._supportedCircuits = [
+    CircuitId.AuthV2,
+    CircuitId.AtomicQueryMTPV2OnChain,
+    CircuitId.AtomicQuerySigV2OnChain,
+    CircuitId.AtomicQueryV3OnChain
+];
+OnChainZKPVerifier._supportedCircuitsPubSignalsMap = {
+    [CircuitId.AtomicQueryMTPV2OnChain]: AtomicQueryMTPV2OnChainPubSignals,
+    [CircuitId.AtomicQuerySigV2OnChain]: AtomicQuerySigV2OnChainPubSignals,
+    [CircuitId.AtomicQueryV3OnChain]: AtomicQueryV3OnChainPubSignals,
+    [CircuitId.AuthV2]: AuthV2PubSignals
+};
 
 var abi$1 = [
 	{
@@ -54127,31 +54236,2279 @@ class OnChainRevocationStorage {
 var abi = [
 	{
 		inputs: [
+			{
+				internalType: "uint256",
+				name: "_userId",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "_credentialId",
+				type: "uint256"
+			}
 		],
-		name: "ECDSAInvalidSignature",
-		type: "error"
+		name: "getCredential",
+		outputs: [
+			{
+				components: [
+					{
+						internalType: "uint256",
+						name: "id",
+						type: "uint256"
+					},
+					{
+						internalType: "string[]",
+						name: "context",
+						type: "string[]"
+					},
+					{
+						internalType: "string",
+						name: "_type",
+						type: "string"
+					},
+					{
+						internalType: "uint64",
+						name: "issuanceDate",
+						type: "uint64"
+					},
+					{
+						components: [
+							{
+								internalType: "string",
+								name: "id",
+								type: "string"
+							},
+							{
+								internalType: "string",
+								name: "_type",
+								type: "string"
+							}
+						],
+						internalType: "struct INonMerklizedIssuer.CredentialSchema",
+						name: "credentialSchema",
+						type: "tuple"
+					},
+					{
+						components: [
+							{
+								internalType: "string",
+								name: "id",
+								type: "string"
+							},
+							{
+								internalType: "string",
+								name: "_type",
+								type: "string"
+							}
+						],
+						internalType: "struct INonMerklizedIssuer.DisplayMethod",
+						name: "displayMethod",
+						type: "tuple"
+					}
+				],
+				internalType: "struct INonMerklizedIssuer.CredentialData",
+				name: "",
+				type: "tuple"
+			},
+			{
+				internalType: "uint256[8]",
+				name: "",
+				type: "uint256[8]"
+			},
+			{
+				components: [
+					{
+						internalType: "string",
+						name: "key",
+						type: "string"
+					},
+					{
+						internalType: "uint256",
+						name: "value",
+						type: "uint256"
+					},
+					{
+						internalType: "bytes",
+						name: "rawValue",
+						type: "bytes"
+					}
+				],
+				internalType: "struct INonMerklizedIssuer.SubjectField[]",
+				name: "",
+				type: "tuple[]"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
 	},
 	{
 		inputs: [
+		],
+		name: "getCredentialAdapterVersion",
+		outputs: [
 			{
-				internalType: "uint256",
-				name: "length",
-				type: "uint256"
+				internalType: "string",
+				name: "",
+				type: "string"
 			}
 		],
-		name: "ECDSAInvalidSignatureLength",
-		type: "error"
+		stateMutability: "view",
+		type: "function"
 	},
 	{
 		inputs: [
 			{
-				internalType: "bytes32",
-				name: "s",
-				type: "bytes32"
+				internalType: "uint256",
+				name: "_userId",
+				type: "uint256"
 			}
 		],
-		name: "ECDSAInvalidSignatureS",
-		type: "error"
+		name: "getUserCredentialIds",
+		outputs: [
+			{
+				internalType: "uint256[]",
+				name: "",
+				type: "uint256[]"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	}
+];
+
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+const _abi = [
+    {
+        inputs: [],
+        name: 'CREDENTIAL_ADAPTER_VERSION',
+        outputs: [
+            {
+                internalType: 'string',
+                name: '',
+                type: 'string'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'claimIndexHash',
+                type: 'uint256'
+            }
+        ],
+        name: 'getClaimProof',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'claimIndexHash',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint256',
+                name: 'root',
+                type: 'uint256'
+            }
+        ],
+        name: 'getClaimProofByRoot',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'claimIndexHash',
+                type: 'uint256'
+            }
+        ],
+        name: 'getClaimProofWithStateInfo',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            },
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'state',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'claimsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'revocationsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'rootsRoot',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct IdentityLib.StateInfo',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getClaimsTreeRoot',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: '_userId',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint256',
+                name: '_credentialId',
+                type: 'uint256'
+            }
+        ],
+        name: 'getCredential',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'id',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'string[]',
+                        name: 'context',
+                        type: 'string[]'
+                    },
+                    {
+                        internalType: 'string',
+                        name: '_type',
+                        type: 'string'
+                    },
+                    {
+                        internalType: 'uint64',
+                        name: 'issuanceDate',
+                        type: 'uint64'
+                    },
+                    {
+                        components: [
+                            {
+                                internalType: 'string',
+                                name: 'id',
+                                type: 'string'
+                            },
+                            {
+                                internalType: 'string',
+                                name: '_type',
+                                type: 'string'
+                            }
+                        ],
+                        internalType: 'struct INonMerklizedIssuer.CredentialSchema',
+                        name: 'credentialSchema',
+                        type: 'tuple'
+                    },
+                    {
+                        components: [
+                            {
+                                internalType: 'string',
+                                name: 'id',
+                                type: 'string'
+                            },
+                            {
+                                internalType: 'string',
+                                name: '_type',
+                                type: 'string'
+                            }
+                        ],
+                        internalType: 'struct INonMerklizedIssuer.DisplayMethod',
+                        name: 'displayMethod',
+                        type: 'tuple'
+                    }
+                ],
+                internalType: 'struct INonMerklizedIssuer.CredentialData',
+                name: '',
+                type: 'tuple'
+            },
+            {
+                internalType: 'uint256[8]',
+                name: '',
+                type: 'uint256[8]'
+            },
+            {
+                components: [
+                    {
+                        internalType: 'string',
+                        name: 'key',
+                        type: 'string'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bytes',
+                        name: 'rawValue',
+                        type: 'bytes'
+                    }
+                ],
+                internalType: 'struct INonMerklizedIssuer.SubjectField[]',
+                name: '',
+                type: 'tuple[]'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getCredentialAdapterVersion',
+        outputs: [
+            {
+                internalType: 'string',
+                name: '',
+                type: 'string'
+            }
+        ],
+        stateMutability: 'pure',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getId',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getIsOldStateGenesis',
+        outputs: [
+            {
+                internalType: 'bool',
+                name: '',
+                type: 'bool'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getLatestPublishedClaimsRoot',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getLatestPublishedRevocationsRoot',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getLatestPublishedRootsRoot',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getLatestPublishedState',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint64',
+                name: 'revocationNonce',
+                type: 'uint64'
+            }
+        ],
+        name: 'getRevocationProof',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint64',
+                name: 'revocationNonce',
+                type: 'uint64'
+            },
+            {
+                internalType: 'uint256',
+                name: 'root',
+                type: 'uint256'
+            }
+        ],
+        name: 'getRevocationProofByRoot',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint64',
+                name: 'revocationNonce',
+                type: 'uint64'
+            }
+        ],
+        name: 'getRevocationProofWithStateInfo',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            },
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'state',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'claimsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'revocationsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'rootsRoot',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct IdentityLib.StateInfo',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'id',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint64',
+                name: 'nonce',
+                type: 'uint64'
+            }
+        ],
+        name: 'getRevocationStatus',
+        outputs: [
+            {
+                components: [
+                    {
+                        components: [
+                            {
+                                internalType: 'uint256',
+                                name: 'state',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'claimsTreeRoot',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'revocationTreeRoot',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'rootOfRoots',
+                                type: 'uint256'
+                            }
+                        ],
+                        internalType: 'struct IOnchainCredentialStatusResolver.IdentityStateRoots',
+                        name: 'issuer',
+                        type: 'tuple'
+                    },
+                    {
+                        components: [
+                            {
+                                internalType: 'uint256',
+                                name: 'root',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'bool',
+                                name: 'existence',
+                                type: 'bool'
+                            },
+                            {
+                                internalType: 'uint256[]',
+                                name: 'siblings',
+                                type: 'uint256[]'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'index',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'value',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'bool',
+                                name: 'auxExistence',
+                                type: 'bool'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'auxIndex',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'auxValue',
+                                type: 'uint256'
+                            }
+                        ],
+                        internalType: 'struct IOnchainCredentialStatusResolver.Proof',
+                        name: 'mtp',
+                        type: 'tuple'
+                    }
+                ],
+                internalType: 'struct IOnchainCredentialStatusResolver.CredentialStatus',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'id',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint256',
+                name: 'state',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint64',
+                name: 'nonce',
+                type: 'uint64'
+            }
+        ],
+        name: 'getRevocationStatusByIdAndState',
+        outputs: [
+            {
+                components: [
+                    {
+                        components: [
+                            {
+                                internalType: 'uint256',
+                                name: 'state',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'claimsTreeRoot',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'revocationTreeRoot',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'rootOfRoots',
+                                type: 'uint256'
+                            }
+                        ],
+                        internalType: 'struct IOnchainCredentialStatusResolver.IdentityStateRoots',
+                        name: 'issuer',
+                        type: 'tuple'
+                    },
+                    {
+                        components: [
+                            {
+                                internalType: 'uint256',
+                                name: 'root',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'bool',
+                                name: 'existence',
+                                type: 'bool'
+                            },
+                            {
+                                internalType: 'uint256[]',
+                                name: 'siblings',
+                                type: 'uint256[]'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'index',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'value',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'bool',
+                                name: 'auxExistence',
+                                type: 'bool'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'auxIndex',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'auxValue',
+                                type: 'uint256'
+                            }
+                        ],
+                        internalType: 'struct IOnchainCredentialStatusResolver.Proof',
+                        name: 'mtp',
+                        type: 'tuple'
+                    }
+                ],
+                internalType: 'struct IOnchainCredentialStatusResolver.CredentialStatus',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getRevocationsTreeRoot',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'rootsTreeRoot',
+                type: 'uint256'
+            }
+        ],
+        name: 'getRootProof',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'claimsTreeRoot',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint256',
+                name: 'root',
+                type: 'uint256'
+            }
+        ],
+        name: 'getRootProofByRoot',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'rootsTreeRoot',
+                type: 'uint256'
+            }
+        ],
+        name: 'getRootProofWithStateInfo',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            },
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'state',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'claimsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'revocationsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'rootsRoot',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct IdentityLib.StateInfo',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'state',
+                type: 'uint256'
+            }
+        ],
+        name: 'getRootsByState',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'claimsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'revocationsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'rootsRoot',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct IdentityLib.Roots',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getRootsTreeRoot',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getSmtDepth',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'pure',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: '_userId',
+                type: 'uint256'
+            }
+        ],
+        name: 'getUserCredentialIds',
+        outputs: [
+            {
+                internalType: 'uint256[]',
+                name: '',
+                type: 'uint256[]'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'address',
+                name: '_stateContractAddr',
+                type: 'address'
+            },
+            {
+                internalType: 'bytes2',
+                name: 'idType',
+                type: 'bytes2'
+            }
+        ],
+        name: 'initialize',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'bytes4',
+                name: 'interfaceId',
+                type: 'bytes4'
+            }
+        ],
+        name: 'supportsInterface',
+        outputs: [
+            {
+                internalType: 'bool',
+                name: '',
+                type: 'bool'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    }
+];
+class NonMerklizedIssuerBase__factory {
+    static abi = _abi;
+    static createInterface() {
+        return new Interface(_abi);
+    }
+    static connect(address, runner) {
+        return new Contract(address, _abi, runner);
+    }
+}
+
+var NonMerklizedIssuerInterfaces;
+(function (NonMerklizedIssuerInterfaces) {
+    NonMerklizedIssuerInterfaces["InterfaceDetection"] = "0x01ffc9a7";
+    NonMerklizedIssuerInterfaces["InterfaceNonMerklizedIssuer"] = "0x58874949";
+    NonMerklizedIssuerInterfaces["InterfaceGetCredential"] = "0x5d1ca631";
+})(NonMerklizedIssuerInterfaces || (NonMerklizedIssuerInterfaces = {}));
+var ValueHashes;
+(function (ValueHashes) {
+    ValueHashes["BooleanTrue"] = "18586133768512220936620570745912940619677854269274689475585506675881198879027";
+    ValueHashes["BooleanFalse"] = "19014214495641488759237505126948346942972912379615652741039992445865937985820";
+})(ValueHashes || (ValueHashes = {}));
+/**
+ * `OnchainNonMerklizedIssuerAdapter` provides functionality to interact with a non-merklized on-chain credential issuer.
+ * This adapter enables interface detection, credential retrieval, and conversion to the W3C Verifiable Credential format.
+ *
+ * @public
+ * @beta
+ * @class OnchainNonMerklizedIssuerAdapter
+ */
+class OnchainNonMerklizedIssuerAdapter {
+    /**
+     * Initializes an instance of `OnchainNonMerklizedIssuerAdapter`.
+     *
+     * @param ethConnectionConfig The configuration for the Ethereum connection.
+     * @param issuerDid The decentralized identifier (DID) of the issuer.
+     * @param merklizationOptions Optional settings for merklization.
+     */
+    constructor(ethConnectionConfig, issuerDid, options) {
+        if (!ethConnectionConfig.chainId) {
+            throw new Error('Chain ID is required');
+        }
+        this._chainId = ethConnectionConfig.chainId;
+        this._contractAddress = getAddress(hexlify(Id$1.ethAddressFromId(DID.idFromDID(issuerDid))));
+        this._contract = NonMerklizedIssuerBase__factory.connect(this._contractAddress, new JsonRpcProvider(ethConnectionConfig.url));
+        this._issuerDid = issuerDid;
+        this._merklizationOptions = options?.merklizationOptions;
+    }
+    /**
+     * Checks if the contract supports required interfaces.
+     * Throws an error if any required interface is unsupported.
+     *
+     * @throws Error - If required interfaces are not supported.
+     */
+    async isInterfaceSupported() {
+        const supportedInterfaces = [
+            {
+                name: 'Interface detection ERC-165',
+                value: NonMerklizedIssuerInterfaces.InterfaceDetection
+            },
+            {
+                name: 'Interface non-merklized issuer',
+                value: NonMerklizedIssuerInterfaces.InterfaceNonMerklizedIssuer
+            },
+            {
+                name: 'Interface get credential',
+                value: NonMerklizedIssuerInterfaces.InterfaceGetCredential
+            }
+        ];
+        const unsupportedInterfaces = await Promise.all(supportedInterfaces.map(async (interfaceObj) => {
+            const isSupported = await this._contract.supportsInterface(interfaceObj.value);
+            return isSupported ? null : interfaceObj.name;
+        }));
+        const unsupportedInterfacesFiltered = unsupportedInterfaces.filter((interfaceName) => interfaceName !== null);
+        if (unsupportedInterfacesFiltered.length > 0) {
+            throw new Error(`Unsupported interfaces: ${unsupportedInterfacesFiltered.join(', ')}`);
+        }
+    }
+    /**
+     * Retrieves a credential from the on-chain non-merklized contract.
+     * @param userId The user's core.Id.
+     * @param credentialId The unique identifier of the credential.
+     */
+    async getCredential(userId, credentialId) {
+        const [credentialData, coreClaimBigInts, credentialSubjectFields] = await this._contract.getCredential(userId.bigInt(), credentialId);
+        return { credentialData, coreClaimBigInts, credentialSubjectFields };
+    }
+    /**
+     * Retrieves the credential IDs of a user.
+     * @param userId The user's core.Id.
+     * @returns An array of credential IDs.
+     */
+    async getUserCredentialsIds(userId) {
+        return this._contract.getUserCredentialIds(userId.bigInt());
+    }
+    /**
+     * Converts on-chain credential to a verifiable credential.
+     *
+     * @param credentialData Data structure of the credential from the contract.
+     * @param coreClaimBigInts Claim data in bigint format.
+     * @param credentialSubjectFields Subject fields of the credential.
+     */
+    async convertOnChainInfoToW3CCredential(credentialData, coreClaimBigInts, credentialSubjectFields) {
+        const c = new Claim().unMarshalJson(JSON.stringify(coreClaimBigInts.map((b) => b.toString())));
+        const credentialSubject = await this.convertCredentialSubject(c, credentialData.context, credentialData._type, credentialSubjectFields);
+        const credentialRequest = {
+            id: this.credentialId(credentialData.id),
+            credentialSchema: credentialData.credentialSchema.id,
+            type: credentialData._type,
+            credentialSubject: credentialSubject,
+            expiration: c.getExpirationDate()?.getTime(),
+            displayMethod: this.convertDisplayMethod(credentialData.displayMethod),
+            context: credentialData.context,
+            revocationOpts: {
+                id: this._contractAddress,
+                nonce: Number(c.getRevocationNonce()),
+                type: CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023
+            },
+            issuanceDate: getDateFromUnixTimestamp(Number(credentialData.issuanceDate)).getTime()
+        };
+        const existenceProof = await this.existenceProof(c);
+        const w3c = W3CCredential.fromCredentialRequest(this._issuerDid, credentialRequest);
+        w3c.proof = [existenceProof];
+        return w3c;
+    }
+    credentialId(id) {
+        return `urn:iden3:onchain:${this._chainId}:${this._contractAddress}:${id}`;
+    }
+    async convertCredentialSubject(coreClaim, contractContexts, credentialType, credentialSubjectFields) {
+        const contractContextsStr = JSON.stringify({
+            '@context': contractContexts
+        });
+        const credentialSubject = {};
+        for (const f of credentialSubjectFields) {
+            const dataType = await Path.newTypeFromContext(contractContextsStr, `${credentialType}.${f.key}`, this._merklizationOptions);
+            switch (dataType) {
+                case XSDNS.Boolean: {
+                    switch (f.rawValue.toString()) {
+                        case ValueHashes.BooleanTrue:
+                            credentialSubject[f.key] = true;
+                            break;
+                        case ValueHashes.BooleanFalse:
+                            credentialSubject[f.key] = false;
+                            break;
+                    }
+                    break;
+                }
+                case (XSDNS.PositiveInteger):
+                    {
+                        credentialSubject[f.key] = f.value.toString();
+                        break;
+                    }
+                case XSDNS.Integer: {
+                    credentialSubject[f.key] = Number(f.value);
+                    break;
+                }
+                case XSDNS.String: {
+                    this.validateSourceValue(dataType, f.value, f.rawValue);
+                    credentialSubject[f.key] = f.rawValue;
+                    break;
+                }
+                case XSDNS.DateTime: {
+                    const timestamp = BigInt(f.rawValue);
+                    const sourceTimestamp = getDateFromUnixTimestamp(Number(timestamp)).toISOString();
+                    this.validateSourceValue(dataType, f.value, sourceTimestamp);
+                    credentialSubject[f.key] = sourceTimestamp;
+                    break;
+                }
+                case XSDNS.Double: {
+                    const rawFloat = Number(f.rawValue);
+                    this.validateSourceValue(dataType, f.value, rawFloat);
+                    credentialSubject[f.key] = rawFloat;
+                    break;
+                }
+                default: {
+                    throw new Error(`Unsupported data type ${dataType}`);
+                }
+            }
+        }
+        credentialSubject['type'] = credentialType;
+        const subjectId = coreClaim.getId();
+        const subjectDid = DID.parseFromId(subjectId);
+        credentialSubject['id'] = subjectDid.string();
+        return credentialSubject;
+    }
+    async existenceProof(coreClaim) {
+        const [mtpProof, stateInfo] = await this._contract.getClaimProofWithStateInfo(coreClaim.hIndex());
+        if (!mtpProof.existence) {
+            throw new Error('Claim does not exist');
+        }
+        const latestStateHash = Hash$2.fromBigInt(stateInfo.state);
+        const latestClaimsOfRootHash = Hash$2.fromBigInt(stateInfo.claimsRoot);
+        const latestRevocationOfRootHash = Hash$2.fromBigInt(stateInfo.revocationsRoot);
+        const latestRootsOfRootHash = Hash$2.fromBigInt(stateInfo.rootsRoot);
+        const p = new Proof({
+            siblings: mtpProof.siblings.map((s) => Hash$2.fromBigInt(s)),
+            existence: mtpProof.existence,
+            nodeAux: mtpProof.auxExistence
+                ? {
+                    key: Hash$2.fromBigInt(mtpProof.auxIndex),
+                    value: Hash$2.fromBigInt(mtpProof.auxValue)
+                }
+                : undefined
+        });
+        return new Iden3SparseMerkleTreeProof({
+            issuerData: {
+                id: this._issuerDid,
+                state: {
+                    value: latestStateHash,
+                    claimsTreeRoot: latestClaimsOfRootHash,
+                    revocationTreeRoot: latestRevocationOfRootHash,
+                    rootOfRoots: latestRootsOfRootHash
+                }
+            },
+            mtp: p,
+            coreClaim: coreClaim
+        });
+    }
+    async validateSourceValue(dataType, originHash, source) {
+        const sourceHash = await Merklizer.hashValue(dataType, source);
+        if (sourceHash !== originHash) {
+            throw new Error(`Invalid source value for ${dataType} type`);
+        }
+    }
+    convertDisplayMethod(onchainDisplayMethod) {
+        if (!onchainDisplayMethod.id || !onchainDisplayMethod._type) {
+            return undefined;
+        }
+        switch (onchainDisplayMethod._type) {
+            case DisplayMethodType.Iden3BasicDisplayMethodV1: {
+                return {
+                    id: onchainDisplayMethod.id,
+                    type: DisplayMethodType.Iden3BasicDisplayMethodV1
+                };
+            }
+            default: {
+                throw new Error(`Unsupported display method type ${onchainDisplayMethod._type}`);
+            }
+        }
+    }
+}
+
+/**
+ * Represents an adapter for interacting with on-chain issuers.
+ *
+ * @public
+ * @beta
+ * @class OnchainIssuer
+ */
+class OnchainIssuer {
+    /**
+     * Initializes an instance of `Adapter`.
+     * @param config The configuration for the Ethereum connection.
+     * @param merklizationOptions Optional settings for merklization.
+     */
+    constructor(config, options) {
+        this._ethConnectionConfig = config;
+        this._onchainIssuerOptions = options;
+    }
+    /**
+     * Retrieves a credential from the on-chain issuer.
+     * @param issuerDID The issuer's core.DID.
+     * @param userId The user's core.Id.
+     * @param credentialId The unique identifier of the credential.
+     */
+    async getCredential(issuerDID, userDID, credentialId) {
+        const { contract, connection } = this.getContractConnection(issuerDID);
+        const response = await contract.getCredentialAdapterVersion();
+        switch (response) {
+            case '0.0.1': {
+                const adapter = new OnchainNonMerklizedIssuerAdapter(connection, issuerDID, {
+                    merklizationOptions: this._onchainIssuerOptions?.merklizationOptions
+                });
+                await adapter.isInterfaceSupported();
+                const { credentialData, coreClaimBigInts, credentialSubjectFields } = await adapter.getCredential(DID.idFromDID(userDID), credentialId);
+                return await adapter.convertOnChainInfoToW3CCredential(credentialData, coreClaimBigInts, credentialSubjectFields);
+            }
+            default:
+                throw new Error(`Unsupported adapter version ${response}`);
+        }
+    }
+    /**
+     * Retrieves the credential identifiers for a user from the on-chain issuer.
+     * @param issuerDID The issuer's core.DID.
+     * @param userId The user's core.Id.
+     */
+    async getUserCredentialIds(issuerDID, userDID) {
+        const { contract, connection } = this.getContractConnection(issuerDID);
+        const response = await contract.getCredentialAdapterVersion();
+        switch (response) {
+            case '0.0.1': {
+                const adapter = new OnchainNonMerklizedIssuerAdapter(connection, issuerDID, {
+                    merklizationOptions: this._onchainIssuerOptions?.merklizationOptions
+                });
+                await adapter.isInterfaceSupported();
+                return await adapter.getUserCredentialsIds(DID.idFromDID(userDID));
+            }
+            default:
+                throw new Error(`Unsupported adapter version ${response}`);
+        }
+    }
+    getContractConnection(did) {
+        const issuerId = DID.idFromDID(did);
+        const chainId = chainIDfromDID(did);
+        const contractAddress = getAddress(hexlify(Id$1.ethAddressFromId(issuerId)));
+        const connection = this._ethConnectionConfig.find((c) => c.chainId === chainId);
+        if (!connection) {
+            throw new Error(`No connection found for chain ID ${chainId}`);
+        }
+        if (!connection.url) {
+            throw new Error(`No URL found for chain ID ${chainId}`);
+        }
+        const contract = new Contract(contractAddress, abi, new JsonRpcProvider(connection.url));
+        return { contract, connection };
+    }
+}
+
+class DidResolverStateReadonlyStorage {
+    constructor(resolverUrl) {
+        this.resolverUrl = resolverUrl;
+    }
+    async getLatestStateById(id) {
+        return this.getStateInfo(id);
+    }
+    async getStateInfoByIdAndState(id, state) {
+        return this.getStateInfo(id, state);
+    }
+    async getGISTProof(id) {
+        const { didDocument } = await resolveDidDocument(DID.parseFromId(Id$1.fromBigInt(id)), this.resolverUrl);
+        const { global } = this.getIden3StateInfo2023(didDocument);
+        if (!global) {
+            throw new Error('GIST root not found');
+        }
+        const { proof } = global;
+        if (!proof) {
+            throw new Error('GIST proof not found');
+        }
+        return {
+            root: global.root,
+            existence: proof.existence,
+            siblings: proof.siblings?.map((sibling) => BigInt(sibling)),
+            index: BigInt(0),
+            value: BigInt(0),
+            auxExistence: !!proof.node_aux,
+            auxIndex: proof.node_aux ? BigInt(proof.node_aux.key) : BigInt(0),
+            auxValue: proof.node_aux ? BigInt(proof.node_aux.value) : BigInt(0)
+        };
+    }
+    async getGISTRootInfo(root, userId) {
+        const { didDocument } = await resolveDidDocument(DID.parseFromId(Id$1.fromBigInt(userId)), this.resolverUrl, {
+            gist: Hash$2.fromBigInt(root)
+        });
+        const { global } = this.getIden3StateInfo2023(didDocument);
+        if (!global) {
+            throw new Error('GIST root not found');
+        }
+        return global;
+    }
+    getRpcProvider() {
+        return new JsonRpcProvider();
+    }
+    publishState() {
+        throw new Error('publishState method not implemented.');
+    }
+    publishStateGeneric() {
+        throw new Error('publishStateGeneric method not implemented.');
+    }
+    async getStateInfo(id, state) {
+        const opts = state ? { state: Hash$2.fromBigInt(state) } : undefined;
+        const { didDocument } = await resolveDidDocument(DID.parseFromId(Id$1.fromBigInt(id)), this.resolverUrl, opts);
+        const { info } = this.getIden3StateInfo2023(didDocument);
+        return { ...info };
+    }
+    getIden3StateInfo2023(didDocument) {
+        const vm = didDocument.verificationMethod?.find((i) => i.type === 'Iden3StateInfo2023');
+        if (!vm) {
+            throw new Error('Iden3StateInfo2023 verification method not found');
+        }
+        return vm;
+    }
+}
+
+var permitAbi = [
+	{
+		inputs: [
+		],
+		name: "ECDSAInvalidSignature",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint256",
+				name: "length",
+				type: "uint256"
+			}
+		],
+		name: "ECDSAInvalidSignatureLength",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "s",
+				type: "bytes32"
+			}
+		],
+		name: "ECDSAInvalidSignatureS",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "allowance",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "needed",
+				type: "uint256"
+			}
+		],
+		name: "ERC20InsufficientAllowance",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "balance",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "needed",
+				type: "uint256"
+			}
+		],
+		name: "ERC20InsufficientBalance",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "approver",
+				type: "address"
+			}
+		],
+		name: "ERC20InvalidApprover",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "receiver",
+				type: "address"
+			}
+		],
+		name: "ERC20InvalidReceiver",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			}
+		],
+		name: "ERC20InvalidSender",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			}
+		],
+		name: "ERC20InvalidSpender",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint256",
+				name: "deadline",
+				type: "uint256"
+			}
+		],
+		name: "ERC2612ExpiredSignature",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "signer",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			}
+		],
+		name: "ERC2612InvalidSigner",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "account",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "currentNonce",
+				type: "uint256"
+			}
+		],
+		name: "InvalidAccountNonce",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "InvalidShortString",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "string",
+				name: "str",
+				type: "string"
+			}
+		],
+		name: "StringTooLong",
+		type: "error"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "Approval",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+		],
+		name: "EIP712DomainChanged",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "from",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "Transfer",
+		type: "event"
+	},
+	{
+		inputs: [
+		],
+		name: "DOMAIN_SEPARATOR",
+		outputs: [
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			}
+		],
+		name: "allowance",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "approve",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "account",
+				type: "address"
+			}
+		],
+		name: "balanceOf",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "decimals",
+		outputs: [
+			{
+				internalType: "uint8",
+				name: "",
+				type: "uint8"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "eip712Domain",
+		outputs: [
+			{
+				internalType: "bytes1",
+				name: "fields",
+				type: "bytes1"
+			},
+			{
+				internalType: "string",
+				name: "name",
+				type: "string"
+			},
+			{
+				internalType: "string",
+				name: "version",
+				type: "string"
+			},
+			{
+				internalType: "uint256",
+				name: "chainId",
+				type: "uint256"
+			},
+			{
+				internalType: "address",
+				name: "verifyingContract",
+				type: "address"
+			},
+			{
+				internalType: "bytes32",
+				name: "salt",
+				type: "bytes32"
+			},
+			{
+				internalType: "uint256[]",
+				name: "extensions",
+				type: "uint256[]"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "name",
+		outputs: [
+			{
+				internalType: "string",
+				name: "",
+				type: "string"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			}
+		],
+		name: "nonces",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "deadline",
+				type: "uint256"
+			},
+			{
+				internalType: "uint8",
+				name: "v",
+				type: "uint8"
+			},
+			{
+				internalType: "bytes32",
+				name: "r",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "s",
+				type: "bytes32"
+			}
+		],
+		name: "permit",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "symbol",
+		outputs: [
+			{
+				internalType: "string",
+				name: "",
+				type: "string"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "totalSupply",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "transfer",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "from",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "transferFrom",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	}
+];
+
+var erc20Abi = [
+	{
+		inputs: [
+			{
+				internalType: "uint256",
+				name: "initialSupply",
+				type: "uint256"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "constructor"
 	},
 	{
 		inputs: [
@@ -54239,66 +56596,6 @@ var abi = [
 		name: "ERC20InvalidSpender",
 		type: "error"
 	},
-	{
-		inputs: [
-			{
-				internalType: "uint256",
-				name: "deadline",
-				type: "uint256"
-			}
-		],
-		name: "ERC2612ExpiredSignature",
-		type: "error"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "signer",
-				type: "address"
-			},
-			{
-				internalType: "address",
-				name: "owner",
-				type: "address"
-			}
-		],
-		name: "ERC2612InvalidSigner",
-		type: "error"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "account",
-				type: "address"
-			},
-			{
-				internalType: "uint256",
-				name: "currentNonce",
-				type: "uint256"
-			}
-		],
-		name: "InvalidAccountNonce",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "InvalidShortString",
-		type: "error"
-	},
-	{
-		inputs: [
-			{
-				internalType: "string",
-				name: "str",
-				type: "string"
-			}
-		],
-		name: "StringTooLong",
-		type: "error"
-	},
 	{
 		anonymous: false,
 		inputs: [
@@ -54324,13 +56621,6 @@ var abi = [
 		name: "Approval",
 		type: "event"
 	},
-	{
-		anonymous: false,
-		inputs: [
-		],
-		name: "EIP712DomainChanged",
-		type: "event"
-	},
 	{
 		anonymous: false,
 		inputs: [
@@ -54356,20 +56646,6 @@ var abi = [
 		name: "Transfer",
 		type: "event"
 	},
-	{
-		inputs: [
-		],
-		name: "DOMAIN_SEPARATOR",
-		outputs: [
-			{
-				internalType: "bytes32",
-				name: "",
-				type: "bytes32"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
 	{
 		inputs: [
 			{
@@ -54451,50 +56727,6 @@ var abi = [
 		stateMutability: "view",
 		type: "function"
 	},
-	{
-		inputs: [
-		],
-		name: "eip712Domain",
-		outputs: [
-			{
-				internalType: "bytes1",
-				name: "fields",
-				type: "bytes1"
-			},
-			{
-				internalType: "string",
-				name: "name",
-				type: "string"
-			},
-			{
-				internalType: "string",
-				name: "version",
-				type: "string"
-			},
-			{
-				internalType: "uint256",
-				name: "chainId",
-				type: "uint256"
-			},
-			{
-				internalType: "address",
-				name: "verifyingContract",
-				type: "address"
-			},
-			{
-				internalType: "bytes32",
-				name: "salt",
-				type: "bytes32"
-			},
-			{
-				internalType: "uint256[]",
-				name: "extensions",
-				type: "uint256[]"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
 	{
 		inputs: [
 		],
@@ -54509,69 +56741,6 @@ var abi = [
 		stateMutability: "view",
 		type: "function"
 	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "owner",
-				type: "address"
-			}
-		],
-		name: "nonces",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "owner",
-				type: "address"
-			},
-			{
-				internalType: "address",
-				name: "spender",
-				type: "address"
-			},
-			{
-				internalType: "uint256",
-				name: "value",
-				type: "uint256"
-			},
-			{
-				internalType: "uint256",
-				name: "deadline",
-				type: "uint256"
-			},
-			{
-				internalType: "uint8",
-				name: "v",
-				type: "uint8"
-			},
-			{
-				internalType: "bytes32",
-				name: "r",
-				type: "bytes32"
-			},
-			{
-				internalType: "bytes32",
-				name: "s",
-				type: "bytes32"
-			}
-		],
-		name: "permit",
-		outputs: [
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
 	{
 		inputs: [
 		],
@@ -54666,10 +56835,11 @@ var abi = [
  * @returns {Promise<PaymentRequestMessage>}
  */
 async function getPermitSignature(signer, tokenAddress, spender, value, deadline) {
-    const erc20PermitContract = new Contract(tokenAddress, abi, signer);
+    const erc20PermitContract = new Contract(tokenAddress, permitAbi, signer);
     const nonce = await erc20PermitContract.nonces(await signer.getAddress());
     const domainData = await erc20PermitContract.eip712Domain();
     const domain = {
+        name: domainData[1],
         version: domainData[2],
         chainId: domainData[3],
         verifyingContract: tokenAddress
@@ -54692,6 +56862,16 @@ async function getPermitSignature(signer, tokenAddress, spender, value, deadline
     };
     return signer.signTypedData(domain, types, message);
 }
+/**
+ * @beta
+ * getERC20Decimals is a function to retrieve the number of decimals of an ERC20 token
+ * @param {string} tokenAddress - Token address
+ * @param {ethers.ContractRunner} runner - Contract runner
+ */
+async function getERC20Decimals(tokenAddress, runner) {
+    const erc20Contract = new Contract(tokenAddress, erc20Abi, runner);
+    return erc20Contract.decimals();
+}
 
 /**
  * Type of MerkleTree
@@ -56370,6 +58550,24 @@ class Iden3SmtRhsCredentialStatusPublisher {
     }
 }
 
+class DidDocumentCredentialStatusResolver {
+    constructor(didResolverUrl) {
+        this.didResolverUrl = didResolverUrl;
+    }
+    async resolve(credentialStatus, opts) {
+        if (!opts?.issuerDID) {
+            throw new Error('IssuerDID is not set in options');
+        }
+        const url = `${this.didResolverUrl}/1.0/credential-status/${encodeURIComponent(opts.issuerDID.string())}`;
+        const resp = await fetch(url, {
+            method: 'POST',
+            body: JSON.stringify(credentialStatus)
+        });
+        const data = await resp.json();
+        return data;
+    }
+}
+
 /**
  *
  * Wallet instance is a wrapper of CRUD logic for W3C credentials,
@@ -56396,40 +58594,18 @@ class CredentialWallet {
             if (!schema.$metadata.uris['jsonLdContext']) {
                 throw new Error('jsonLdContext is missing is the schema');
             }
-            request.context = request.context ?? [];
-            if (request.displayMethod?.type === DisplayMethodType.Iden3BasicDisplayMethodV1 &&
-                !request.context.includes(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD)) {
-                request.context.push(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD);
-            }
-            const context = [
-                VerifiableConstants.JSONLD_SCHEMA.W3C_CREDENTIAL_2018,
-                ...request.context,
-                VerifiableConstants.JSONLD_SCHEMA.IDEN3_CREDENTIAL,
-                schema.$metadata.uris['jsonLdContext']
-            ];
-            const credentialType = [
-                VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_CREDENTIAL,
-                request.type
-            ];
-            const expirationDate = !request.expiration || request.expiration == 0 ? null : request.expiration;
-            const credentialSubject = request.credentialSubject;
-            credentialSubject['type'] = request.type;
-            const cr = new W3CCredential();
-            cr.id = `urn:${v4()}`;
-            cr['@context'] = context;
-            cr.type = credentialType;
-            cr.expirationDate = expirationDate ? new Date(expirationDate * 1000).toISOString() : undefined;
-            cr.refreshService = request.refreshService;
-            cr.displayMethod = request.displayMethod;
-            cr.issuanceDate = new Date().toISOString();
-            cr.credentialSubject = credentialSubject;
-            cr.issuer = issuer.string();
-            cr.credentialSchema = {
-                id: request.credentialSchema,
-                type: VerifiableConstants.JSON_SCHEMA_VALIDATOR
-            };
-            cr.credentialStatus = this.buildCredentialStatus(request, issuer);
-            return cr;
+            // do copy of request to avoid mutation
+            const r = { ...request };
+            r.context = r.context ?? [];
+            if (r.displayMethod?.type === DisplayMethodType.Iden3BasicDisplayMethodV1 &&
+                !r.context.includes(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD)) {
+                r.context.push(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD);
+            }
+            r.context.push(schema.$metadata.uris['jsonLdContext']);
+            r.expiration = r.expiration ? r.expiration * 1000 : undefined;
+            r.id = r.id ? r.id : `urn:${v4()}`;
+            r.issuanceDate = r.issuanceDate ? r.issuanceDate * 1000 : Date.now();
+            return W3CCredential.fromCredentialRequest(issuer, r);
         };
         // if no credential status resolvers are provided
         // register default issuer resolver
@@ -56499,51 +58675,6 @@ class CredentialWallet {
         }
         return statusResolver.resolve(credStatus, credentialStatusResolveOptions);
     }
-    /**
-     * Builds credential status
-     * @param {CredentialRequest} request
-     * @returns `CredentialStatus`
-     */
-    buildCredentialStatus(request, issuer) {
-        const credentialStatus = {
-            id: request.revocationOpts.id,
-            type: request.revocationOpts.type,
-            revocationNonce: request.revocationOpts.nonce
-        };
-        switch (request.revocationOpts.type) {
-            case CredentialStatusType.SparseMerkleTreeProof:
-                return {
-                    ...credentialStatus,
-                    id: `${credentialStatus.id.replace(/\/$/, '')}/${credentialStatus.revocationNonce}`
-                };
-            case CredentialStatusType.Iden3ReverseSparseMerkleTreeProof:
-                return {
-                    ...credentialStatus,
-                    id: request.revocationOpts.issuerState
-                        ? `${credentialStatus.id.replace(/\/$/, '')}/node?state=${request.revocationOpts.issuerState}`
-                        : `${credentialStatus.id.replace(/\/$/, '')}`
-                };
-            case CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023: {
-                const issuerId = DID.idFromDID(issuer);
-                const chainId = getChainId(DID.blockchainFromId(issuerId), DID.networkIdFromId(issuerId));
-                const searchParams = [
-                    ['revocationNonce', request.revocationOpts.nonce?.toString() || ''],
-                    ['contractAddress', `${chainId}:${request.revocationOpts.id}`],
-                    ['state', request.revocationOpts.issuerState || '']
-                ]
-                    .filter(([, value]) => Boolean(value))
-                    .map(([key, value]) => `${key}=${value}`)
-                    .join('&');
-                return {
-                    ...credentialStatus,
-                    // `[did]:[methodid]:[chain]:[network]:[id]/credentialStatus?(revocationNonce=value)&[contractAddress=[chainID]:[contractAddress]]&(state=issuerState)`
-                    id: `${issuer.string()}/credentialStatus?${searchParams}`
-                };
-            }
-            default:
-                return credentialStatus;
-        }
-    }
     /**
      * {@inheritDoc ICredentialWallet.findById}
      */
@@ -58520,10 +60651,34 @@ class FetchHandler extends AbstractMessageHandler {
                 return this.handleFetchRequest(message);
             case PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE:
                 return this.handleIssuanceResponseMsg(message);
+            case PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: {
+                const result = await this.handleOnchainOfferMessage(message);
+                if (Array.isArray(result)) {
+                    const credWallet = this.opts?.credentialWallet;
+                    if (!credWallet)
+                        throw new Error('Credential wallet is not provided');
+                    await credWallet.saveAll(result);
+                    return null;
+                }
+                return result;
+            }
             default:
                 return super.handle(message, ctx);
         }
     }
+    async handleOnchainOfferMessage(offerMessage) {
+        if (!this.opts?.onchainIssuer) {
+            throw new Error('onchain issuer is not provided');
+        }
+        const credentials = [];
+        for (const credentialInfo of offerMessage.body.credentials) {
+            const issuerDID = DID.parse(offerMessage.from);
+            const userDID = DID.parse(offerMessage.to);
+            const credential = await this.opts.onchainIssuer.getCredential(issuerDID, userDID, BigInt(credentialInfo.id));
+            credentials.push(credential);
+        }
+        return credentials;
+    }
     async handleOfferMessage(offerMessage, ctx) {
         if (!ctx.mediaType) {
             ctx.mediaType = MediaType.ZKPMessage;
@@ -58608,6 +60763,14 @@ class FetchHandler extends AbstractMessageHandler {
         }
         throw new Error('invalid protocol message response');
     }
+    /**
+     * Handles only messages with credentials/1.0/onchain-offer type
+     * @beta
+     */
+    async handleOnchainOffer(offer) {
+        const offerMessage = await FetchHandler.unpackMessage(this._packerMgr, offer, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE);
+        return this.handleOnchainOfferMessage(offerMessage);
+    }
     async handleFetchRequest(msgRequest) {
         if (!msgRequest.to) {
             throw new Error("failed request. empty 'to' field");
@@ -58710,6 +60873,7 @@ class ContractRequestHandler extends AbstractMessageHandler {
         this._proofService = _proofService;
         this._zkpVerifier = _zkpVerifier;
         this._supportedCircuits = [
+            CircuitId.AuthV2,
             CircuitId.AtomicQueryMTPV2OnChain,
             CircuitId.AtomicQuerySigV2OnChain,
             CircuitId.AtomicQueryV3OnChain
@@ -58740,7 +60904,12 @@ class ContractRequestHandler extends AbstractMessageHandler {
             throw new Error(`Invalid chain id ${chain_id}`);
         }
         const verifierDid = message.from ? DID.parse(message.from) : undefined;
-        const zkpResponses = await processZeroKnowledgeProofRequests(did, message?.body?.scope, verifierDid, this._proofService, { ethSigner, challenge, supportedCircuits: this._supportedCircuits });
+        const { scope = [] } = message.body;
+        const zkpResponses = await processZeroKnowledgeProofRequests(did, scope, verifierDid, this._proofService, {
+            ethSigner,
+            challenge,
+            supportedCircuits: this._supportedCircuits
+        });
         const methodId = message.body.transaction_data.method_id.replace('0x', '');
         switch (methodId) {
             case FunctionSignatures.SubmitZKPResponseV2:
@@ -59265,7 +61434,7 @@ async function verifyEIP712TypedData(data, resolver) {
         ? {
             recipient: data.recipient,
             amount: data.amount,
-            expirationDate: new Date(data.expirationDate).getTime(),
+            expirationDate: getUnixTimestamp(new Date(data.expirationDate)),
             nonce: data.nonce,
             metadata: '0x'
         }
@@ -59273,7 +61442,7 @@ async function verifyEIP712TypedData(data, resolver) {
             tokenAddress: data.tokenAddress,
             recipient: data.recipient,
             amount: data.amount,
-            expirationDate: new Date(data.expirationDate).getTime(),
+            expirationDate: getUnixTimestamp(new Date(data.expirationDate)),
             nonce: data.nonce,
             metadata: '0x'
         };
@@ -59482,37 +61651,39 @@ class PaymentHandler extends AbstractMessageHandler {
         for (let i = 0; i < payments.length; i++) {
             const { credentials, description } = payments[i];
             const dataArr = [];
-            for (let j = 0; j < payments[i].chains.length; j++) {
-                const { features, nonce, amount, currency, chainId, expirationDate, type } = payments[i].chains[j];
+            for (let j = 0; j < payments[i].options.length; j++) {
+                const { nonce, amount, chainId, optionId, expirationDate } = payments[i].options[j];
                 const multiChainConfig = this._params.multiChainPaymentConfig?.find((c) => c.chainId === chainId);
                 if (!multiChainConfig) {
                     throw new Error(`failed request. no config for chain ${chainId}`);
                 }
-                const { recipient, paymentContract, erc20TokenAddressArr } = multiChainConfig;
-                const tokenAddress = erc20TokenAddressArr.find((t) => t.symbol === currency)?.address;
-                if (type === PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1 && !tokenAddress) {
-                    throw new Error(`failed request. no token address for currency ${currency}`);
+                const { recipient, paymentRails, options } = multiChainConfig;
+                const option = options.find((t) => t.id === optionId);
+                if (!option) {
+                    throw new Error(`failed request. no option for id ${optionId}`);
                 }
-                const expirationTime = expirationDate
-                    ? new Date(expirationDate).getTime()
-                    : new Date(new Date().setHours(new Date().getHours() + 1)).getTime();
-                const typeUrl = `https://schema.iden3.io/core/json/${type}.json`;
+                if (option.type === PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1 &&
+                    !option.contractAddress) {
+                    throw new Error(`failed request. no token address for option id ${optionId}`);
+                }
+                const expirationDateRequired = expirationDate ?? new Date(new Date().setHours(new Date().getHours() + 1));
+                const typeUrl = `https://schema.iden3.io/core/json/${option.type}.json`;
                 const typesFetchResult = await fetch(typeUrl);
                 const types = await typesFetchResult.json();
                 delete types.EIP712Domain;
-                const paymentData = type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                const paymentData = option.type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
                     ? {
                         recipient,
-                        amount,
-                        expirationDate: expirationTime,
+                        amount: amount,
+                        expirationDate: getUnixTimestamp(expirationDateRequired),
                         nonce,
                         metadata: '0x'
                     }
                     : {
-                        tokenAddress,
+                        tokenAddress: option.contractAddress,
                         recipient,
-                        amount,
-                        expirationDate: expirationTime,
+                        amount: amount,
+                        expirationDate: getUnixTimestamp(expirationDateRequired),
                         nonce,
                         metadata: '0x'
                     };
@@ -59520,7 +61691,7 @@ class PaymentHandler extends AbstractMessageHandler {
                     name: 'MCPayment',
                     version: '1.0.0',
                     chainId,
-                    verifyingContract: paymentContract
+                    verifyingContract: paymentRails
                 };
                 const signature = await signer.signTypedData(domain, types, paymentData);
                 const proof = [
@@ -59540,20 +61711,24 @@ class PaymentHandler extends AbstractMessageHandler {
                 const d = {
                     type: PaymentRequestDataType.Iden3PaymentRailsRequestV1,
                     '@context': [
-                        `https://schema.iden3.io/core/jsonld/payment.jsonld#${type}`,
+                        `https://schema.iden3.io/core/jsonld/payment.jsonld#${option.type}`,
                         'https://w3id.org/security/suites/eip712sig-2021/v1'
                     ],
                     recipient,
                     amount: amount.toString(),
-                    currency,
-                    expirationDate: new Date(expirationTime).toISOString(),
+                    expirationDate: expirationDateRequired.toISOString(),
                     nonce: nonce.toString(),
                     metadata: '0x',
                     proof
                 };
-                dataArr.push(type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                dataArr.push(option.type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
                     ? d
-                    : { ...d, type, tokenAddress: tokenAddress || '', features: features || [] });
+                    : {
+                        ...d,
+                        type: option.type,
+                        tokenAddress: option.contractAddress || '',
+                        features: option.features || []
+                    });
             }
             paymentRequestInfo.push({
                 data: dataArr,
@@ -60908,6 +63083,12 @@ class ProofService {
         authInputs.gistProof = gistProof;
         return authInputs.inputsMarshal();
     }
+    /** {@inheritdoc IProofService.generateAuthV2Proof} */
+    async generateAuthV2Proof(challenge, did) {
+        const authInputs = await this.generateAuthV2Inputs(challenge, did, CircuitId.AuthV2);
+        const zkProof = await this._prover.generate(authInputs, CircuitId.AuthV2);
+        return zkProof;
+    }
     async verifyState(circuitId, pubSignals, opts = {
         acceptedStateTransitionDelay: DEFAULT_AUTH_VERIFY_DELAY
     }) {
@@ -61672,5 +63853,5 @@ class IdentityWallet {
     }
 }
 
-export { AbstractMessageHandler, AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DIDDocumentSignature, DataPrepareHandlerFunc, 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, 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, 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, calculateCoreSchemaHash, calculateQueryHashV2, calculateQueryHashV3, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createPayment, createPaymentRequest, 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, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getPermitSignature, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$3 as hexToBytes, isEthereumIdentity, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, parseAcceptProfile, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolveDidDocument, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, 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, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DIDDocumentSignature, DataPrepareHandlerFunc, DidDocumentCredentialStatusResolver, DidResolverStateReadonlyStorage, 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, 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, calculateCoreSchemaHash, calculateQueryHashV2, calculateQueryHashV3, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createPayment, createPaymentRequest, 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, parseAcceptProfile, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolveDidDocument, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyEIP712TypedData, verifyExpiresTime, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
 //# sourceMappingURL=index.js.map