@0xpolygonid/js-sdk 1.23.0 → 1.25.1

package/dist/browser/umd/index.js

@@ -1396,7 +1396,7 @@ var PolygonIdSdk = (function (exports) {
         }
     };
     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()}`;
         }
@@ -1412,11 +1412,11 @@ var PolygonIdSdk = (function (exports) {
         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) {
@@ -1428,9 +1428,14 @@ var PolygonIdSdk = (function (exports) {
         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
@@ -7872,6 +7877,7 @@ var PolygonIdSdk = (function (exports) {
     /**
      * Media types for Payment supported currencies
      * @beta
+     * @deprecated
      * @enum {string}
      */
     exports.SupportedCurrencies = void 0;
@@ -7880,8 +7886,7 @@ var PolygonIdSdk = (function (exports) {
         SupportedCurrencies["ETH_WEI"] = "ETHWEI";
         SupportedCurrencies["ETH_GWEI"] = "ETHGWEI";
         SupportedCurrencies["MATIC"] = "MATIC";
-        SupportedCurrencies["USDT"] = "USDT";
-        SupportedCurrencies["USDC"] = "USDC";
+        SupportedCurrencies["POL"] = "POL";
     })(exports.SupportedCurrencies || (exports.SupportedCurrencies = {}));
     /**
      * Supported features for payment-request
@@ -20038,6 +20043,92 @@ var PolygonIdSdk = (function (exports) {
             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 exports.CredentialStatusType.SparseMerkleTreeProof:
+                    return {
+                        ...credentialStatus,
+                        id: `${credentialStatus.id.replace(/\/$/, '')}/${credentialStatus.revocationNonce}`
+                    };
+                case exports.CredentialStatusType.Iden3ReverseSparseMerkleTreeProof:
+                    return {
+                        ...credentialStatus,
+                        id: request.revocationOpts.issuerState
+                            ? `${credentialStatus.id.replace(/\/$/, '')}/node?state=${request.revocationOpts.issuerState}`
+                            : `${credentialStatus.id.replace(/\/$/, '')}`
+                    };
+                case exports.CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023: {
+                    const issuerId = Q$2.idFromDID(issuer);
+                    const chainId = et$2(Q$2.blockchainFromId(issuerId), Q$2.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,
@@ -51282,6 +51373,12 @@ var PolygonIdSdk = (function (exports) {
             this.GISTRoot = V$1.fromString(sVals[2]);
             return this;
         }
+        getStatesInfo() {
+            return {
+                states: [],
+                gists: [{ id: this.userID, root: this.GISTRoot }]
+            };
+        }
     }
 
     /**
@@ -53598,23 +53695,8 @@ var PolygonIdSdk = (function (exports) {
         constructor(_configs, _opts) {
             this._configs = _configs;
             this._opts = _opts;
-            /**
-             * supported circuits
-             */
-            this._supportedCircuits = [
-                exports.CircuitId.AtomicQueryMTPV2OnChain,
-                exports.CircuitId.AtomicQuerySigV2OnChain,
-                exports.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', '') !== exports.FunctionSignatures.SubmitZKPResponseV1) {
                 throw new Error(`prepareTxArgsSubmitV1 function doesn't implement requested method id. Only '0x${exports.FunctionSignatures.SubmitZKPResponseV1}' is supported.`);
             }
@@ -53632,6 +53714,12 @@ var PolygonIdSdk = (function (exports) {
             ];
             return payload;
         }
+        /**
+         * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
+         */
+        async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+            return OnChainZKPVerifier.prepareTxArgsSubmitV1(txData, zkProofResponse);
+        }
         /**
          * {@inheritDoc IOnChainZKPVerifier.submitZKPResponse}
          */
