@0xpolygonid/js-sdk 1.23.0 → 1.24.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) {
@@ -5451,7 +5451,7 @@ var PolygonIdSdk = (function (exports) {
       throw new Error('Unknown type, must be binary type');
     };
     const fromString$2 = str => new TextEncoder().encode(str);
-    const toString$7 = b => new TextDecoder().decode(b);
+    const toString$8 = b => new TextDecoder().decode(b);
 
     class Encoder {
       constructor(name, prefix, baseEncode) {
@@ -5608,7 +5608,7 @@ var PolygonIdSdk = (function (exports) {
     const identity$1 = from({
       prefix: '\0',
       name: 'identity',
-      encode: buf => toString$7(buf),
+      encode: buf => toString$8(buf),
       decode: str => fromString$2(str)
     });
 
@@ -5972,7 +5972,7 @@ var PolygonIdSdk = (function (exports) {
       return base.decoder.decode(`${ base.prefix }${ string }`);
     }
 
-    function toString$6(array, encoding = 'utf8') {
+    function toString$7(array, encoding = 'utf8') {
       const base = BASES[encoding];
       if (!base) {
         throw new Error(`Unsupported encoding "${ encoding }"`);
@@ -6366,19 +6366,19 @@ var PolygonIdSdk = (function (exports) {
     ];
 
     /** @type {Record<BaseName,Base>} */
-    const names$1 = constants$2.reduce((prev, tupple) => {
+    const names$2 = constants$2.reduce((prev, tupple) => {
       prev[tupple[0]] = new Base(tupple[0], tupple[1], tupple[2], tupple[3]);
       return prev
     }, /** @type {Record<BaseName,Base>} */({}));
 
     /** @type {Record<BaseCode,Base>} */
     const codes$1 = constants$2.reduce((prev, tupple) => {
-      prev[tupple[1]] = names$1[tupple[0]];
+      prev[tupple[1]] = names$2[tupple[0]];
       return prev
     }, /** @type {Record<BaseCode,Base>} */({}));
 
     var constants_1 = {
-      names: names$1,
+      names: names$2,
       codes: codes$1
     };
 
@@ -7150,7 +7150,7 @@ var PolygonIdSdk = (function (exports) {
     const bech32 = /* @__PURE__ */ genBech32('bech32');
 
     const u8a$2 = {
-      toString: toString$6,
+      toString: toString$7,
       fromString: fromString$1,
       concat: concat$2
     };
@@ -7348,7 +7348,7 @@ var PolygonIdSdk = (function (exports) {
     const keccak = keccak_256$1;
     function toEthereumAddress(hexPublicKey) {
       const hashInput = fromString$1(hexPublicKey.slice(2), 'base16');
-      return `0x${toString$6(keccak(hashInput).slice(-20), 'base16')}`;
+      return `0x${toString$7(keccak(hashInput).slice(-20), 'base16')}`;
     }
 
     /**
@@ -7880,6 +7880,7 @@ var PolygonIdSdk = (function (exports) {
         SupportedCurrencies["ETH_WEI"] = "ETHWEI";
         SupportedCurrencies["ETH_GWEI"] = "ETHGWEI";
         SupportedCurrencies["MATIC"] = "MATIC";
+        SupportedCurrencies["POL"] = "POL";
         SupportedCurrencies["USDT"] = "USDT";
         SupportedCurrencies["USDC"] = "USDC";
     })(exports.SupportedCurrencies || (exports.SupportedCurrencies = {}));
@@ -20038,6 +20039,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,
@@ -22414,16 +22501,16 @@ var PolygonIdSdk = (function (exports) {
     	
     } (util));
 
-    var names = {};
+    var names$1 = {};
 
     var hasRequiredNames;
 
     function requireNames () {
-    	if (hasRequiredNames) return names;
+    	if (hasRequiredNames) return names$1;
     	hasRequiredNames = 1;
-    	Object.defineProperty(names, "__esModule", { value: true });
+    	Object.defineProperty(names$1, "__esModule", { value: true });
     	const codegen_1 = requireCodegen();
-    	const names$1 = {
+    	const names = {
     	    // validation function arguments
     	    data: new codegen_1.Name("data"),
     	    // args passed from referencing schema
@@ -22446,9 +22533,9 @@ var PolygonIdSdk = (function (exports) {
     	    jsonLen: new codegen_1.Name("jsonLen"),
     	    jsonPart: new codegen_1.Name("jsonPart"),
     	};
-    	names.default = names$1;
+    	names$1.default = names;
     	
-    	return names;
+    	return names$1;
     }
 
     var hasRequiredErrors;
@@ -30882,8 +30969,8 @@ var PolygonIdSdk = (function (exports) {
      *
      *  @_subsection: api/utils:Math Helpers  [about-maths]
      */
-    const BN_0$8 = BigInt(0);
-    const BN_1$3 = BigInt(1);
+    const BN_0$9 = BigInt(0);
+    const BN_1$4 = BigInt(1);
     //const BN_Max256 = (BN_1 << BigInt(256)) - BN_1;
     // IEEE 754 support 53-bits of mantissa
     const maxValue = 0x1fffffffffffff;
@@ -30896,13 +30983,13 @@ var PolygonIdSdk = (function (exports) {
     function fromTwos(_value, _width) {
         const value = getUint(_value, "value");
         const width = BigInt(getNumber(_width, "width"));
-        assert$2((value >> width) === BN_0$8, "overflow", "NUMERIC_FAULT", {
+        assert$2((value >> width) === BN_0$9, "overflow", "NUMERIC_FAULT", {
             operation: "fromTwos", fault: "overflow", value: _value
         });
         // Top bit set; treat as a negative value
-        if (value >> (width - BN_1$3)) {
-            const mask = (BN_1$3 << width) - BN_1$3;
-            return -(((~value) & mask) + BN_1$3);
+        if (value >> (width - BN_1$4)) {
+            const mask = (BN_1$4 << width) - BN_1$4;
+            return -(((~value) & mask) + BN_1$4);
         }
         return value;
     }
@@ -30915,14 +31002,14 @@ var PolygonIdSdk = (function (exports) {
     function toTwos(_value, _width) {
         let value = getBigInt(_value, "value");
         const width = BigInt(getNumber(_width, "width"));
-        const limit = (BN_1$3 << (width - BN_1$3));
-        if (value < BN_0$8) {
+        const limit = (BN_1$4 << (width - BN_1$4));
+        if (value < BN_0$9) {
             value = -value;
             assert$2(value <= limit, "too low", "NUMERIC_FAULT", {
                 operation: "toTwos", fault: "overflow", value: _value
             });
-            const mask = (BN_1$3 << width) - BN_1$3;
-            return ((~value) & mask) + BN_1$3;
+            const mask = (BN_1$4 << width) - BN_1$4;
+            return ((~value) & mask) + BN_1$4;
         }
         else {
             assert$2(value < limit, "too high", "NUMERIC_FAULT", {
@@ -30937,7 +31024,7 @@ var PolygonIdSdk = (function (exports) {
     function mask(_value, _bits) {
         const value = getUint(_value, "value");
         const bits = BigInt(getNumber(_bits, "bits"));
-        return value & ((BN_1$3 << bits) - BN_1$3);
+        return value & ((BN_1$4 << bits) - BN_1$4);
     }
     /**
      *  Gets a BigInt from %%value%%. If it is an invalid value for
@@ -30972,7 +31059,7 @@ var PolygonIdSdk = (function (exports) {
      */
     function getUint(value, name) {
         const result = getBigInt(value, name);
-        assert$2(result >= BN_0$8, "unsigned value cannot be negative", "NUMERIC_FAULT", {
+        assert$2(result >= BN_0$9, "unsigned value cannot be negative", "NUMERIC_FAULT", {
             fault: "overflow", operation: "getUint", value
         });
         return result;
@@ -31058,7 +31145,7 @@ var PolygonIdSdk = (function (exports) {
      */
     function toBeArray(_value) {
         const value = getUint(_value, "value");
-        if (value === BN_0$8) {
+        if (value === BN_0$9) {
             return new Uint8Array([]);
         }
         let hex = value.toString(16);
@@ -32290,6 +32377,526 @@ var PolygonIdSdk = (function (exports) {
         return new Promise((resolve) => setTimeout(resolve, delay));
     }
 
+    /**
+     *  The **FixedNumber** class permits using values with decimal places,
+     *  using fixed-pont math.
+     *
+     *  Fixed-point math is still based on integers under-the-hood, but uses an
+     *  internal offset to store fractional components below, and each operation
+     *  corrects for this after each operation.
+     *
+     *  @_section: api/utils/fixed-point-math:Fixed-Point Maths  [about-fixed-point-math]
+     */
+    const BN_N1 = BigInt(-1);
+    const BN_0$8 = BigInt(0);
+    const BN_1$3 = BigInt(1);
+    const BN_5 = BigInt(5);
+    const _guard$3 = {};
+    // Constant to pull zeros from for multipliers
+    let Zeros$1 = "0000";
+    while (Zeros$1.length < 80) {
+        Zeros$1 += Zeros$1;
+    }
+    // Returns a string "1" followed by decimal "0"s
+    function getTens(decimals) {
+        let result = Zeros$1;
+        while (result.length < decimals) {
+            result += result;
+        }
+        return BigInt("1" + result.substring(0, decimals));
+    }
+    function checkValue(val, format, safeOp) {
+        const width = BigInt(format.width);
+        if (format.signed) {
+            const limit = (BN_1$3 << (width - BN_1$3));
+            assert$2(safeOp == null || (val >= -limit && val < limit), "overflow", "NUMERIC_FAULT", {
+                operation: safeOp, fault: "overflow", value: val
+            });
+            if (val > BN_0$8) {
+                val = fromTwos(mask(val, width), width);
+            }
+            else {
+                val = -fromTwos(mask(-val, width), width);
+            }
+        }
+        else {
+            const limit = (BN_1$3 << width);
+            assert$2(safeOp == null || (val >= 0 && val < limit), "overflow", "NUMERIC_FAULT", {
+                operation: safeOp, fault: "overflow", value: val
+            });
+            val = (((val % limit) + limit) % limit) & (limit - BN_1$3);
+        }
+        return val;
+    }
+    function getFormat(value) {
+        if (typeof (value) === "number") {
+            value = `fixed128x${value}`;
+        }
+        let signed = true;
+        let width = 128;
+        let decimals = 18;
+        if (typeof (value) === "string") {
+            // Parse the format string
+            if (value === "fixed") ;
+            else if (value === "ufixed") {
+                signed = false;
+            }
+            else {
+                const match = value.match(/^(u?)fixed([0-9]+)x([0-9]+)$/);
+                assertArgument(match, "invalid fixed format", "format", value);
+                signed = (match[1] !== "u");
+                width = parseInt(match[2]);
+                decimals = parseInt(match[3]);
+            }
+        }
+        else if (value) {
+            // Extract the values from the object
+            const v = value;
+            const check = (key, type, defaultValue) => {
+                if (v[key] == null) {
+                    return defaultValue;
+                }
+                assertArgument(typeof (v[key]) === type, "invalid fixed format (" + key + " not " + type + ")", "format." + key, v[key]);
+                return v[key];
+            };
+            signed = check("signed", "boolean", signed);
+            width = check("width", "number", width);
+            decimals = check("decimals", "number", decimals);
+        }
+        assertArgument((width % 8) === 0, "invalid FixedNumber width (not byte aligned)", "format.width", width);
+        assertArgument(decimals <= 80, "invalid FixedNumber decimals (too large)", "format.decimals", decimals);
+        const name = (signed ? "" : "u") + "fixed" + String(width) + "x" + String(decimals);
+        return { signed, width, decimals, name };
+    }
+    function toString$6(val, decimals) {
+        let negative = "";
+        if (val < BN_0$8) {
+            negative = "-";
+            val *= BN_N1;
+        }
+        let str = val.toString();
+        // No decimal point for whole values
+        if (decimals === 0) {
+            return (negative + str);
+        }
+        // Pad out to the whole component (including a whole digit)
+        while (str.length <= decimals) {
+            str = Zeros$1 + str;
+        }
+        // Insert the decimal point
+        const index = str.length - decimals;
+        str = str.substring(0, index) + "." + str.substring(index);
+        // Trim the whole component (leaving at least one 0)
+        while (str[0] === "0" && str[1] !== ".") {
+            str = str.substring(1);
+        }
+        // Trim the decimal component (leaving at least one 0)
+        while (str[str.length - 1] === "0" && str[str.length - 2] !== ".") {
+            str = str.substring(0, str.length - 1);
+        }
+        return (negative + str);
+    }
+    /**
+     *  A FixedNumber represents a value over its [[FixedFormat]]
+     *  arithmetic field.
+     *
+     *  A FixedNumber can be used to perform math, losslessly, on
+     *  values which have decmial places.
+     *
+     *  A FixedNumber has a fixed bit-width to store values in, and stores all
+     *  values internally by multiplying the value by 10 raised to the power of
+     *  %%decimals%%.
+     *
+     *  If operations are performed that cause a value to grow too high (close to
+     *  positive infinity) or too low (close to negative infinity), the value
+     *  is said to //overflow//.
+     *
+     *  For example, an 8-bit signed value, with 0 decimals may only be within
+     *  the range ``-128`` to ``127``; so ``-128 - 1`` will overflow and become
+     *  ``127``. Likewise, ``127 + 1`` will overflow and become ``-127``.
+     *
+     *  Many operation have a normal and //unsafe// variant. The normal variant
+     *  will throw a [[NumericFaultError]] on any overflow, while the //unsafe//
+     *  variant will silently allow overflow, corrupting its value value.
+     *
+     *  If operations are performed that cause a value to become too small
+     *  (close to zero), the value loses precison and is said to //underflow//.
+     *
+     *  For example, an value with 1 decimal place may store a number as small
+     *  as ``0.1``, but the value of ``0.1 / 2`` is ``0.05``, which cannot fit
+     *  into 1 decimal place, so underflow occurs which means precision is lost
+     *  and the value becomes ``0``.
+     *
+     *  Some operations have a normal and //signalling// variant. The normal
+     *  variant will silently ignore underflow, while the //signalling// variant
+     *  will thow a [[NumericFaultError]] on underflow.
+     */
+    class FixedNumber {
+        /**
+         *  The specific fixed-point arithmetic field for this value.
+         */
+        format;
+        #format;
+        // The actual value (accounting for decimals)
+        #val;
+        // A base-10 value to multiple values by to maintain the magnitude
+        #tens;
+        /**
+         *  This is a property so console.log shows a human-meaningful value.
+         *
+         *  @private
+         */
+        _value;
+        // Use this when changing this file to get some typing info,
+        // but then switch to any to mask the internal type
+        //constructor(guard: any, value: bigint, format: _FixedFormat) {
+        /**
+         *  @private
+         */
+        constructor(guard, value, format) {
+            assertPrivate(guard, _guard$3, "FixedNumber");
+            this.#val = value;
+            this.#format = format;
+            const _value = toString$6(value, format.decimals);
+            defineProperties(this, { format: format.name, _value });
+            this.#tens = getTens(format.decimals);
+        }
+        /**
+         *  If true, negative values are permitted, otherwise only
+         *  positive values and zero are allowed.
+         */
+        get signed() { return this.#format.signed; }
+        /**
+         *  The number of bits available to store the value.
+         */
+        get width() { return this.#format.width; }
+        /**
+         *  The number of decimal places in the fixed-point arithment field.
+         */
+        get decimals() { return this.#format.decimals; }
+        /**
+         *  The value as an integer, based on the smallest unit the
+         *  [[decimals]] allow.
+         */
+        get value() { return this.#val; }
+        #checkFormat(other) {
+            assertArgument(this.format === other.format, "incompatible format; use fixedNumber.toFormat", "other", other);
+        }
+        #checkValue(val, safeOp) {
+            /*
+                    const width = BigInt(this.width);
+                    if (this.signed) {
+                        const limit = (BN_1 << (width - BN_1));
+                        assert(safeOp == null || (val >= -limit  && val < limit), "overflow", "NUMERIC_FAULT", {
+                            operation: <string>safeOp, fault: "overflow", value: val
+                        });
+            
+                        if (val > BN_0) {
+                            val = fromTwos(mask(val, width), width);
+                        } else {
+                            val = -fromTwos(mask(-val, width), width);
+                        }
+            
+                    } else {
+                        const masked = mask(val, width);
+                        assert(safeOp == null || (val >= 0 && val === masked), "overflow", "NUMERIC_FAULT", {
+                            operation: <string>safeOp, fault: "overflow", value: val
+                        });
+                        val = masked;
+                    }
+            */
+            val = checkValue(val, this.#format, safeOp);
+            return new FixedNumber(_guard$3, val, this.#format);
+        }
+        #add(o, safeOp) {
+            this.#checkFormat(o);
+            return this.#checkValue(this.#val + o.#val, safeOp);
+        }
+        /**
+         *  Returns a new [[FixedNumber]] with the result of %%this%% added
+         *  to %%other%%, ignoring overflow.
+         */
+        addUnsafe(other) { return this.#add(other); }
+        /**
+         *  Returns a new [[FixedNumber]] with the result of %%this%% added
+         *  to %%other%%. A [[NumericFaultError]] is thrown if overflow
+         *  occurs.
+         */
+        add(other) { return this.#add(other, "add"); }
+        #sub(o, safeOp) {
+            this.#checkFormat(o);
+            return this.#checkValue(this.#val - o.#val, safeOp);
+        }
+        /**
+         *  Returns a new [[FixedNumber]] with the result of %%other%% subtracted
+         *  from %%this%%, ignoring overflow.
+         */
+        subUnsafe(other) { return this.#sub(other); }
+        /**
+         *  Returns a new [[FixedNumber]] with the result of %%other%% subtracted
+         *  from %%this%%. A [[NumericFaultError]] is thrown if overflow
+         *  occurs.
+         */
+        sub(other) { return this.#sub(other, "sub"); }
+        #mul(o, safeOp) {
+            this.#checkFormat(o);
+            return this.#checkValue((this.#val * o.#val) / this.#tens, safeOp);
+        }
+        /**
+         *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
+         *  by %%other%%, ignoring overflow and underflow (precision loss).
+         */
+        mulUnsafe(other) { return this.#mul(other); }
+        /**
+         *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
+         *  by %%other%%. A [[NumericFaultError]] is thrown if overflow
+         *  occurs.
+         */
+        mul(other) { return this.#mul(other, "mul"); }
+        /**
+         *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
+         *  by %%other%%. A [[NumericFaultError]] is thrown if overflow
+         *  occurs or if underflow (precision loss) occurs.
+         */
+        mulSignal(other) {
+            this.#checkFormat(other);
+            const value = this.#val * other.#val;
+            assert$2((value % this.#tens) === BN_0$8, "precision lost during signalling mul", "NUMERIC_FAULT", {
+                operation: "mulSignal", fault: "underflow", value: this
+            });
+            return this.#checkValue(value / this.#tens, "mulSignal");
+        }
+        #div(o, safeOp) {
+            assert$2(o.#val !== BN_0$8, "division by zero", "NUMERIC_FAULT", {
+                operation: "div", fault: "divide-by-zero", value: this
+            });
+            this.#checkFormat(o);
+            return this.#checkValue((this.#val * this.#tens) / o.#val, safeOp);
+        }
+        /**
+         *  Returns a new [[FixedNumber]] with the result of %%this%% divided
+         *  by %%other%%, ignoring underflow (precision loss). A
+         *  [[NumericFaultError]] is thrown if overflow occurs.
+         */
+        divUnsafe(other) { return this.#div(other); }
+        /**
+         *  Returns a new [[FixedNumber]] with the result of %%this%% divided
+         *  by %%other%%, ignoring underflow (precision loss). A
+         *  [[NumericFaultError]] is thrown if overflow occurs.
+         */
+        div(other) { return this.#div(other, "div"); }
+        /**
+         *  Returns a new [[FixedNumber]] with the result of %%this%% divided
+         *  by %%other%%. A [[NumericFaultError]] is thrown if underflow
+         *  (precision loss) occurs.
+         */
+        divSignal(other) {
+            assert$2(other.#val !== BN_0$8, "division by zero", "NUMERIC_FAULT", {
+                operation: "div", fault: "divide-by-zero", value: this
+            });
+            this.#checkFormat(other);
+            const value = (this.#val * this.#tens);
+            assert$2((value % other.#val) === BN_0$8, "precision lost during signalling div", "NUMERIC_FAULT", {
+                operation: "divSignal", fault: "underflow", value: this
+            });
+            return this.#checkValue(value / other.#val, "divSignal");
+        }
+        /**
+         *  Returns a comparison result between %%this%% and %%other%%.
+         *
+         *  This is suitable for use in sorting, where ``-1`` implies %%this%%
+         *  is smaller, ``1`` implies %%this%% is larger and ``0`` implies
+         *  both are equal.
+         */
+        cmp(other) {
+            let a = this.value, b = other.value;
+            // Coerce a and b to the same magnitude
+            const delta = this.decimals - other.decimals;
+            if (delta > 0) {
+                b *= getTens(delta);
+            }
+            else if (delta < 0) {
+                a *= getTens(-delta);
+            }
+            // Comnpare
+            if (a < b) {
+                return -1;
+            }
+            if (a > b) {
+                return 1;
+            }
+            return 0;
+        }
+        /**
+         *  Returns true if %%other%% is equal to %%this%%.
+         */
+        eq(other) { return this.cmp(other) === 0; }
+        /**
+         *  Returns true if %%other%% is less than to %%this%%.
+         */
+        lt(other) { return this.cmp(other) < 0; }
+        /**
+         *  Returns true if %%other%% is less than or equal to %%this%%.
+         */
+        lte(other) { return this.cmp(other) <= 0; }
+        /**
+         *  Returns true if %%other%% is greater than to %%this%%.
+         */
+        gt(other) { return this.cmp(other) > 0; }
+        /**
+         *  Returns true if %%other%% is greater than or equal to %%this%%.
+         */
+        gte(other) { return this.cmp(other) >= 0; }
+        /**
+         *  Returns a new [[FixedNumber]] which is the largest **integer**
+         *  that is less than or equal to %%this%%.
+         *
+         *  The decimal component of the result will always be ``0``.
+         */
+        floor() {
+            let val = this.#val;
+            if (this.#val < BN_0$8) {
+                val -= this.#tens - BN_1$3;
+            }
+            val = (this.#val / this.#tens) * this.#tens;
+            return this.#checkValue(val, "floor");
+        }
+        /**
+         *  Returns a new [[FixedNumber]] which is the smallest **integer**
+         *  that is greater than or equal to %%this%%.
+         *
+         *  The decimal component of the result will always be ``0``.
+         */
+        ceiling() {
+            let val = this.#val;
+            if (this.#val > BN_0$8) {
+                val += this.#tens - BN_1$3;
+            }
+            val = (this.#val / this.#tens) * this.#tens;
+            return this.#checkValue(val, "ceiling");
+        }
+        /**
+         *  Returns a new [[FixedNumber]] with the decimal component
+         *  rounded up on ties at %%decimals%% places.
+         */
+        round(decimals) {
+            if (decimals == null) {
+                decimals = 0;
+            }
+            // Not enough precision to not already be rounded
+            if (decimals >= this.decimals) {
+                return this;
+            }
+            const delta = this.decimals - decimals;
+            const bump = BN_5 * getTens(delta - 1);
+            let value = this.value + bump;
+            const tens = getTens(delta);
+            value = (value / tens) * tens;
+            checkValue(value, this.#format, "round");
+            return new FixedNumber(_guard$3, value, this.#format);
+        }
+        /**
+         *  Returns true if %%this%% is equal to ``0``.
+         */
+        isZero() { return (this.#val === BN_0$8); }
+        /**
+         *  Returns true if %%this%% is less than ``0``.
+         */
+        isNegative() { return (this.#val < BN_0$8); }
+        /**
+         *  Returns the string representation of %%this%%.
+         */
+        toString() { return this._value; }
+        /**
+         *  Returns a float approximation.
+         *
+         *  Due to IEEE 754 precission (or lack thereof), this function
+         *  can only return an approximation and most values will contain
+         *  rounding errors.
+         */
+        toUnsafeFloat() { return parseFloat(this.toString()); }
+        /**
+         *  Return a new [[FixedNumber]] with the same value but has had
+         *  its field set to %%format%%.
+         *
+         *  This will throw if the value cannot fit into %%format%%.
+         */
+        toFormat(format) {
+            return FixedNumber.fromString(this.toString(), format);
+        }
+        /**
+         *  Creates a new [[FixedNumber]] for %%value%% divided by
+         *  %%decimal%% places with %%format%%.
+         *
+         *  This will throw a [[NumericFaultError]] if %%value%% (once adjusted
+         *  for %%decimals%%) cannot fit in %%format%%, either due to overflow
+         *  or underflow (precision loss).
+         */
+        static fromValue(_value, _decimals, _format) {
+            const decimals = (_decimals == null) ? 0 : getNumber(_decimals);
+            const format = getFormat(_format);
+            let value = getBigInt(_value, "value");
+            const delta = decimals - format.decimals;
+            if (delta > 0) {
+                const tens = getTens(delta);
+                assert$2((value % tens) === BN_0$8, "value loses precision for format", "NUMERIC_FAULT", {
+                    operation: "fromValue", fault: "underflow", value: _value
+                });
+                value /= tens;
+            }
+            else if (delta < 0) {
+                value *= getTens(-delta);
+            }
+            checkValue(value, format, "fromValue");
+            return new FixedNumber(_guard$3, value, format);
+        }
+        /**
+         *  Creates a new [[FixedNumber]] for %%value%% with %%format%%.
+         *
+         *  This will throw a [[NumericFaultError]] if %%value%% cannot fit
+         *  in %%format%%, either due to overflow or underflow (precision loss).
+         */
+        static fromString(_value, _format) {
+            const match = _value.match(/^(-?)([0-9]*)\.?([0-9]*)$/);
+            assertArgument(match && (match[2].length + match[3].length) > 0, "invalid FixedNumber string value", "value", _value);
+            const format = getFormat(_format);
+            let whole = (match[2] || "0"), decimal = (match[3] || "");
+            // Pad out the decimals
+            while (decimal.length < format.decimals) {
+                decimal += Zeros$1;
+            }
+            // Check precision is safe
+            assert$2(decimal.substring(format.decimals).match(/^0*$/), "too many decimals for format", "NUMERIC_FAULT", {
+                operation: "fromString", fault: "underflow", value: _value
+            });
+            // Remove extra padding
+            decimal = decimal.substring(0, format.decimals);
+            const value = BigInt(match[1] + whole + decimal);
+            checkValue(value, format, "fromString");
+            return new FixedNumber(_guard$3, value, format);
+        }
+        /**
+         *  Creates a new [[FixedNumber]] with the big-endian representation
+         *  %%value%% with %%format%%.
+         *
+         *  This will throw a [[NumericFaultError]] if %%value%% cannot fit
+         *  in %%format%% due to overflow.
+         */
+        static fromBytes(_value, _format) {
+            let value = toBigInt(getBytes(_value, "value"));
+            const format = getFormat(_format);
+            if (format.signed) {
+                value = fromTwos(value, format.width);
+            }
+            checkValue(value, format, "fromBytes");
+            return new FixedNumber(_guard$3, value, format);
+        }
+    }
+    //const f1 = FixedNumber.fromString("12.56", "fixed16x2");
+    //const f2 = FixedNumber.fromString("0.3", "fixed16x2");
+    //console.log(f1.divSignal(f2));
+    //const BUMP = FixedNumber.from("0.5");
+
     //See: https://github.com/ethereum/wiki/wiki/RLP
     function hexlifyByte(value) {
         let result = value.toString(16);
@@ -32414,6 +33021,62 @@ var PolygonIdSdk = (function (exports) {
         return result;
     }
 
+    /**
+     *  Most interactions with Ethereum requires integer values, which use
+     *  the smallest magnitude unit.
+     *
+     *  For example, imagine dealing with dollars and cents. Since dollars
+     *  are divisible, non-integer values are possible, such as ``$10.77``.
+     *  By using the smallest indivisible unit (i.e. cents), the value can
+     *  be kept as the integer ``1077``.
+     *
+     *  When receiving decimal input from the user (as a decimal string),
+     *  the value should be converted to an integer and when showing a user
+     *  a value, the integer value should be converted to a decimal string.
+     *
+     *  This creates a clear distinction, between values to be used by code
+     *  (integers) and values used for display logic to users (decimals).
+     *
+     *  The native unit in Ethereum, //ether// is divisible to 18 decimal places,
+     *  where each individual unit is called a //wei//.
+     *
+     *  @_subsection api/utils:Unit Conversion  [about-units]
+     */
+    const names = [
+        "wei",
+        "kwei",
+        "mwei",
+        "gwei",
+        "szabo",
+        "finney",
+        "ether",
+    ];
+    /**
+     *  Converts the //decimal string// %%value%% to a BigInt, assuming
+     *  %%unit%% decimal places. The %%unit%% may the number of decimal places
+     *  or the name of a unit (e.g. ``"gwei"`` for 9 decimal places).
+     */
+    function parseUnits$1(value, unit) {
+        assertArgument(typeof (value) === "string", "value must be a string", "value", value);
+        let decimals = 18;
+        if (typeof (unit) === "string") {
+            const index = names.indexOf(unit);
+            assertArgument(index >= 0, "invalid unit", "unit", unit);
+            decimals = 3 * index;
+        }
+        else if (unit != null) {
+            decimals = getNumber(unit, "unit");
+        }
+        return FixedNumber.fromString(value, { decimals, width: 512 }).value;
+    }
+    /**
+     *  Converts the //decimal string// %%ether%% to a BigInt, using 18
+     *  decimal places.
+     */
+    function parseEther(ether) {
+        return parseUnits$1(ether, 18);
+    }
+
     /**
      * @_ignore:
      */
@@ -53598,23 +54261,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 +54280,12 @@ var PolygonIdSdk = (function (exports) {
             ];
             return payload;
         }
+        /**
+         * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
+         */
+        async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+            return OnChainZKPVerifier.prepareTxArgsSubmitV1(txData, zkProofResponse);
+        }
         /**
          * {@inheritDoc IOnChainZKPVerifier.submitZKPResponse}
          */
@@ -53721,13 +54375,10 @@ var PolygonIdSdk = (function (exports) {
             const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
             return new Map().set(txnHash, zkProofResponses);
         }
-        async prepareTxArgsSubmitV2(txData, zkProofResponses) {
+        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 payload = [];
@@ -53752,7 +54403,9 @@ var PolygonIdSdk = (function (exports) {
                         continue;
                     }
                     gistUpdateResolutionsPending.push(JSON.stringify(gist));
-                    gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(Q$2.parseFromId(gist.id), this._opts.didResolverUrl, { gist: gist.root }));
+                    gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(Q$2.parseFromId(gist.id), resolverUrl, {
+                        gist: gist.root
+                    }));
                 }
                 const stateUpdateResolutions = [];
                 for (const state of stateInfo.states) {
@@ -53761,7 +54414,7 @@ var PolygonIdSdk = (function (exports) {
                         continue;
                     }
                     stateUpdateResolutionsPending.push(JSON.stringify(state));
-                    stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(Q$2.parseFromId(state.id), this._opts.didResolverUrl, {
+                    stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(Q$2.parseFromId(state.id), resolverUrl, {
                         state: state.state
                     }));
                 }
@@ -53795,10 +54448,16 @@ var PolygonIdSdk = (function (exports) {
             const crossChainProofs = this.packCrossChainProofs(gistUpdateArr, stateUpdateArr);
             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 +54471,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 +54486,8 @@ var PolygonIdSdk = (function (exports) {
                     ')'
             ], [msg]);
         }
-        packIdentityStateMsg(msg) {
-            return this._abiCoder.encode([
+        static packIdentityStateMsg(msg) {
+            return new AbiCoder().encode([
                 'tuple(' +
                     'tuple(' +
                     'uint256 timestamp,' +
@@ -53840,10 +54499,10 @@ 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) {
+        static getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
             let atomicQueryPubSignals;
             switch (onChainCircuitId) {
                 case exports.CircuitId.AtomicQueryMTPV2OnChain:
@@ -53860,7 +54519,7 @@ var PolygonIdSdk = (function (exports) {
             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 +54552,14 @@ var PolygonIdSdk = (function (exports) {
             };
         }
     }
+    /**
+     * supported circuits
+     */
+    OnChainZKPVerifier._supportedCircuits = [
+        exports.CircuitId.AtomicQueryMTPV2OnChain,
+        exports.CircuitId.AtomicQuerySigV2OnChain,
+        exports.CircuitId.AtomicQueryV3OnChain
+    ];
 
     var abi$1 = [
     	{
@@ -54266,31 +54933,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 +57293,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 +57318,6 @@ var PolygonIdSdk = (function (exports) {
     		name: "Approval",
     		type: "event"
     	},
-    	{
-    		anonymous: false,
-    		inputs: [
-    		],
-    		name: "EIP712DomainChanged",
-    		type: "event"
-    	},
     	{
     		anonymous: false,
     		inputs: [
@@ -54495,20 +57343,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 +57424,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 +57438,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 +57532,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 +57559,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 +59247,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 +59291,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 +59372,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 +82091,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 +82203,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");
@@ -80143,19 +82864,20 @@ var PolygonIdSdk = (function (exports) {
         return request;
     }
     async function verifyEIP712TypedData(data, resolver) {
+        const convertedAmount = await convertPaymentAmount(data.amount, data.currency);
         const paymentData = data.type === exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1
             ? {
                 recipient: data.recipient,
-                amount: data.amount,
-                expirationDate: new Date(data.expirationDate).getTime(),
+                amount: convertedAmount,
+                expirationDate: b$4(new Date(data.expirationDate)),
                 nonce: data.nonce,
                 metadata: '0x'
             }
             : {
                 tokenAddress: data.tokenAddress,
                 recipient: data.recipient,
-                amount: data.amount,
-                expirationDate: new Date(data.expirationDate).getTime(),
+                amount: convertedAmount,
+                expirationDate: b$4(new Date(data.expirationDate)),
                 nonce: data.nonce,
                 metadata: '0x'
             };
@@ -80178,6 +82900,30 @@ var PolygonIdSdk = (function (exports) {
         }
         throw new Error(`failed request. no matching verificationMethod`);
     }
+    async function convertPaymentAmount(amount, currency) {
+        let convertedAmount = 0n;
+        switch (currency) {
+            case exports.SupportedCurrencies.ETH:
+            case exports.SupportedCurrencies.POL:
+            case exports.SupportedCurrencies.MATIC:
+                convertedAmount = parseEther(amount.toString());
+                break;
+            case exports.SupportedCurrencies.ETH_WEI:
+                convertedAmount = parseUnits$1(amount.toString(), 'wei');
+                break;
+            case exports.SupportedCurrencies.ETH_GWEI:
+                convertedAmount = parseUnits$1(amount.toString(), 'gwei');
+                break;
+            case exports.SupportedCurrencies.USDC:
+            case exports.SupportedCurrencies.USDT: {
+                convertedAmount = parseUnits$1(amount.toString(), 6);
+                break;
+            }
+            default:
+                throw new Error(`failed request. unsupported currency ${currency}`);
+        }
+        return convertedAmount;
+    }
     /**
      * @beta
      * createPayment is a function to create protocol payment message
@@ -80375,26 +83121,25 @@ var PolygonIdSdk = (function (exports) {
                     if (type === exports.PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1 && !tokenAddress) {
                         throw new Error(`failed request. no token address for currency ${currency}`);
                     }
-                    const expirationTime = expirationDate
-                        ? new Date(expirationDate).getTime()
-                        : new Date(new Date().setHours(new Date().getHours() + 1)).getTime();
+                    const expirationDateRequired = expirationDate ?? new Date(new Date().setHours(new Date().getHours() + 1));
                     const typeUrl = `https://schema.iden3.io/core/json/${type}.json`;
                     const typesFetchResult = await fetch(typeUrl);
                     const types = await typesFetchResult.json();
                     delete types.EIP712Domain;
+                    const convertedAmount = await convertPaymentAmount(amount, currency);
                     const paymentData = type === exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1
                         ? {
                             recipient,
-                            amount,
-                            expirationDate: expirationTime,
+                            amount: convertedAmount,
+                            expirationDate: b$4(expirationDateRequired),
                             nonce,
                             metadata: '0x'
                         }
                         : {
                             tokenAddress,
                             recipient,
-                            amount,
-                            expirationDate: expirationTime,
+                            amount: convertedAmount,
+                            expirationDate: b$4(expirationDateRequired),
                             nonce,
                             metadata: '0x'
                         };
@@ -80428,7 +83173,7 @@ var PolygonIdSdk = (function (exports) {
                         recipient,
                         amount: amount.toString(),
                         currency,
-                        expirationDate: new Date(expirationTime).toISOString(),
+                        expirationDate: expirationDateRequired.toISOString(),
                         nonce: nonce.toString(),
                         metadata: '0x',
                         proof
@@ -82587,6 +85332,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 +85376,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;
@@ -82682,6 +85430,7 @@ var PolygonIdSdk = (function (exports) {
     exports.checkQueryRequest = checkQueryRequest;
     exports.circuitValidator = circuitValidator;
     exports.comparatorOptions = comparatorOptions;
+    exports.convertPaymentAmount = convertPaymentAmount;
     exports.core = index$1;
     exports.createAuthorizationRequest = createAuthorizationRequest;
     exports.createAuthorizationRequestWithMessage = createAuthorizationRequestWithMessage;
@@ -82712,6 +85461,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;