@0xpolygonid/js-sdk 1.23.0 → 1.24.1

package/dist/browser/esm/index.js

@@ -1,4 +1,4 @@
-import { DID, buildDIDType, Id as Id$1, genesisFromEthAddress, BytesHelper, checkBigIntInField, Claim, SchemaHash, ClaimOptions, MerklizedRootPosition as MerklizedRootPosition$1, IdPosition, getChainId, getUnixTimestamp, ChainIds, getDateFromUnixTimestamp, DidMethod, Blockchain, NetworkId } from '@iden3/js-iden3-core';
+import { DID, buildDIDType, Id as Id$1, genesisFromEthAddress, BytesHelper, checkBigIntInField, Claim, SchemaHash, getChainId, ClaimOptions, MerklizedRootPosition as MerklizedRootPosition$1, IdPosition, getDateFromUnixTimestamp, chainIDfromDID, getUnixTimestamp, ChainIds, DidMethod, Blockchain, NetworkId } from '@iden3/js-iden3-core';
 import * as jsIden3Core from '@iden3/js-iden3-core';
 export { jsIden3Core as core };
 import { Path, Merklizer, getDocumentLoader } from '@iden3/js-jsonld-merklization';
@@ -1343,7 +1343,7 @@ const validateDIDDocumentAuth = async (did, resolverURL, state) => {
     }
 };
 const resolveDIDDocumentAuth = async (did, resolveURL, state) => {
-    let url = `${resolveURL}/${did.string().replace(/:/g, '%3A')}`;
+    let url = `${resolveURL}/${encodeURIComponent(did.string())}`;
     if (state) {
         url += `?state=${state.hex()}`;
     }
@@ -1359,11 +1359,11 @@ function emptyStateDID(did) {
     return emptyDID;
 }
 const resolveDidDocument = async (did, resolverUrl, opts) => {
-    let didString = did.string().replace(/:/g, '%3A');
+    let didString = encodeURIComponent(did.string());
     // for gist resolve we have to `hide` user did (look into resolver implementation)
     const isGistRequest = opts?.gist && !opts.state;
     if (isGistRequest) {
-        didString = emptyStateDID(did).string();
+        didString = encodeURIComponent(emptyStateDID(did).string());
     }
     let url = `${resolverUrl}/1.0/identifiers/${didString}`;
     if (opts?.signature) {
@@ -5398,7 +5398,7 @@ const coerce = o => {
   throw new Error('Unknown type, must be binary type');
 };
 const fromString$1 = str => new TextEncoder().encode(str);
-const toString$1 = b => new TextDecoder().decode(b);
+const toString$2 = b => new TextDecoder().decode(b);
 
 class Encoder {
   constructor(name, prefix, baseEncode) {
@@ -5555,7 +5555,7 @@ const rfc4648$2 = ({name, prefix, bitsPerChar, alphabet}) => {
 const identity$1 = from({
   prefix: '\0',
   name: 'identity',
-  encode: buf => toString$1(buf),
+  encode: buf => toString$2(buf),
   decode: str => fromString$1(str)
 });
 
@@ -5919,7 +5919,7 @@ function fromString(string, encoding = 'utf8') {
   return base.decoder.decode(`${ base.prefix }${ string }`);
 }
 
-function toString(array, encoding = 'utf8') {
+function toString$1(array, encoding = 'utf8') {
   const base = BASES[encoding];
   if (!base) {
     throw new Error(`Unsupported encoding "${ encoding }"`);
@@ -6313,19 +6313,19 @@ const constants$2 = [
 ];
 
 /** @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 = 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
 };
 
@@ -7097,7 +7097,7 @@ function genBech32(encoding) {
 const bech32 = /* @__PURE__ */ genBech32('bech32');
 
 const u8a$2 = {
-  toString,
+  toString: toString$1,
   fromString,
   concat: concat$2
 };
@@ -7295,7 +7295,7 @@ function sha256$2(payload) {
 const keccak = keccak_256$1;
 function toEthereumAddress(hexPublicKey) {
   const hashInput = fromString(hexPublicKey.slice(2), 'base16');
-  return `0x${toString(keccak(hashInput).slice(-20), 'base16')}`;
+  return `0x${toString$1(keccak(hashInput).slice(-20), 'base16')}`;
 }
 
 /**
@@ -7827,6 +7827,7 @@ var SupportedCurrencies;
     SupportedCurrencies["ETH_WEI"] = "ETHWEI";
     SupportedCurrencies["ETH_GWEI"] = "ETHGWEI";
     SupportedCurrencies["MATIC"] = "MATIC";
+    SupportedCurrencies["POL"] = "POL";
     SupportedCurrencies["USDT"] = "USDT";
     SupportedCurrencies["USDC"] = "USDC";
 })(SupportedCurrencies || (SupportedCurrencies = {}));
@@ -19899,6 +19900,92 @@ class W3CCredential {
         this.credentialSubject = {};
         this.issuer = '';
     }
+    /**
+     *
+     * @param issuer - DID of the issuer
+     * @param request - Credential request
+     * @returns - W3C Credential
+     */
+    static fromCredentialRequest(issuer, request) {
+        if (!request.id) {
+            throw new Error('Credential id is required');
+        }
+        if (!request.context) {
+            throw new Error('Credential context is required');
+        }
+        const context = [
+            VerifiableConstants.JSONLD_SCHEMA.W3C_CREDENTIAL_2018,
+            VerifiableConstants.JSONLD_SCHEMA.IDEN3_CREDENTIAL,
+            ...request.context
+        ];
+        const credentialType = [
+            VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_CREDENTIAL,
+            request.type
+        ];
+        const credentialSubject = request.credentialSubject;
+        credentialSubject['type'] = request.type;
+        const cr = new W3CCredential();
+        cr.id = request.id;
+        cr['@context'] = context;
+        cr.type = credentialType;
+        cr.credentialSubject = credentialSubject;
+        cr.issuer = issuer.string();
+        cr.credentialSchema = {
+            id: request.credentialSchema,
+            type: VerifiableConstants.JSON_SCHEMA_VALIDATOR
+        };
+        cr.credentialStatus = W3CCredential.buildCredentialStatus(request, issuer);
+        request.expiration && (cr.expirationDate = new Date(request.expiration).toISOString());
+        request.refreshService && (cr.refreshService = request.refreshService);
+        request.displayMethod && (cr.displayMethod = request.displayMethod);
+        request.issuanceDate && (cr.issuanceDate = new Date(request.issuanceDate).toISOString());
+        return cr;
+    }
+    /**
+     * Builds credential status
+     * @param {CredentialRequest} request
+     * @returns `CredentialStatus`
+     */
+    static buildCredentialStatus(request, issuer) {
+        const credentialStatus = {
+            id: request.revocationOpts.id,
+            type: request.revocationOpts.type,
+            revocationNonce: request.revocationOpts.nonce
+        };
+        switch (request.revocationOpts.type) {
+            case CredentialStatusType.SparseMerkleTreeProof:
+                return {
+                    ...credentialStatus,
+                    id: `${credentialStatus.id.replace(/\/$/, '')}/${credentialStatus.revocationNonce}`
+                };
+            case CredentialStatusType.Iden3ReverseSparseMerkleTreeProof:
+                return {
+                    ...credentialStatus,
+                    id: request.revocationOpts.issuerState
+                        ? `${credentialStatus.id.replace(/\/$/, '')}/node?state=${request.revocationOpts.issuerState}`
+                        : `${credentialStatus.id.replace(/\/$/, '')}`
+                };
+            case CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023: {
+                const issuerId = DID.idFromDID(issuer);
+                const chainId = getChainId(DID.blockchainFromId(issuerId), DID.networkIdFromId(issuerId));
+                const searchParams = [
+                    ['revocationNonce', request.revocationOpts.nonce?.toString() || ''],
+                    ['contractAddress', `${chainId}:${request.revocationOpts.id}`],
+                    ['state', request.revocationOpts.issuerState || '']
+                ]
+                    .filter(([, value]) => Boolean(value))
+                    .map(([key, value]) => `${key}=${value}`)
+                    .join('&');
+                return {
+                    ...credentialStatus,
+                    // `[did]:[methodid]:[chain]:[network]:[id]/credentialStatus?(revocationNonce=value)&[contractAddress=[chainID]:[contractAddress]]&(state=issuerState)`
+                    id: `${issuer.string()}/credentialStatus?${searchParams}`
+                };
+            }
+            default:
+                return credentialStatus;
+        }
+    }
     toJSON() {
         return {
             ...this,
@@ -22275,16 +22362,16 @@ var util = {};
 	
 } (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
@@ -22307,9 +22394,9 @@ function requireNames () {
 	    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;
@@ -30743,8 +30830,8 @@ function zeroPadBytes(data, length) {
  *
  *  @_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;
@@ -30757,13 +30844,13 @@ const maxValue = 0x1fffffffffffff;
 function fromTwos(_value, _width) {
     const value = getUint(_value, "value");
     const width = BigInt(getNumber(_width, "width"));
-    assert((value >> width) === BN_0$8, "overflow", "NUMERIC_FAULT", {
+    assert((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;
 }
@@ -30776,14 +30863,14 @@ function fromTwos(_value, _width) {
 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(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(value < limit, "too high", "NUMERIC_FAULT", {
@@ -30798,7 +30885,7 @@ function toTwos(_value, _width) {
 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
@@ -30833,7 +30920,7 @@ function getBigInt(value, name) {
  */
 function getUint(value, name) {
     const result = getBigInt(value, name);
-    assert(result >= BN_0$8, "unsigned value cannot be negative", "NUMERIC_FAULT", {
+    assert(result >= BN_0$9, "unsigned value cannot be negative", "NUMERIC_FAULT", {
         fault: "overflow", operation: "getUint", value
     });
     return result;
@@ -30919,7 +31006,7 @@ function toBeHex(_value, _width) {
  */
 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);
@@ -32151,6 +32238,526 @@ function wait(delay) {
     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(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(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(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(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((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(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(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((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((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(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);
@@ -32275,6 +32882,62 @@ function encodeRlp(object) {
     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:
  */
@@ -53459,23 +54122,8 @@ class OnChainZKPVerifier {
     constructor(_configs, _opts) {
         this._configs = _configs;
         this._opts = _opts;
-        /**
-         * supported circuits
-         */
-        this._supportedCircuits = [
-            CircuitId.AtomicQueryMTPV2OnChain,
-            CircuitId.AtomicQuerySigV2OnChain,
-            CircuitId.AtomicQueryV3OnChain
-        ];
-        /**
-         * abi coder to encode/decode structures to solidity bytes
-         */
-        this._abiCoder = new AbiCoder();
     }
-    /**
-     * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
-     */
-    async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+    static async prepareTxArgsSubmitV1(txData, zkProofResponse) {
         if (txData.method_id.replace('0x', '') !== FunctionSignatures.SubmitZKPResponseV1) {
             throw new Error(`prepareTxArgsSubmitV1 function doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV1}' is supported.`);
         }
@@ -53493,6 +54141,12 @@ class OnChainZKPVerifier {
         ];
         return payload;
     }
+    /**
+     * {@inheritDoc IOnChainZKPVerifier.prepareTxArgsSubmitV1}
+     */
+    async prepareTxArgsSubmitV1(txData, zkProofResponse) {
+        return OnChainZKPVerifier.prepareTxArgsSubmitV1(txData, zkProofResponse);
+    }
     /**
      * {@inheritDoc IOnChainZKPVerifier.submitZKPResponse}
      */
@@ -53582,13 +54236,10 @@ class OnChainZKPVerifier {
         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', '') !== FunctionSignatures.SubmitZKPResponseV2) {
             throw new Error(`submit cross chain doesn't implement requested method id. Only '0x${FunctionSignatures.SubmitZKPResponseV2}' is supported.`);
         }
-        if (!this._opts?.didResolverUrl) {
-            throw new Error(`did resolver url required for crosschain verification`);
-        }
         const gistUpdateArr = [];
         const stateUpdateArr = [];
         const payload = [];
@@ -53613,7 +54264,9 @@ class OnChainZKPVerifier {
                     continue;
                 }
                 gistUpdateResolutionsPending.push(JSON.stringify(gist));
-                gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(gist.id), this._opts.didResolverUrl, { gist: gist.root }));
+                gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(gist.id), resolverUrl, {
+                    gist: gist.root
+                }));
             }
             const stateUpdateResolutions = [];
             for (const state of stateInfo.states) {
@@ -53622,7 +54275,7 @@ class OnChainZKPVerifier {
                     continue;
                 }
                 stateUpdateResolutionsPending.push(JSON.stringify(state));
-                stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(state.id), this._opts.didResolverUrl, {
+                stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(DID.parseFromId(state.id), resolverUrl, {
                     state: state.state
                 }));
             }
@@ -53656,10 +54309,16 @@ class OnChainZKPVerifier {
         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);
     }
-    packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
+    static packZkpProof(inputs, a, b, c) {
+        return new AbiCoder().encode(['uint256[] inputs', 'uint256[2]', 'uint256[2][2]', 'uint256[2]'], [inputs, a, b, c]);
+    }
+    static packCrossChainProofs(gistUpdateArr, stateUpdateArr) {
         const proofs = [];
         for (const globalStateUpdate of gistUpdateArr) {
             proofs.push({
@@ -53673,10 +54332,10 @@ class OnChainZKPVerifier {
                 proof: this.packIdentityStateMsg(stateUpdate)
             });
         }
-        return this._abiCoder.encode(['tuple(' + 'string proofType,' + 'bytes proof' + ')[]'], [proofs]);
+        return new AbiCoder().encode(['tuple(' + 'string proofType,' + 'bytes proof' + ')[]'], [proofs]);
     }
-    packGlobalStateMsg(msg) {
-        return this._abiCoder.encode([
+    static packGlobalStateMsg(msg) {
+        return new AbiCoder().encode([
             'tuple(' +
                 'tuple(' +
                 'uint256 timestamp,' +
@@ -53688,8 +54347,8 @@ class OnChainZKPVerifier {
                 ')'
         ], [msg]);
     }
-    packIdentityStateMsg(msg) {
-        return this._abiCoder.encode([
+    static packIdentityStateMsg(msg) {
+        return new AbiCoder().encode([
             'tuple(' +
                 'tuple(' +
                 'uint256 timestamp,' +
@@ -53701,10 +54360,10 @@ class OnChainZKPVerifier {
                 ')'
         ], [msg]);
     }
-    packMetadatas(metas) {
-        return this._abiCoder.encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
+    static packMetadatas(metas) {
+        return new AbiCoder().encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
     }
-    getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
+    static getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
         let atomicQueryPubSignals;
         switch (onChainCircuitId) {
             case CircuitId.AtomicQueryMTPV2OnChain:
@@ -53721,7 +54380,7 @@ class OnChainZKPVerifier {
         atomicQueryPubSignals.pubSignalsUnmarshal(encodedInputs);
         return atomicQueryPubSignals.getStatesInfo();
     }
-    async resolveDidDocumentEip712MessageAndSignature(did, resolverUrl, opts) {
+    static async resolveDidDocumentEip712MessageAndSignature(did, resolverUrl, opts) {
         const didDoc = await resolveDidDocument(did, resolverUrl, {
             ...opts,
             signature: DIDDocumentSignature.EthereumEip712Signature2021
@@ -53754,6 +54413,14 @@ class OnChainZKPVerifier {
         };
     }
 }
+/**
+ * supported circuits
+ */
+OnChainZKPVerifier._supportedCircuits = [
+    CircuitId.AtomicQueryMTPV2OnChain,
+    CircuitId.AtomicQuerySigV2OnChain,
+    CircuitId.AtomicQueryV3OnChain
+];
 
 var abi$1 = [
 	{
@@ -54127,31 +54794,2279 @@ class OnChainRevocationStorage {
 var abi = [
 	{
 		inputs: [
+			{
+				internalType: "uint256",
+				name: "_userId",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "_credentialId",
+				type: "uint256"
+			}
 		],
-		name: "ECDSAInvalidSignature",
-		type: "error"
+		name: "getCredential",
+		outputs: [
+			{
+				components: [
+					{
+						internalType: "uint256",
+						name: "id",
+						type: "uint256"
+					},
+					{
+						internalType: "string[]",
+						name: "context",
+						type: "string[]"
+					},
+					{
+						internalType: "string",
+						name: "_type",
+						type: "string"
+					},
+					{
+						internalType: "uint64",
+						name: "issuanceDate",
+						type: "uint64"
+					},
+					{
+						components: [
+							{
+								internalType: "string",
+								name: "id",
+								type: "string"
+							},
+							{
+								internalType: "string",
+								name: "_type",
+								type: "string"
+							}
+						],
+						internalType: "struct INonMerklizedIssuer.CredentialSchema",
+						name: "credentialSchema",
+						type: "tuple"
+					},
+					{
+						components: [
+							{
+								internalType: "string",
+								name: "id",
+								type: "string"
+							},
+							{
+								internalType: "string",
+								name: "_type",
+								type: "string"
+							}
+						],
+						internalType: "struct INonMerklizedIssuer.DisplayMethod",
+						name: "displayMethod",
+						type: "tuple"
+					}
+				],
+				internalType: "struct INonMerklizedIssuer.CredentialData",
+				name: "",
+				type: "tuple"
+			},
+			{
+				internalType: "uint256[8]",
+				name: "",
+				type: "uint256[8]"
+			},
+			{
+				components: [
+					{
+						internalType: "string",
+						name: "key",
+						type: "string"
+					},
+					{
+						internalType: "uint256",
+						name: "value",
+						type: "uint256"
+					},
+					{
+						internalType: "bytes",
+						name: "rawValue",
+						type: "bytes"
+					}
+				],
+				internalType: "struct INonMerklizedIssuer.SubjectField[]",
+				name: "",
+				type: "tuple[]"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
 	},
 	{
 		inputs: [
+		],
+		name: "getCredentialAdapterVersion",
+		outputs: [
 			{
-				internalType: "uint256",
-				name: "length",
-				type: "uint256"
+				internalType: "string",
+				name: "",
+				type: "string"
 			}
 		],
-		name: "ECDSAInvalidSignatureLength",
-		type: "error"
+		stateMutability: "view",
+		type: "function"
 	},
 	{
 		inputs: [
 			{
-				internalType: "bytes32",
-				name: "s",
-				type: "bytes32"
+				internalType: "uint256",
+				name: "_userId",
+				type: "uint256"
 			}
 		],
-		name: "ECDSAInvalidSignatureS",
-		type: "error"
+		name: "getUserCredentialIds",
+		outputs: [
+			{
+				internalType: "uint256[]",
+				name: "",
+				type: "uint256[]"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	}
+];
+
+/* Autogenerated file. Do not edit manually. */
+/* tslint:disable */
+/* eslint-disable */
+const _abi = [
+    {
+        inputs: [],
+        name: 'CREDENTIAL_ADAPTER_VERSION',
+        outputs: [
+            {
+                internalType: 'string',
+                name: '',
+                type: 'string'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'claimIndexHash',
+                type: 'uint256'
+            }
+        ],
+        name: 'getClaimProof',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'claimIndexHash',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint256',
+                name: 'root',
+                type: 'uint256'
+            }
+        ],
+        name: 'getClaimProofByRoot',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'claimIndexHash',
+                type: 'uint256'
+            }
+        ],
+        name: 'getClaimProofWithStateInfo',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            },
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'state',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'claimsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'revocationsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'rootsRoot',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct IdentityLib.StateInfo',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getClaimsTreeRoot',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: '_userId',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint256',
+                name: '_credentialId',
+                type: 'uint256'
+            }
+        ],
+        name: 'getCredential',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'id',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'string[]',
+                        name: 'context',
+                        type: 'string[]'
+                    },
+                    {
+                        internalType: 'string',
+                        name: '_type',
+                        type: 'string'
+                    },
+                    {
+                        internalType: 'uint64',
+                        name: 'issuanceDate',
+                        type: 'uint64'
+                    },
+                    {
+                        components: [
+                            {
+                                internalType: 'string',
+                                name: 'id',
+                                type: 'string'
+                            },
+                            {
+                                internalType: 'string',
+                                name: '_type',
+                                type: 'string'
+                            }
+                        ],
+                        internalType: 'struct INonMerklizedIssuer.CredentialSchema',
+                        name: 'credentialSchema',
+                        type: 'tuple'
+                    },
+                    {
+                        components: [
+                            {
+                                internalType: 'string',
+                                name: 'id',
+                                type: 'string'
+                            },
+                            {
+                                internalType: 'string',
+                                name: '_type',
+                                type: 'string'
+                            }
+                        ],
+                        internalType: 'struct INonMerklizedIssuer.DisplayMethod',
+                        name: 'displayMethod',
+                        type: 'tuple'
+                    }
+                ],
+                internalType: 'struct INonMerklizedIssuer.CredentialData',
+                name: '',
+                type: 'tuple'
+            },
+            {
+                internalType: 'uint256[8]',
+                name: '',
+                type: 'uint256[8]'
+            },
+            {
+                components: [
+                    {
+                        internalType: 'string',
+                        name: 'key',
+                        type: 'string'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bytes',
+                        name: 'rawValue',
+                        type: 'bytes'
+                    }
+                ],
+                internalType: 'struct INonMerklizedIssuer.SubjectField[]',
+                name: '',
+                type: 'tuple[]'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getCredentialAdapterVersion',
+        outputs: [
+            {
+                internalType: 'string',
+                name: '',
+                type: 'string'
+            }
+        ],
+        stateMutability: 'pure',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getId',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getIsOldStateGenesis',
+        outputs: [
+            {
+                internalType: 'bool',
+                name: '',
+                type: 'bool'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getLatestPublishedClaimsRoot',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getLatestPublishedRevocationsRoot',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getLatestPublishedRootsRoot',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getLatestPublishedState',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint64',
+                name: 'revocationNonce',
+                type: 'uint64'
+            }
+        ],
+        name: 'getRevocationProof',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint64',
+                name: 'revocationNonce',
+                type: 'uint64'
+            },
+            {
+                internalType: 'uint256',
+                name: 'root',
+                type: 'uint256'
+            }
+        ],
+        name: 'getRevocationProofByRoot',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint64',
+                name: 'revocationNonce',
+                type: 'uint64'
+            }
+        ],
+        name: 'getRevocationProofWithStateInfo',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            },
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'state',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'claimsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'revocationsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'rootsRoot',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct IdentityLib.StateInfo',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'id',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint64',
+                name: 'nonce',
+                type: 'uint64'
+            }
+        ],
+        name: 'getRevocationStatus',
+        outputs: [
+            {
+                components: [
+                    {
+                        components: [
+                            {
+                                internalType: 'uint256',
+                                name: 'state',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'claimsTreeRoot',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'revocationTreeRoot',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'rootOfRoots',
+                                type: 'uint256'
+                            }
+                        ],
+                        internalType: 'struct IOnchainCredentialStatusResolver.IdentityStateRoots',
+                        name: 'issuer',
+                        type: 'tuple'
+                    },
+                    {
+                        components: [
+                            {
+                                internalType: 'uint256',
+                                name: 'root',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'bool',
+                                name: 'existence',
+                                type: 'bool'
+                            },
+                            {
+                                internalType: 'uint256[]',
+                                name: 'siblings',
+                                type: 'uint256[]'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'index',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'value',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'bool',
+                                name: 'auxExistence',
+                                type: 'bool'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'auxIndex',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'auxValue',
+                                type: 'uint256'
+                            }
+                        ],
+                        internalType: 'struct IOnchainCredentialStatusResolver.Proof',
+                        name: 'mtp',
+                        type: 'tuple'
+                    }
+                ],
+                internalType: 'struct IOnchainCredentialStatusResolver.CredentialStatus',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'id',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint256',
+                name: 'state',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint64',
+                name: 'nonce',
+                type: 'uint64'
+            }
+        ],
+        name: 'getRevocationStatusByIdAndState',
+        outputs: [
+            {
+                components: [
+                    {
+                        components: [
+                            {
+                                internalType: 'uint256',
+                                name: 'state',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'claimsTreeRoot',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'revocationTreeRoot',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'rootOfRoots',
+                                type: 'uint256'
+                            }
+                        ],
+                        internalType: 'struct IOnchainCredentialStatusResolver.IdentityStateRoots',
+                        name: 'issuer',
+                        type: 'tuple'
+                    },
+                    {
+                        components: [
+                            {
+                                internalType: 'uint256',
+                                name: 'root',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'bool',
+                                name: 'existence',
+                                type: 'bool'
+                            },
+                            {
+                                internalType: 'uint256[]',
+                                name: 'siblings',
+                                type: 'uint256[]'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'index',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'value',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'bool',
+                                name: 'auxExistence',
+                                type: 'bool'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'auxIndex',
+                                type: 'uint256'
+                            },
+                            {
+                                internalType: 'uint256',
+                                name: 'auxValue',
+                                type: 'uint256'
+                            }
+                        ],
+                        internalType: 'struct IOnchainCredentialStatusResolver.Proof',
+                        name: 'mtp',
+                        type: 'tuple'
+                    }
+                ],
+                internalType: 'struct IOnchainCredentialStatusResolver.CredentialStatus',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getRevocationsTreeRoot',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'rootsTreeRoot',
+                type: 'uint256'
+            }
+        ],
+        name: 'getRootProof',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'claimsTreeRoot',
+                type: 'uint256'
+            },
+            {
+                internalType: 'uint256',
+                name: 'root',
+                type: 'uint256'
+            }
+        ],
+        name: 'getRootProofByRoot',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'rootsTreeRoot',
+                type: 'uint256'
+            }
+        ],
+        name: 'getRootProofWithStateInfo',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'root',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'existence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256[]',
+                        name: 'siblings',
+                        type: 'uint256[]'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'index',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'value',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'bool',
+                        name: 'auxExistence',
+                        type: 'bool'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxIndex',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'auxValue',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct SmtLib.Proof',
+                name: '',
+                type: 'tuple'
+            },
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'state',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'claimsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'revocationsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'rootsRoot',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct IdentityLib.StateInfo',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: 'state',
+                type: 'uint256'
+            }
+        ],
+        name: 'getRootsByState',
+        outputs: [
+            {
+                components: [
+                    {
+                        internalType: 'uint256',
+                        name: 'claimsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'revocationsRoot',
+                        type: 'uint256'
+                    },
+                    {
+                        internalType: 'uint256',
+                        name: 'rootsRoot',
+                        type: 'uint256'
+                    }
+                ],
+                internalType: 'struct IdentityLib.Roots',
+                name: '',
+                type: 'tuple'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getRootsTreeRoot',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [],
+        name: 'getSmtDepth',
+        outputs: [
+            {
+                internalType: 'uint256',
+                name: '',
+                type: 'uint256'
+            }
+        ],
+        stateMutability: 'pure',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'uint256',
+                name: '_userId',
+                type: 'uint256'
+            }
+        ],
+        name: 'getUserCredentialIds',
+        outputs: [
+            {
+                internalType: 'uint256[]',
+                name: '',
+                type: 'uint256[]'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'address',
+                name: '_stateContractAddr',
+                type: 'address'
+            },
+            {
+                internalType: 'bytes2',
+                name: 'idType',
+                type: 'bytes2'
+            }
+        ],
+        name: 'initialize',
+        outputs: [],
+        stateMutability: 'nonpayable',
+        type: 'function'
+    },
+    {
+        inputs: [
+            {
+                internalType: 'bytes4',
+                name: 'interfaceId',
+                type: 'bytes4'
+            }
+        ],
+        name: 'supportsInterface',
+        outputs: [
+            {
+                internalType: 'bool',
+                name: '',
+                type: 'bool'
+            }
+        ],
+        stateMutability: 'view',
+        type: 'function'
+    }
+];
+class NonMerklizedIssuerBase__factory {
+    static abi = _abi;
+    static createInterface() {
+        return new Interface(_abi);
+    }
+    static connect(address, runner) {
+        return new Contract(address, _abi, runner);
+    }
+}
+
+var NonMerklizedIssuerInterfaces;
+(function (NonMerklizedIssuerInterfaces) {
+    NonMerklizedIssuerInterfaces["InterfaceDetection"] = "0x01ffc9a7";
+    NonMerklizedIssuerInterfaces["InterfaceNonMerklizedIssuer"] = "0x58874949";
+    NonMerklizedIssuerInterfaces["InterfaceGetCredential"] = "0x5d1ca631";
+})(NonMerklizedIssuerInterfaces || (NonMerklizedIssuerInterfaces = {}));
+var ValueHashes;
+(function (ValueHashes) {
+    ValueHashes["BooleanTrue"] = "18586133768512220936620570745912940619677854269274689475585506675881198879027";
+    ValueHashes["BooleanFalse"] = "19014214495641488759237505126948346942972912379615652741039992445865937985820";
+})(ValueHashes || (ValueHashes = {}));
+/**
+ * `OnchainNonMerklizedIssuerAdapter` provides functionality to interact with a non-merklized on-chain credential issuer.
+ * This adapter enables interface detection, credential retrieval, and conversion to the W3C Verifiable Credential format.
+ *
+ * @public
+ * @beta
+ * @class OnchainNonMerklizedIssuerAdapter
+ */
+class OnchainNonMerklizedIssuerAdapter {
+    /**
+     * Initializes an instance of `OnchainNonMerklizedIssuerAdapter`.
+     *
+     * @param ethConnectionConfig The configuration for the Ethereum connection.
+     * @param issuerDid The decentralized identifier (DID) of the issuer.
+     * @param merklizationOptions Optional settings for merklization.
+     */
+    constructor(ethConnectionConfig, issuerDid, options) {
+        if (!ethConnectionConfig.chainId) {
+            throw new Error('Chain ID is required');
+        }
+        this._chainId = ethConnectionConfig.chainId;
+        this._contractAddress = getAddress(hexlify(Id$1.ethAddressFromId(DID.idFromDID(issuerDid))));
+        this._contract = NonMerklizedIssuerBase__factory.connect(this._contractAddress, new JsonRpcProvider(ethConnectionConfig.url));
+        this._issuerDid = issuerDid;
+        this._merklizationOptions = options?.merklizationOptions;
+    }
+    /**
+     * Checks if the contract supports required interfaces.
+     * Throws an error if any required interface is unsupported.
+     *
+     * @throws Error - If required interfaces are not supported.
+     */
+    async isInterfaceSupported() {
+        const supportedInterfaces = [
+            {
+                name: 'Interface detection ERC-165',
+                value: NonMerklizedIssuerInterfaces.InterfaceDetection
+            },
+            {
+                name: 'Interface non-merklized issuer',
+                value: NonMerklizedIssuerInterfaces.InterfaceNonMerklizedIssuer
+            },
+            {
+                name: 'Interface get credential',
+                value: NonMerklizedIssuerInterfaces.InterfaceGetCredential
+            }
+        ];
+        const unsupportedInterfaces = await Promise.all(supportedInterfaces.map(async (interfaceObj) => {
+            const isSupported = await this._contract.supportsInterface(interfaceObj.value);
+            return isSupported ? null : interfaceObj.name;
+        }));
+        const unsupportedInterfacesFiltered = unsupportedInterfaces.filter((interfaceName) => interfaceName !== null);
+        if (unsupportedInterfacesFiltered.length > 0) {
+            throw new Error(`Unsupported interfaces: ${unsupportedInterfacesFiltered.join(', ')}`);
+        }
+    }
+    /**
+     * Retrieves a credential from the on-chain non-merklized contract.
+     * @param userId The user's core.Id.
+     * @param credentialId The unique identifier of the credential.
+     */
+    async getCredential(userId, credentialId) {
+        const [credentialData, coreClaimBigInts, credentialSubjectFields] = await this._contract.getCredential(userId.bigInt(), credentialId);
+        return { credentialData, coreClaimBigInts, credentialSubjectFields };
+    }
+    /**
+     * Retrieves the credential IDs of a user.
+     * @param userId The user's core.Id.
+     * @returns An array of credential IDs.
+     */
+    async getUserCredentialsIds(userId) {
+        return this._contract.getUserCredentialIds(userId.bigInt());
+    }
+    /**
+     * Converts on-chain credential to a verifiable credential.
+     *
+     * @param credentialData Data structure of the credential from the contract.
+     * @param coreClaimBigInts Claim data in bigint format.
+     * @param credentialSubjectFields Subject fields of the credential.
+     */
+    async convertOnChainInfoToW3CCredential(credentialData, coreClaimBigInts, credentialSubjectFields) {
+        const c = new Claim().unMarshalJson(JSON.stringify(coreClaimBigInts.map((b) => b.toString())));
+        const credentialSubject = await this.convertCredentialSubject(c, credentialData.context, credentialData._type, credentialSubjectFields);
+        const credentialRequest = {
+            id: this.credentialId(credentialData.id),
+            credentialSchema: credentialData.credentialSchema.id,
+            type: credentialData._type,
+            credentialSubject: credentialSubject,
+            expiration: c.getExpirationDate()?.getTime(),
+            displayMethod: this.convertDisplayMethod(credentialData.displayMethod),
+            context: credentialData.context,
+            revocationOpts: {
+                id: this._contractAddress,
+                nonce: Number(c.getRevocationNonce()),
+                type: CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023
+            },
+            issuanceDate: getDateFromUnixTimestamp(Number(credentialData.issuanceDate)).getTime()
+        };
+        const existenceProof = await this.existenceProof(c);
+        const w3c = W3CCredential.fromCredentialRequest(this._issuerDid, credentialRequest);
+        w3c.proof = [existenceProof];
+        return w3c;
+    }
+    credentialId(id) {
+        return `urn:iden3:onchain:${this._chainId}:${this._contractAddress}:${id}`;
+    }
+    async convertCredentialSubject(coreClaim, contractContexts, credentialType, credentialSubjectFields) {
+        const contractContextsStr = JSON.stringify({
+            '@context': contractContexts
+        });
+        const credentialSubject = {};
+        for (const f of credentialSubjectFields) {
+            const dataType = await Path.newTypeFromContext(contractContextsStr, `${credentialType}.${f.key}`, this._merklizationOptions);
+            switch (dataType) {
+                case XSDNS.Boolean: {
+                    switch (f.rawValue.toString()) {
+                        case ValueHashes.BooleanTrue:
+                            credentialSubject[f.key] = true;
+                            break;
+                        case ValueHashes.BooleanFalse:
+                            credentialSubject[f.key] = false;
+                            break;
+                    }
+                    break;
+                }
+                case (XSDNS.PositiveInteger):
+                    {
+                        credentialSubject[f.key] = f.value.toString();
+                        break;
+                    }
+                case XSDNS.Integer: {
+                    credentialSubject[f.key] = Number(f.value);
+                    break;
+                }
+                case XSDNS.String: {
+                    this.validateSourceValue(dataType, f.value, f.rawValue);
+                    credentialSubject[f.key] = f.rawValue;
+                    break;
+                }
+                case XSDNS.DateTime: {
+                    const timestamp = BigInt(f.rawValue);
+                    const sourceTimestamp = getDateFromUnixTimestamp(Number(timestamp)).toISOString();
+                    this.validateSourceValue(dataType, f.value, sourceTimestamp);
+                    credentialSubject[f.key] = sourceTimestamp;
+                    break;
+                }
+                case XSDNS.Double: {
+                    const rawFloat = Number(f.rawValue);
+                    this.validateSourceValue(dataType, f.value, rawFloat);
+                    credentialSubject[f.key] = rawFloat;
+                    break;
+                }
+                default: {
+                    throw new Error(`Unsupported data type ${dataType}`);
+                }
+            }
+        }
+        credentialSubject['type'] = credentialType;
+        const subjectId = coreClaim.getId();
+        const subjectDid = DID.parseFromId(subjectId);
+        credentialSubject['id'] = subjectDid.string();
+        return credentialSubject;
+    }
+    async existenceProof(coreClaim) {
+        const [mtpProof, stateInfo] = await this._contract.getClaimProofWithStateInfo(coreClaim.hIndex());
+        if (!mtpProof.existence) {
+            throw new Error('Claim does not exist');
+        }
+        const latestStateHash = Hash$2.fromBigInt(stateInfo.state);
+        const latestClaimsOfRootHash = Hash$2.fromBigInt(stateInfo.claimsRoot);
+        const latestRevocationOfRootHash = Hash$2.fromBigInt(stateInfo.revocationsRoot);
+        const latestRootsOfRootHash = Hash$2.fromBigInt(stateInfo.rootsRoot);
+        const p = new Proof({
+            siblings: mtpProof.siblings.map((s) => Hash$2.fromBigInt(s)),
+            existence: mtpProof.existence,
+            nodeAux: mtpProof.auxExistence
+                ? {
+                    key: Hash$2.fromBigInt(mtpProof.auxIndex),
+                    value: Hash$2.fromBigInt(mtpProof.auxValue)
+                }
+                : undefined
+        });
+        return new Iden3SparseMerkleTreeProof({
+            issuerData: {
+                id: this._issuerDid,
+                state: {
+                    value: latestStateHash,
+                    claimsTreeRoot: latestClaimsOfRootHash,
+                    revocationTreeRoot: latestRevocationOfRootHash,
+                    rootOfRoots: latestRootsOfRootHash
+                }
+            },
+            mtp: p,
+            coreClaim: coreClaim
+        });
+    }
+    async validateSourceValue(dataType, originHash, source) {
+        const sourceHash = await Merklizer.hashValue(dataType, source);
+        if (sourceHash !== originHash) {
+            throw new Error(`Invalid source value for ${dataType} type`);
+        }
+    }
+    convertDisplayMethod(onchainDisplayMethod) {
+        if (!onchainDisplayMethod.id || !onchainDisplayMethod._type) {
+            return undefined;
+        }
+        switch (onchainDisplayMethod._type) {
+            case DisplayMethodType.Iden3BasicDisplayMethodV1: {
+                return {
+                    id: onchainDisplayMethod.id,
+                    type: DisplayMethodType.Iden3BasicDisplayMethodV1
+                };
+            }
+            default: {
+                throw new Error(`Unsupported display method type ${onchainDisplayMethod._type}`);
+            }
+        }
+    }
+}
+
+/**
+ * Represents an adapter for interacting with on-chain issuers.
+ *
+ * @public
+ * @beta
+ * @class OnchainIssuer
+ */
+class OnchainIssuer {
+    /**
+     * Initializes an instance of `Adapter`.
+     * @param config The configuration for the Ethereum connection.
+     * @param merklizationOptions Optional settings for merklization.
+     */
+    constructor(config, options) {
+        this._ethConnectionConfig = config;
+        this._onchainIssuerOptions = options;
+    }
+    /**
+     * Retrieves a credential from the on-chain issuer.
+     * @param issuerDID The issuer's core.DID.
+     * @param userId The user's core.Id.
+     * @param credentialId The unique identifier of the credential.
+     */
+    async getCredential(issuerDID, userDID, credentialId) {
+        const { contract, connection } = this.getContractConnection(issuerDID);
+        const response = await contract.getCredentialAdapterVersion();
+        switch (response) {
+            case '0.0.1': {
+                const adapter = new OnchainNonMerklizedIssuerAdapter(connection, issuerDID, {
+                    merklizationOptions: this._onchainIssuerOptions?.merklizationOptions
+                });
+                await adapter.isInterfaceSupported();
+                const { credentialData, coreClaimBigInts, credentialSubjectFields } = await adapter.getCredential(DID.idFromDID(userDID), credentialId);
+                return await adapter.convertOnChainInfoToW3CCredential(credentialData, coreClaimBigInts, credentialSubjectFields);
+            }
+            default:
+                throw new Error(`Unsupported adapter version ${response}`);
+        }
+    }
+    /**
+     * Retrieves the credential identifiers for a user from the on-chain issuer.
+     * @param issuerDID The issuer's core.DID.
+     * @param userId The user's core.Id.
+     */
+    async getUserCredentialIds(issuerDID, userDID) {
+        const { contract, connection } = this.getContractConnection(issuerDID);
+        const response = await contract.getCredentialAdapterVersion();
+        switch (response) {
+            case '0.0.1': {
+                const adapter = new OnchainNonMerklizedIssuerAdapter(connection, issuerDID, {
+                    merklizationOptions: this._onchainIssuerOptions?.merklizationOptions
+                });
+                await adapter.isInterfaceSupported();
+                return await adapter.getUserCredentialsIds(DID.idFromDID(userDID));
+            }
+            default:
+                throw new Error(`Unsupported adapter version ${response}`);
+        }
+    }
+    getContractConnection(did) {
+        const issuerId = DID.idFromDID(did);
+        const chainId = chainIDfromDID(did);
+        const contractAddress = getAddress(hexlify(Id$1.ethAddressFromId(issuerId)));
+        const connection = this._ethConnectionConfig.find((c) => c.chainId === chainId);
+        if (!connection) {
+            throw new Error(`No connection found for chain ID ${chainId}`);
+        }
+        if (!connection.url) {
+            throw new Error(`No URL found for chain ID ${chainId}`);
+        }
+        const contract = new Contract(contractAddress, abi, new JsonRpcProvider(connection.url));
+        return { contract, connection };
+    }
+}
+
+class DidResolverStateReadonlyStorage {
+    constructor(resolverUrl) {
+        this.resolverUrl = resolverUrl;
+    }
+    async getLatestStateById(id) {
+        return this.getStateInfo(id);
+    }
+    async getStateInfoByIdAndState(id, state) {
+        return this.getStateInfo(id, state);
+    }
+    async getGISTProof(id) {
+        const { didDocument } = await resolveDidDocument(DID.parseFromId(Id$1.fromBigInt(id)), this.resolverUrl);
+        const { global } = this.getIden3StateInfo2023(didDocument);
+        if (!global) {
+            throw new Error('GIST root not found');
+        }
+        const { proof } = global;
+        if (!proof) {
+            throw new Error('GIST proof not found');
+        }
+        return {
+            root: global.root,
+            existence: proof.existence,
+            siblings: proof.siblings?.map((sibling) => BigInt(sibling)),
+            index: BigInt(0),
+            value: BigInt(0),
+            auxExistence: !!proof.node_aux,
+            auxIndex: proof.node_aux ? BigInt(proof.node_aux.key) : BigInt(0),
+            auxValue: proof.node_aux ? BigInt(proof.node_aux.value) : BigInt(0)
+        };
+    }
+    async getGISTRootInfo(root, userId) {
+        const { didDocument } = await resolveDidDocument(DID.parseFromId(Id$1.fromBigInt(userId)), this.resolverUrl, {
+            gist: Hash$2.fromBigInt(root)
+        });
+        const { global } = this.getIden3StateInfo2023(didDocument);
+        if (!global) {
+            throw new Error('GIST root not found');
+        }
+        return global;
+    }
+    getRpcProvider() {
+        return new JsonRpcProvider();
+    }
+    publishState() {
+        throw new Error('publishState method not implemented.');
+    }
+    publishStateGeneric() {
+        throw new Error('publishStateGeneric method not implemented.');
+    }
+    async getStateInfo(id, state) {
+        const opts = state ? { state: Hash$2.fromBigInt(state) } : undefined;
+        const { didDocument } = await resolveDidDocument(DID.parseFromId(Id$1.fromBigInt(id)), this.resolverUrl, opts);
+        const { info } = this.getIden3StateInfo2023(didDocument);
+        return { ...info };
+    }
+    getIden3StateInfo2023(didDocument) {
+        const vm = didDocument.verificationMethod?.find((i) => i.type === 'Iden3StateInfo2023');
+        if (!vm) {
+            throw new Error('Iden3StateInfo2023 verification method not found');
+        }
+        return vm;
+    }
+}
+
+var permitAbi = [
+	{
+		inputs: [
+		],
+		name: "ECDSAInvalidSignature",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint256",
+				name: "length",
+				type: "uint256"
+			}
+		],
+		name: "ECDSAInvalidSignatureLength",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "bytes32",
+				name: "s",
+				type: "bytes32"
+			}
+		],
+		name: "ECDSAInvalidSignatureS",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "allowance",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "needed",
+				type: "uint256"
+			}
+		],
+		name: "ERC20InsufficientAllowance",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "balance",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "needed",
+				type: "uint256"
+			}
+		],
+		name: "ERC20InsufficientBalance",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "approver",
+				type: "address"
+			}
+		],
+		name: "ERC20InvalidApprover",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "receiver",
+				type: "address"
+			}
+		],
+		name: "ERC20InvalidReceiver",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "sender",
+				type: "address"
+			}
+		],
+		name: "ERC20InvalidSender",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			}
+		],
+		name: "ERC20InvalidSpender",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "uint256",
+				name: "deadline",
+				type: "uint256"
+			}
+		],
+		name: "ERC2612ExpiredSignature",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "signer",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			}
+		],
+		name: "ERC2612InvalidSigner",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "account",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "currentNonce",
+				type: "uint256"
+			}
+		],
+		name: "InvalidAccountNonce",
+		type: "error"
+	},
+	{
+		inputs: [
+		],
+		name: "InvalidShortString",
+		type: "error"
+	},
+	{
+		inputs: [
+			{
+				internalType: "string",
+				name: "str",
+				type: "string"
+			}
+		],
+		name: "StringTooLong",
+		type: "error"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "Approval",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+		],
+		name: "EIP712DomainChanged",
+		type: "event"
+	},
+	{
+		anonymous: false,
+		inputs: [
+			{
+				indexed: true,
+				internalType: "address",
+				name: "from",
+				type: "address"
+			},
+			{
+				indexed: true,
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				indexed: false,
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "Transfer",
+		type: "event"
+	},
+	{
+		inputs: [
+		],
+		name: "DOMAIN_SEPARATOR",
+		outputs: [
+			{
+				internalType: "bytes32",
+				name: "",
+				type: "bytes32"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			}
+		],
+		name: "allowance",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "approve",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "account",
+				type: "address"
+			}
+		],
+		name: "balanceOf",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "decimals",
+		outputs: [
+			{
+				internalType: "uint8",
+				name: "",
+				type: "uint8"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "eip712Domain",
+		outputs: [
+			{
+				internalType: "bytes1",
+				name: "fields",
+				type: "bytes1"
+			},
+			{
+				internalType: "string",
+				name: "name",
+				type: "string"
+			},
+			{
+				internalType: "string",
+				name: "version",
+				type: "string"
+			},
+			{
+				internalType: "uint256",
+				name: "chainId",
+				type: "uint256"
+			},
+			{
+				internalType: "address",
+				name: "verifyingContract",
+				type: "address"
+			},
+			{
+				internalType: "bytes32",
+				name: "salt",
+				type: "bytes32"
+			},
+			{
+				internalType: "uint256[]",
+				name: "extensions",
+				type: "uint256[]"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "name",
+		outputs: [
+			{
+				internalType: "string",
+				name: "",
+				type: "string"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			}
+		],
+		name: "nonces",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "owner",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "spender",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			},
+			{
+				internalType: "uint256",
+				name: "deadline",
+				type: "uint256"
+			},
+			{
+				internalType: "uint8",
+				name: "v",
+				type: "uint8"
+			},
+			{
+				internalType: "bytes32",
+				name: "r",
+				type: "bytes32"
+			},
+			{
+				internalType: "bytes32",
+				name: "s",
+				type: "bytes32"
+			}
+		],
+		name: "permit",
+		outputs: [
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "symbol",
+		outputs: [
+			{
+				internalType: "string",
+				name: "",
+				type: "string"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+		],
+		name: "totalSupply",
+		outputs: [
+			{
+				internalType: "uint256",
+				name: "",
+				type: "uint256"
+			}
+		],
+		stateMutability: "view",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "transfer",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	},
+	{
+		inputs: [
+			{
+				internalType: "address",
+				name: "from",
+				type: "address"
+			},
+			{
+				internalType: "address",
+				name: "to",
+				type: "address"
+			},
+			{
+				internalType: "uint256",
+				name: "value",
+				type: "uint256"
+			}
+		],
+		name: "transferFrom",
+		outputs: [
+			{
+				internalType: "bool",
+				name: "",
+				type: "bool"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "function"
+	}
+];
+
+var erc20Abi = [
+	{
+		inputs: [
+			{
+				internalType: "uint256",
+				name: "initialSupply",
+				type: "uint256"
+			}
+		],
+		stateMutability: "nonpayable",
+		type: "constructor"
 	},
 	{
 		inputs: [
@@ -54239,66 +57154,6 @@ var abi = [
 		name: "ERC20InvalidSpender",
 		type: "error"
 	},
-	{
-		inputs: [
-			{
-				internalType: "uint256",
-				name: "deadline",
-				type: "uint256"
-			}
-		],
-		name: "ERC2612ExpiredSignature",
-		type: "error"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "signer",
-				type: "address"
-			},
-			{
-				internalType: "address",
-				name: "owner",
-				type: "address"
-			}
-		],
-		name: "ERC2612InvalidSigner",
-		type: "error"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "account",
-				type: "address"
-			},
-			{
-				internalType: "uint256",
-				name: "currentNonce",
-				type: "uint256"
-			}
-		],
-		name: "InvalidAccountNonce",
-		type: "error"
-	},
-	{
-		inputs: [
-		],
-		name: "InvalidShortString",
-		type: "error"
-	},
-	{
-		inputs: [
-			{
-				internalType: "string",
-				name: "str",
-				type: "string"
-			}
-		],
-		name: "StringTooLong",
-		type: "error"
-	},
 	{
 		anonymous: false,
 		inputs: [
@@ -54324,13 +57179,6 @@ var abi = [
 		name: "Approval",
 		type: "event"
 	},
-	{
-		anonymous: false,
-		inputs: [
-		],
-		name: "EIP712DomainChanged",
-		type: "event"
-	},
 	{
 		anonymous: false,
 		inputs: [
@@ -54356,20 +57204,6 @@ var abi = [
 		name: "Transfer",
 		type: "event"
 	},
-	{
-		inputs: [
-		],
-		name: "DOMAIN_SEPARATOR",
-		outputs: [
-			{
-				internalType: "bytes32",
-				name: "",
-				type: "bytes32"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
 	{
 		inputs: [
 			{
@@ -54451,50 +57285,6 @@ var abi = [
 		stateMutability: "view",
 		type: "function"
 	},
-	{
-		inputs: [
-		],
-		name: "eip712Domain",
-		outputs: [
-			{
-				internalType: "bytes1",
-				name: "fields",
-				type: "bytes1"
-			},
-			{
-				internalType: "string",
-				name: "name",
-				type: "string"
-			},
-			{
-				internalType: "string",
-				name: "version",
-				type: "string"
-			},
-			{
-				internalType: "uint256",
-				name: "chainId",
-				type: "uint256"
-			},
-			{
-				internalType: "address",
-				name: "verifyingContract",
-				type: "address"
-			},
-			{
-				internalType: "bytes32",
-				name: "salt",
-				type: "bytes32"
-			},
-			{
-				internalType: "uint256[]",
-				name: "extensions",
-				type: "uint256[]"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
 	{
 		inputs: [
 		],
@@ -54509,69 +57299,6 @@ var abi = [
 		stateMutability: "view",
 		type: "function"
 	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "owner",
-				type: "address"
-			}
-		],
-		name: "nonces",
-		outputs: [
-			{
-				internalType: "uint256",
-				name: "",
-				type: "uint256"
-			}
-		],
-		stateMutability: "view",
-		type: "function"
-	},
-	{
-		inputs: [
-			{
-				internalType: "address",
-				name: "owner",
-				type: "address"
-			},
-			{
-				internalType: "address",
-				name: "spender",
-				type: "address"
-			},
-			{
-				internalType: "uint256",
-				name: "value",
-				type: "uint256"
-			},
-			{
-				internalType: "uint256",
-				name: "deadline",
-				type: "uint256"
-			},
-			{
-				internalType: "uint8",
-				name: "v",
-				type: "uint8"
-			},
-			{
-				internalType: "bytes32",
-				name: "r",
-				type: "bytes32"
-			},
-			{
-				internalType: "bytes32",
-				name: "s",
-				type: "bytes32"
-			}
-		],
-		name: "permit",
-		outputs: [
-		],
-		stateMutability: "nonpayable",
-		type: "function"
-	},
 	{
 		inputs: [
 		],
@@ -54666,10 +57393,11 @@ var abi = [
  * @returns {Promise<PaymentRequestMessage>}
  */
 async function getPermitSignature(signer, tokenAddress, spender, value, deadline) {
-    const erc20PermitContract = new Contract(tokenAddress, abi, signer);
+    const erc20PermitContract = new Contract(tokenAddress, permitAbi, signer);
     const nonce = await erc20PermitContract.nonces(await signer.getAddress());
     const domainData = await erc20PermitContract.eip712Domain();
     const domain = {
+        name: domainData[1],
         version: domainData[2],
         chainId: domainData[3],
         verifyingContract: tokenAddress
@@ -54692,6 +57420,16 @@ async function getPermitSignature(signer, tokenAddress, spender, value, deadline
     };
     return signer.signTypedData(domain, types, message);
 }
+/**
+ * @beta
+ * getERC20Decimals is a function to retrieve the number of decimals of an ERC20 token
+ * @param {string} tokenAddress - Token address
+ * @param {ethers.ContractRunner} runner - Contract runner
+ */
+async function getERC20Decimals(tokenAddress, runner) {
+    const erc20Contract = new Contract(tokenAddress, erc20Abi, runner);
+    return erc20Contract.decimals();
+}
 
 /**
  * Type of MerkleTree
@@ -56370,6 +59108,24 @@ class Iden3SmtRhsCredentialStatusPublisher {
     }
 }
 
+class DidDocumentCredentialStatusResolver {
+    constructor(didResolverUrl) {
+        this.didResolverUrl = didResolverUrl;
+    }
+    async resolve(credentialStatus, opts) {
+        if (!opts?.issuerDID) {
+            throw new Error('IssuerDID is not set in options');
+        }
+        const url = `${this.didResolverUrl}/1.0/credential-status/${encodeURIComponent(opts.issuerDID.string())}`;
+        const resp = await fetch(url, {
+            method: 'POST',
+            body: JSON.stringify(credentialStatus)
+        });
+        const data = await resp.json();
+        return data;
+    }
+}
+
 /**
  *
  * Wallet instance is a wrapper of CRUD logic for W3C credentials,
@@ -56396,40 +59152,18 @@ class CredentialWallet {
             if (!schema.$metadata.uris['jsonLdContext']) {
                 throw new Error('jsonLdContext is missing is the schema');
             }
-            request.context = request.context ?? [];
-            if (request.displayMethod?.type === DisplayMethodType.Iden3BasicDisplayMethodV1 &&
-                !request.context.includes(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD)) {
-                request.context.push(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD);
-            }
-            const context = [
-                VerifiableConstants.JSONLD_SCHEMA.W3C_CREDENTIAL_2018,
-                ...request.context,
-                VerifiableConstants.JSONLD_SCHEMA.IDEN3_CREDENTIAL,
-                schema.$metadata.uris['jsonLdContext']
-            ];
-            const credentialType = [
-                VerifiableConstants.CREDENTIAL_TYPE.W3C_VERIFIABLE_CREDENTIAL,
-                request.type
-            ];
-            const expirationDate = !request.expiration || request.expiration == 0 ? null : request.expiration;
-            const credentialSubject = request.credentialSubject;
-            credentialSubject['type'] = request.type;
-            const cr = new W3CCredential();
-            cr.id = `urn:${v4()}`;
-            cr['@context'] = context;
-            cr.type = credentialType;
-            cr.expirationDate = expirationDate ? new Date(expirationDate * 1000).toISOString() : undefined;
-            cr.refreshService = request.refreshService;
-            cr.displayMethod = request.displayMethod;
-            cr.issuanceDate = new Date().toISOString();
-            cr.credentialSubject = credentialSubject;
-            cr.issuer = issuer.string();
-            cr.credentialSchema = {
-                id: request.credentialSchema,
-                type: VerifiableConstants.JSON_SCHEMA_VALIDATOR
-            };
-            cr.credentialStatus = this.buildCredentialStatus(request, issuer);
-            return cr;
+            // do copy of request to avoid mutation
+            const r = { ...request };
+            r.context = r.context ?? [];
+            if (r.displayMethod?.type === DisplayMethodType.Iden3BasicDisplayMethodV1 &&
+                !r.context.includes(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD)) {
+                r.context.push(VerifiableConstants.JSONLD_SCHEMA.IDEN3_DISPLAY_METHOD);
+            }
+            r.context.push(schema.$metadata.uris['jsonLdContext']);
+            r.expiration = r.expiration ? r.expiration * 1000 : undefined;
+            r.id = r.id ? r.id : `urn:${v4()}`;
+            r.issuanceDate = r.issuanceDate ? r.issuanceDate * 1000 : Date.now();
+            return W3CCredential.fromCredentialRequest(issuer, r);
         };
         // if no credential status resolvers are provided
         // register default issuer resolver
@@ -56499,51 +59233,6 @@ class CredentialWallet {
         }
         return statusResolver.resolve(credStatus, credentialStatusResolveOptions);
     }
-    /**
-     * Builds credential status
-     * @param {CredentialRequest} request
-     * @returns `CredentialStatus`
-     */
-    buildCredentialStatus(request, issuer) {
-        const credentialStatus = {
-            id: request.revocationOpts.id,
-            type: request.revocationOpts.type,
-            revocationNonce: request.revocationOpts.nonce
-        };
-        switch (request.revocationOpts.type) {
-            case CredentialStatusType.SparseMerkleTreeProof:
-                return {
-                    ...credentialStatus,
-                    id: `${credentialStatus.id.replace(/\/$/, '')}/${credentialStatus.revocationNonce}`
-                };
-            case CredentialStatusType.Iden3ReverseSparseMerkleTreeProof:
-                return {
-                    ...credentialStatus,
-                    id: request.revocationOpts.issuerState
-                        ? `${credentialStatus.id.replace(/\/$/, '')}/node?state=${request.revocationOpts.issuerState}`
-                        : `${credentialStatus.id.replace(/\/$/, '')}`
-                };
-            case CredentialStatusType.Iden3OnchainSparseMerkleTreeProof2023: {
-                const issuerId = DID.idFromDID(issuer);
-                const chainId = getChainId(DID.blockchainFromId(issuerId), DID.networkIdFromId(issuerId));
-                const searchParams = [
-                    ['revocationNonce', request.revocationOpts.nonce?.toString() || ''],
-                    ['contractAddress', `${chainId}:${request.revocationOpts.id}`],
-                    ['state', request.revocationOpts.issuerState || '']
-                ]
-                    .filter(([, value]) => Boolean(value))
-                    .map(([key, value]) => `${key}=${value}`)
-                    .join('&');
-                return {
-                    ...credentialStatus,
-                    // `[did]:[methodid]:[chain]:[network]:[id]/credentialStatus?(revocationNonce=value)&[contractAddress=[chainID]:[contractAddress]]&(state=issuerState)`
-                    id: `${issuer.string()}/credentialStatus?${searchParams}`
-                };
-            }
-            default:
-                return credentialStatus;
-        }
-    }
     /**
      * {@inheritDoc ICredentialWallet.findById}
      */
@@ -58520,10 +61209,34 @@ class FetchHandler extends AbstractMessageHandler {
                 return this.handleFetchRequest(message);
             case PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ISSUANCE_RESPONSE_MESSAGE_TYPE:
                 return this.handleIssuanceResponseMsg(message);
+            case PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE: {
+                const result = await this.handleOnchainOfferMessage(message);
+                if (Array.isArray(result)) {
+                    const credWallet = this.opts?.credentialWallet;
+                    if (!credWallet)
+                        throw new Error('Credential wallet is not provided');
+                    await credWallet.saveAll(result);
+                    return null;
+                }
+                return result;
+            }
             default:
                 return super.handle(message, ctx);
         }
     }
+    async handleOnchainOfferMessage(offerMessage) {
+        if (!this.opts?.onchainIssuer) {
+            throw new Error('onchain issuer is not provided');
+        }
+        const credentials = [];
+        for (const credentialInfo of offerMessage.body.credentials) {
+            const issuerDID = DID.parse(offerMessage.from);
+            const userDID = DID.parse(offerMessage.to);
+            const credential = await this.opts.onchainIssuer.getCredential(issuerDID, userDID, BigInt(credentialInfo.id));
+            credentials.push(credential);
+        }
+        return credentials;
+    }
     async handleOfferMessage(offerMessage, ctx) {
         if (!ctx.mediaType) {
             ctx.mediaType = MediaType.ZKPMessage;
@@ -58608,6 +61321,14 @@ class FetchHandler extends AbstractMessageHandler {
         }
         throw new Error('invalid protocol message response');
     }
+    /**
+     * Handles only messages with credentials/1.0/onchain-offer type
+     * @beta
+     */
+    async handleOnchainOffer(offer) {
+        const offerMessage = await FetchHandler.unpackMessage(this._packerMgr, offer, PROTOCOL_MESSAGE_TYPE.CREDENTIAL_ONCHAIN_OFFER_MESSAGE_TYPE);
+        return this.handleOnchainOfferMessage(offerMessage);
+    }
     async handleFetchRequest(msgRequest) {
         if (!msgRequest.to) {
             throw new Error("failed request. empty 'to' field");
@@ -59261,19 +61982,20 @@ function createPaymentRequest(sender, receiver, agent, payments, opts) {
     return request;
 }
 async function verifyEIP712TypedData(data, resolver) {
+    const convertedAmount = await convertPaymentAmount(data.amount, data.currency);
     const paymentData = data.type === PaymentRequestDataType.Iden3PaymentRailsRequestV1
         ? {
             recipient: data.recipient,
-            amount: data.amount,
-            expirationDate: new Date(data.expirationDate).getTime(),
+            amount: convertedAmount,
+            expirationDate: getUnixTimestamp(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: getUnixTimestamp(new Date(data.expirationDate)),
             nonce: data.nonce,
             metadata: '0x'
         };
@@ -59296,6 +62018,30 @@ async function verifyEIP712TypedData(data, resolver) {
     }
     throw new Error(`failed request. no matching verificationMethod`);
 }
+async function convertPaymentAmount(amount, currency) {
+    let convertedAmount = 0n;
+    switch (currency) {
+        case SupportedCurrencies.ETH:
+        case SupportedCurrencies.POL:
+        case SupportedCurrencies.MATIC:
+            convertedAmount = parseEther(amount.toString());
+            break;
+        case SupportedCurrencies.ETH_WEI:
+            convertedAmount = parseUnits$1(amount.toString(), 'wei');
+            break;
+        case SupportedCurrencies.ETH_GWEI:
+            convertedAmount = parseUnits$1(amount.toString(), 'gwei');
+            break;
+        case SupportedCurrencies.USDC:
+        case 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
@@ -59493,26 +62239,25 @@ class PaymentHandler extends AbstractMessageHandler {
                 if (type === 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 === PaymentRequestDataType.Iden3PaymentRailsRequestV1
                     ? {
                         recipient,
-                        amount,
-                        expirationDate: expirationTime,
+                        amount: convertedAmount,
+                        expirationDate: getUnixTimestamp(expirationDateRequired),
                         nonce,
                         metadata: '0x'
                     }
                     : {
                         tokenAddress,
                         recipient,
-                        amount,
-                        expirationDate: expirationTime,
+                        amount: convertedAmount,
+                        expirationDate: getUnixTimestamp(expirationDateRequired),
                         nonce,
                         metadata: '0x'
                     };
@@ -59546,7 +62291,7 @@ class PaymentHandler extends AbstractMessageHandler {
                     recipient,
                     amount: amount.toString(),
                     currency,
-                    expirationDate: new Date(expirationTime).toISOString(),
+                    expirationDate: expirationDateRequired.toISOString(),
                     nonce: nonce.toString(),
                     metadata: '0x',
                     proof
@@ -61672,5 +64417,5 @@ class IdentityWallet {
     }
 }
 
-export { AbstractMessageHandler, AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DIDDocumentSignature, DataPrepareHandlerFunc, DisplayMethodType, Ed25519Provider, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, FunctionSignatures, Iden3OnchainSmtCredentialStatusPublisher, Iden3SmtRhsCredentialStatusPublisher, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, InputGenerator, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, MessageBus, MessageHandler, NativeProver, OnChainResolver, OnChainRevocationStorage, OnChainZKPVerifier, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PaymentFeatures, PaymentHandler, PaymentRequestDataType, PaymentType, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, SupportedCurrencies, SupportedPaymentProofType, TransactionService, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes$1 as base58ToBytes, base64ToBytes$1 as base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildAccept, buildDIDFromEthPubKey, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58$1 as bytesToBase58, bytesToBase64, bytesToBase64url$1 as bytesToBase64url, bytesToHex$3 as bytesToHex, cacheLoader, calculateCoreSchemaHash, calculateQueryHashV2, calculateQueryHashV3, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, createAuthorizationRequest, createAuthorizationRequestWithMessage, createPayment, createPaymentRequest, createProposal, createProposalRequest, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url$1 as decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fieldValueFromVerifiablePresentation, fillCoreClaimSlot, fillSlot, findCredentialType, findValue, generateProfileDID, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getPermitSignature, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$3 as hexToBytes, isEthereumIdentity, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, parseAcceptProfile, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolveDidDocument, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyEIP712TypedData, verifyExpiresTime, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
+export { AbstractMessageHandler, AbstractPrivateKeyStore, AgentResolver, AtomicQueryMTPV2Inputs, AtomicQueryMTPV2OnChainInputs, AtomicQueryMTPV2OnChainPubSignals, AtomicQueryMTPV2PubSignals, AtomicQuerySigV2Inputs, AtomicQuerySigV2OnChainCircuitInputs, AtomicQuerySigV2OnChainInputs, AtomicQuerySigV2OnChainPubSignals, AtomicQuerySigV2PubSignals, AtomicQueryV3Inputs, AtomicQueryV3OnChainInputs, AtomicQueryV3OnChainPubSignals, AtomicQueryV3PubSignals, AuthHandler, AuthV2Inputs, AuthV2PubSignals, BJJSignatureProof2021, BaseConfig, BjjProvider, BrowserDataSource, CircuitClaim, CircuitError, CircuitId, CircuitStorage, ContractRequestHandler, CredentialOfferStatus, CredentialProposalHandler, CredentialStatusPublisherRegistry, CredentialStatusResolverRegistry, CredentialStatusType, CredentialStorage, CredentialWallet, DIDDocumentJSONSchema, DIDDocumentSignature, DataPrepareHandlerFunc, DidDocumentCredentialStatusResolver, DidResolverStateReadonlyStorage, DisplayMethodType, Ed25519Provider, ErrorEmptyAuthClaimNonRevProof, ErrorEmptyAuthClaimProof, ErrorEmptyChallengeSignature, ErrorEmptyClaimNonRevProof, ErrorEmptyClaimProof, ErrorEmptyClaimSignature, ErrorEmptyIssuerAuthClaimNonRevProof, ErrorEmptyIssuerAuthClaimProof, ErrorUserStateInRelayClaimProof, EthStateStorage, FSCircuitStorage, FetchHandler, FilterQuery, FunctionSignatures, Iden3OnchainSmtCredentialStatusPublisher, Iden3SmtRhsCredentialStatusPublisher, Iden3SparseMerkleTreeProof, IdentityStorage, IdentityWallet, InMemoryDataSource, InMemoryMerkleTreeStorage, InMemoryPrivateKeyStore, IndexedDBDataSource, IndexedDBPrivateKeyStore, InputGenerator, IssuerResolver, JSON_SCHEMA_VALIDATORS_REGISTRY, JWSPacker, JsonSchemaValidator, KMS, KmsKeyType, LDParser, LinkedMultiQueryInputs, LinkedMultiQueryPubSignals, LocalStoragePrivateKeyStore, MerkleTreeIndexedDBStorage, MerkleTreeLocalStorage, MerkleTreeType, MerklizedRootPosition, MessageBus, MessageHandler, NativeProver, OnChainResolver, OnChainRevocationStorage, OnChainZKPVerifier, OnchainIssuer, Operators, constants as PROTOCOL_CONSTANTS, PackageManager, Parser, PaymentFeatures, PaymentHandler, PaymentRequestDataType, PaymentType, PlainPacker, ProofNode, ProofPurpose, ProofService, ProofType, PubSignalsVerifier, Query, QueryOperators, RHSResolver, RefreshHandler, RefreshServiceType, RevocationStatusHandler, SDK_EVENTS, Scalar, SearchError, Sec256k1Provider, StandardJSONCredentialsQueryFilter, StateTransitionInputs, StateTransitionPubSignals, SubjectPosition, SupportedCurrencies, SupportedPaymentProofType, TransactionService, ValueProof, Vector, VerifiableConstants, VerificationHandlerFunc, W3CCredential, XSDNS, ZKPPacker, availableTypesOperators, base58ToBytes$1 as base58ToBytes, base64ToBytes$1 as base64ToBytes, base64UrlToBytes, bigIntArrayToStringArray, bigIntCompare, buildAccept, buildDIDFromEthPubKey, buildFieldPath, buildTreeState, buildVerifierId, byteDecoder, byteEncoder, bytesToBase58$1 as bytesToBase58, bytesToBase64, bytesToBase64url$1 as bytesToBase64url, bytesToHex$3 as bytesToHex, cacheLoader, calculateCoreSchemaHash, calculateQueryHashV2, calculateQueryHashV3, checkCircuitOperator, checkCircuitQueriesLength, checkDataInField, checkQueryRequest, circuitValidator, comparatorOptions, convertPaymentAmount, createAuthorizationRequest, createAuthorizationRequestWithMessage, createPayment, createPaymentRequest, createProposal, createProposalRequest, createSchemaHash, createVerifiablePresentation, credentialSubjectKey, dataFillsSlot, decodeBase64url$1 as decodeBase64url, defaultEthConnectionConfig, defaultMTLevels, defaultMTLevelsClaim, defaultMTLevelsOnChain, defaultValueArraySize, defineMerklizedRootPosition, encodeBase64url, existenceToInt, extractProof, extractPublicKeyBytes, factoryComparer, fieldToByteArray, fieldValueFromVerifiablePresentation, fillCoreClaimSlot, fillSlot, findCredentialType, findValue, generateProfileDID, getERC20Decimals, getFieldSlotIndex, getKMSIdByAuthCredential, getNodeAuxValue, getNodesRepresentation, getOperatorNameByValue, getPermitSignature, getProperties, getSerializationAttrFromContext, getSerializationAttrFromParsedContext, getUserDIDFromCredential, hexToBytes$3 as hexToBytes, isEthereumIdentity, isGenesisState, isGenesisStateId, isIssuerGenesis, isValidOperation, keyPath, mergeObjects, parseAcceptProfile, parseCoreClaimSlots, parseCredentialSubject, parseQueriesMetadata, parseQueryMetadata, parseSerializationAttr, prepareCircuitArrayValues, prepareSiblingsStr, processZeroKnowledgeProofRequests, pushHashesToRHS, resolveDIDDocumentAuth, resolveDidDocument, resolvePath, resolveVerificationMethods, strMTHex, stringByPath, subjectPositionIndex, swapEndianness, toClaimNonRevStatus, toGISTProof, toRevocationStatus, transformQueryValueToBigInts, userStateError, validateDIDDocumentAuth, validateDisclosureNativeSDSupport, validateDisclosureV2Circuit, validateEmptyCredentialSubjectNoopNativeSupport, validateEmptyCredentialSubjectV2Circuit, validateOperators, validateTreeState, verifyEIP712TypedData, verifyExpiresTime, verifyFieldValueInclusionNativeExistsSupport, verifyFieldValueInclusionV2, witnessBuilder };
 //# sourceMappingURL=index.js.map