@@ -53721,55 +53809,60 @@ var PolygonIdSdk = (function (exports) {
             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 = $$1.fromString(info.id);
+                const chainId = rt$2(Q$2.parseFromId(id));
+                if (txDataChainId === chainId) {
+                    return acc;
+                }
+                const promise = this.resolveDidDocumentEip712MessageAndSignature(Q$2.parseFromId($$1.fromString(info.id)), didResolverUrl, {
+                    [type]: V$1.fromString(info[type])
+                });
+                return [...acc, promise];
+            }, []);
+        }
+        static async prepareTxArgsSubmitV2(resolverUrl, txData, zkProofResponses) {
             if (txData.method_id.replace('0x', '') !== exports.FunctionSignatures.SubmitZKPResponseV2) {
                 throw new Error(`submit cross chain doesn't implement requested method id. Only '0x${exports.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(Q$2.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(Q$2.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) {
@@ -53785,20 +53878,28 @@ var PolygonIdSdk = (function (exports) {
                         });
                     }
                 }
-                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({
@@ -53812,10 +53913,10 @@ var PolygonIdSdk = (function (exports) {
                     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,' +
@@ -53827,8 +53928,8 @@ var PolygonIdSdk = (function (exports) {
                     ')'
             ], [msg]);
         }
-        packIdentityStateMsg(msg) {
-            return this._abiCoder.encode([
+        static packIdentityStateMsg(msg) {
+            return new AbiCoder().encode([
                 'tuple(' +
                     'tuple(' +
                     'uint256 timestamp,' +
@@ -53840,27 +53941,20 @@ var PolygonIdSdk = (function (exports) {
                     ')'
             ], [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 exports.CircuitId.AtomicQueryMTPV2OnChain:
-                    atomicQueryPubSignals = new AtomicQueryMTPV2OnChainPubSignals();
-                    break;
-                case exports.CircuitId.AtomicQuerySigV2OnChain:
-                    atomicQueryPubSignals = new AtomicQuerySigV2OnChainPubSignals();
-                    break;
-                case exports.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: exports.DIDDocumentSignature.EthereumEip712Signature2021
@@ -53893,6 +53987,21 @@ var PolygonIdSdk = (function (exports) {
             };
         }
     }
+    /**
+     * supported circuits
+     */
+    OnChainZKPVerifier._supportedCircuits = [
+        exports.CircuitId.AuthV2,
+        exports.CircuitId.AtomicQueryMTPV2OnChain,
+        exports.CircuitId.AtomicQuerySigV2OnChain,
+        exports.CircuitId.AtomicQueryV3OnChain
+    ];
+    OnChainZKPVerifier._supportedCircuitsPubSignalsMap = {
+        [exports.CircuitId.AtomicQueryMTPV2OnChain]: AtomicQueryMTPV2OnChainPubSignals,
+        [exports.CircuitId.AtomicQuerySigV2OnChain]: AtomicQuerySigV2OnChainPubSignals,
+        [exports.CircuitId.AtomicQueryV3OnChain]: AtomicQueryV3OnChainPubSignals,
+        [exports.CircuitId.AuthV2]: AuthV2PubSignals
+    };
 
     var abi$1 = [
     	{
@@ -54266,31 +54375,2279 @@ var PolygonIdSdk = (function (exports) {
     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($$1.ethAddressFromId(Q$2.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 P$2().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: exports.CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023
+                },
+                issuanceDate: p$3(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 lf.newTypeFromContext(contractContextsStr, `${credentialType}.${f.key}`, this._merklizationOptions);
+                switch (dataType) {
+                    case exports.XSDNS.Boolean: {
+                        switch (f.rawValue.toString()) {
+                            case ValueHashes.BooleanTrue:
+                                credentialSubject[f.key] = true;
+                                break;
+                            case ValueHashes.BooleanFalse:
+                                credentialSubject[f.key] = false;
+                                break;
+                        }
+                        break;
+                    }
+                    case (exports.XSDNS.PositiveInteger):
+                        {
+                            credentialSubject[f.key] = f.value.toString();
+                            break;
+                        }
+                    case exports.XSDNS.Integer: {
+                        credentialSubject[f.key] = Number(f.value);
+                        break;
+                    }
+                    case exports.XSDNS.String: {
+                        this.validateSourceValue(dataType, f.value, f.rawValue);
+                        credentialSubject[f.key] = f.rawValue;
+                        break;
+                    }
+                    case exports.XSDNS.DateTime: {
+                        const timestamp = BigInt(f.rawValue);
+                        const sourceTimestamp = p$3(Number(timestamp)).toISOString();
+                        this.validateSourceValue(dataType, f.value, sourceTimestamp);
+                        credentialSubject[f.key] = sourceTimestamp;
+                        break;
+                    }
+                    case exports.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 = Q$2.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 = V$1.fromBigInt(stateInfo.state);
+            const latestClaimsOfRootHash = V$1.fromBigInt(stateInfo.claimsRoot);
+            const latestRevocationOfRootHash = V$1.fromBigInt(stateInfo.revocationsRoot);
+            const latestRootsOfRootHash = V$1.fromBigInt(stateInfo.rootsRoot);
+            const p = new Kt$1({
+                siblings: mtpProof.siblings.map((s) => V$1.fromBigInt(s)),
+                existence: mtpProof.existence,
+                nodeAux: mtpProof.auxExistence
+                    ? {
+                        key: V$1.fromBigInt(mtpProof.auxIndex),
+                        value: V$1.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 ff.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 exports.DisplayMethodType.Iden3BasicDisplayMethodV1: {
+                    return {
+                        id: onchainDisplayMethod.id,
+                        type: exports.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(Q$2.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(Q$2.idFromDID(userDID));
+                }
+                default:
+                    throw new Error(`Unsupported adapter version ${response}`);
+            }
+        }
+        getContractConnection(did) {
+            const issuerId = Q$2.idFromDID(did);
+            const chainId = rt$2(did);
+            const contractAddress = getAddress(hexlify($$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(Q$2.parseFromId($$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(Q$2.parseFromId($$1.fromBigInt(userId)), this.resolverUrl, {
+                gist: V$1.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: V$1.fromBigInt(state) } : undefined;
+            const { didDocument } = await resolveDidDocument(Q$2.parseFromId($$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: [
@@ -54378,66 +56735,6 @@ var PolygonIdSdk = (function (exports) {
     		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: [
@@ -54463,13 +56760,6 @@ var PolygonIdSdk = (function (exports) {
     		name: "Approval",
     		type: "event"
     	},
-    	{
-    		anonymous: false,
-    		inputs: [
-    		],
-    		name: "EIP712DomainChanged",
-    		type: "event"
-    	},
     	{
     		anonymous: false,
     		inputs: [
@@ -54495,20 +56785,6 @@ var PolygonIdSdk = (function (exports) {
     		name: "Transfer",
     		type: "event"
     	},
-    	{
-    		inputs: [
-    		],
-    		name: "DOMAIN_SEPARATOR",
-    		outputs: [
-    			{
-    				internalType: "bytes32",
-    				name: "",
-    				type: "bytes32"
-    			}
-    		],
-    		stateMutability: "view",
-    		type: "function"
-    	},
     	{
     		inputs: [
     			{
@@ -54590,50 +56866,6 @@ var PolygonIdSdk = (function (exports) {
     		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: [
     		],
@@ -54648,69 +56880,6 @@ var PolygonIdSdk = (function (exports) {
     		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: [
     		],
@@ -54805,10 +56974,11 @@ var PolygonIdSdk = (function (exports) {
      * @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
@@ -54831,6 +57001,16 @@ var PolygonIdSdk = (function (exports) {
         };
         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
@@ -56509,6 +58689,24 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
+    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,
@@ -56535,40 +58733,18 @@ var PolygonIdSdk = (function (exports) {
                 if (!schema.$metadata.uris['jsonLdContext']) {
                     throw new Error('jsonLdContext is missing is the schema');
                 }
-                request.context = request.context ?? [];
-                if (request.displayMethod?.type === exports.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 === exports.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
@@ -56638,51 +58814,6 @@ var PolygonIdSdk = (function (exports) {
             }
             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 exports.CredentialStatusType.SparseMerkleTreeProof:
-                    return {
-                        ...credentialStatus,
-                        id: `${credentialStatus.id.replace(/\/$/, '')}/${credentialStatus.revocationNonce}`
-                    };
-                case exports.CredentialStatusType.Iden3ReverseSparseMerkleTreeProof:
-                    return {
-                        ...credentialStatus,
-                        id: request.revocationOpts.issuerState
-                            ? `${credentialStatus.id.replace(/\/$/, '')}/node?state=${request.revocationOpts.issuerState}`
-                            : `${credentialStatus.id.replace(/\/$/, '')}`
-                    };
-                case exports.CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023: {
-                    const issuerId = Q$2.idFromDID(issuer);
-                    const chainId = et$2(Q$2.blockchainFromId(issuerId), Q$2.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}
          */
@@ -79402,10 +81533,34 @@ var PolygonIdSdk = (function (exports) {
                     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 = Q$2.parse(offerMessage.from);
+                const userDID = Q$2.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;
@@ -79490,6 +81645,14 @@ var PolygonIdSdk = (function (exports) {
             }
             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");
@@ -79592,6 +81755,7 @@ var PolygonIdSdk = (function (exports) {
             this._proofService = _proofService;
             this._zkpVerifier = _zkpVerifier;
             this._supportedCircuits = [
+                exports.CircuitId.AuthV2,
                 exports.CircuitId.AtomicQueryMTPV2OnChain,
                 exports.CircuitId.AtomicQuerySigV2OnChain,
                 exports.CircuitId.AtomicQueryV3OnChain
@@ -79622,7 +81786,12 @@ var PolygonIdSdk = (function (exports) {
                 throw new Error(`Invalid chain id ${chain_id}`);
             }
             const verifierDid = message.from ? Q$2.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 exports.FunctionSignatures.SubmitZKPResponseV2:
@@ -80147,7 +82316,7 @@ var PolygonIdSdk = (function (exports) {
             ? {
                 recipient: data.recipient,
                 amount: data.amount,
-                expirationDate: new Date(data.expirationDate).getTime(),
+                expirationDate: b$4(new Date(data.expirationDate)),
                 nonce: data.nonce,
                 metadata: '0x'
             }
@@ -80155,7 +82324,7 @@ var PolygonIdSdk = (function (exports) {
                 tokenAddress: data.tokenAddress,
                 recipient: data.recipient,
                 amount: data.amount,
-                expirationDate: new Date(data.expirationDate).getTime(),
+                expirationDate: b$4(new Date(data.expirationDate)),
                 nonce: data.nonce,
                 metadata: '0x'
             };
@@ -80364,37 +82533,39 @@ var PolygonIdSdk = (function (exports) {
             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 === exports.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 === exports.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 === exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                    const paymentData = option.type === exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1
                         ? {
                             recipient,
-                            amount,
-                            expirationDate: expirationTime,
+                            amount: amount,
+                            expirationDate: b$4(expirationDateRequired),
                             nonce,
                             metadata: '0x'
                         }
                         : {
-                            tokenAddress,
+                            tokenAddress: option.contractAddress,
                             recipient,
-                            amount,
-                            expirationDate: expirationTime,
+                            amount: amount,
+                            expirationDate: b$4(expirationDateRequired),
                             nonce,
                             metadata: '0x'
                         };
@@ -80402,7 +82573,7 @@ var PolygonIdSdk = (function (exports) {
                         name: 'MCPayment',
                         version: '1.0.0',
                         chainId,
-                        verifyingContract: paymentContract
+                        verifyingContract: paymentRails
                     };
                     const signature = await signer.signTypedData(domain, types, paymentData);
                     const proof = [
@@ -80422,20 +82593,24 @@ var PolygonIdSdk = (function (exports) {
                     const d = {
                         type: exports.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 === exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                    dataArr.push(option.type === exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1
                         ? d
-                        : { ...d, type, tokenAddress: tokenAddress || '', features: features || [] });
+                        : {
+                            ...d,
+                            type: option.type,
+                            tokenAddress: option.contractAddress || '',
+                            features: option.features || []
+                        });
                 }
                 paymentRequestInfo.push({
                     data: dataArr,
@@ -81790,6 +83965,12 @@ var PolygonIdSdk = (function (exports) {
             authInputs.gistProof = gistProof;
             return authInputs.inputsMarshal();
         }
+        /** {@inheritdoc IProofService.generateAuthV2Proof} */
+        async generateAuthV2Proof(challenge, did) {
+            const authInputs = await this.generateAuthV2Inputs(challenge, did, exports.CircuitId.AuthV2);
+            const zkProof = await this._prover.generate(authInputs, exports.CircuitId.AuthV2);
+            return zkProof;
+        }
         async verifyState(circuitId, pubSignals, opts = {
             acceptedStateTransitionDelay: DEFAULT_AUTH_VERIFY_DELAY
         }) {
@@ -82587,6 +84768,8 @@ var PolygonIdSdk = (function (exports) {
     exports.CredentialWallet = CredentialWallet;
     exports.DIDDocumentJSONSchema = DIDDocumentJSONSchema;
     exports.DataPrepareHandlerFunc = DataPrepareHandlerFunc;
+    exports.DidDocumentCredentialStatusResolver = DidDocumentCredentialStatusResolver;
+    exports.DidResolverStateReadonlyStorage = DidResolverStateReadonlyStorage;
     exports.Ed25519Provider = Ed25519Provider;
     exports.ErrorEmptyAuthClaimNonRevProof = ErrorEmptyAuthClaimNonRevProof;
     exports.ErrorEmptyAuthClaimProof = ErrorEmptyAuthClaimProof;
@@ -82629,6 +84812,7 @@ var PolygonIdSdk = (function (exports) {
     exports.OnChainResolver = OnChainResolver;
     exports.OnChainRevocationStorage = OnChainRevocationStorage;
     exports.OnChainZKPVerifier = OnChainZKPVerifier;
+    exports.OnchainIssuer = OnchainIssuer;
     exports.PROTOCOL_CONSTANTS = constants;
     exports.PackageManager = PackageManager;
     exports.Parser = Parser;
@@ -82712,6 +84896,7 @@ var PolygonIdSdk = (function (exports) {
     exports.findCredentialType = findCredentialType;
     exports.findValue = findValue;
     exports.generateProfileDID = generateProfileDID;
+    exports.getERC20Decimals = getERC20Decimals;
     exports.getFieldSlotIndex = getFieldSlotIndex;
     exports.getKMSIdByAuthCredential = getKMSIdByAuthCredential;
     exports.getNodeAuxValue = getNodeAuxValue;