@0xpolygonid/js-sdk 1.24.1 → 1.26.0

package/dist/browser/umd/index.js

@@ -1428,9 +1428,14 @@ var PolygonIdSdk = (function (exports) {
         if (opts?.gist) {
             url += `${url.includes('?') ? '&' : '?'}gist=${opts.gist.hex()}`;
         }
-        const resp = await fetch(url);
-        const data = await resp.json();
-        return data;
+        try {
+            const resp = await fetch(url);
+            const data = await resp.json();
+            return data;
+        }
+        catch (e) {
+            throw new Error(`Failed to resolve DID document for ${did} ${e}`);
+        }
     };
     const buildDIDFromEthPubKey = (didType, pubKeyEth) => {
         // Use Keccak-256 hash function to get public key hash
@@ -5451,7 +5456,7 @@ var PolygonIdSdk = (function (exports) {
       throw new Error('Unknown type, must be binary type');
     };
     const fromString$2 = str => new TextEncoder().encode(str);
-    const toString$8 = b => new TextDecoder().decode(b);
+    const toString$7 = b => new TextDecoder().decode(b);
 
     class Encoder {
       constructor(name, prefix, baseEncode) {
@@ -5608,7 +5613,7 @@ var PolygonIdSdk = (function (exports) {
     const identity$1 = from({
       prefix: '\0',
       name: 'identity',
-      encode: buf => toString$8(buf),
+      encode: buf => toString$7(buf),
       decode: str => fromString$2(str)
     });
 
@@ -5972,7 +5977,7 @@ var PolygonIdSdk = (function (exports) {
       return base.decoder.decode(`${ base.prefix }${ string }`);
     }
 
-    function toString$7(array, encoding = 'utf8') {
+    function toString$6(array, encoding = 'utf8') {
       const base = BASES[encoding];
       if (!base) {
         throw new Error(`Unsupported encoding "${ encoding }"`);
@@ -6366,19 +6371,19 @@ var PolygonIdSdk = (function (exports) {
     ];
 
     /** @type {Record<BaseName,Base>} */
-    const names$2 = constants$2.reduce((prev, tupple) => {
+    const names$1 = constants$2.reduce((prev, tupple) => {
       prev[tupple[0]] = new Base(tupple[0], tupple[1], tupple[2], tupple[3]);
       return prev
     }, /** @type {Record<BaseName,Base>} */({}));
 
     /** @type {Record<BaseCode,Base>} */
     const codes$1 = constants$2.reduce((prev, tupple) => {
-      prev[tupple[1]] = names$2[tupple[0]];
+      prev[tupple[1]] = names$1[tupple[0]];
       return prev
     }, /** @type {Record<BaseCode,Base>} */({}));
 
     var constants_1 = {
-      names: names$2,
+      names: names$1,
       codes: codes$1
     };
 
@@ -7150,7 +7155,7 @@ var PolygonIdSdk = (function (exports) {
     const bech32 = /* @__PURE__ */ genBech32('bech32');
 
     const u8a$2 = {
-      toString: toString$7,
+      toString: toString$6,
       fromString: fromString$1,
       concat: concat$2
     };
@@ -7348,7 +7353,7 @@ var PolygonIdSdk = (function (exports) {
     const keccak = keccak_256$1;
     function toEthereumAddress(hexPublicKey) {
       const hashInput = fromString$1(hexPublicKey.slice(2), 'base16');
-      return `0x${toString$7(keccak(hashInput).slice(-20), 'base16')}`;
+      return `0x${toString$6(keccak(hashInput).slice(-20), 'base16')}`;
     }
 
     /**
@@ -7872,6 +7877,7 @@ var PolygonIdSdk = (function (exports) {
     /**
      * Media types for Payment supported currencies
      * @beta
+     * @deprecated
      * @enum {string}
      */
     exports.SupportedCurrencies = void 0;
@@ -7881,8 +7887,6 @@ var PolygonIdSdk = (function (exports) {
         SupportedCurrencies["ETH_GWEI"] = "ETHGWEI";
         SupportedCurrencies["MATIC"] = "MATIC";
         SupportedCurrencies["POL"] = "POL";
-        SupportedCurrencies["USDT"] = "USDT";
-        SupportedCurrencies["USDC"] = "USDC";
     })(exports.SupportedCurrencies || (exports.SupportedCurrencies = {}));
     /**
      * Supported features for payment-request
@@ -22501,16 +22505,16 @@ var PolygonIdSdk = (function (exports) {
     	
     } (util));
 
-    var names$1 = {};
+    var names = {};
 
     var hasRequiredNames;
 
     function requireNames () {
-    	if (hasRequiredNames) return names$1;
+    	if (hasRequiredNames) return names;
     	hasRequiredNames = 1;
-    	Object.defineProperty(names$1, "__esModule", { value: true });
+    	Object.defineProperty(names, "__esModule", { value: true });
     	const codegen_1 = requireCodegen();
-    	const names = {
+    	const names$1 = {
     	    // validation function arguments
     	    data: new codegen_1.Name("data"),
     	    // args passed from referencing schema
@@ -22533,9 +22537,9 @@ var PolygonIdSdk = (function (exports) {
     	    jsonLen: new codegen_1.Name("jsonLen"),
     	    jsonPart: new codegen_1.Name("jsonPart"),
     	};
-    	names$1.default = names;
+    	names.default = names$1;
     	
-    	return names$1;
+    	return names;
     }
 
     var hasRequiredErrors;
@@ -30969,8 +30973,8 @@ var PolygonIdSdk = (function (exports) {
      *
      *  @_subsection: api/utils:Math Helpers  [about-maths]
      */
-    const BN_0$9 = BigInt(0);
-    const BN_1$4 = BigInt(1);
+    const BN_0$8 = BigInt(0);
+    const BN_1$3 = BigInt(1);
     //const BN_Max256 = (BN_1 << BigInt(256)) - BN_1;
     // IEEE 754 support 53-bits of mantissa
     const maxValue = 0x1fffffffffffff;
@@ -30983,13 +30987,13 @@ var PolygonIdSdk = (function (exports) {
     function fromTwos(_value, _width) {
         const value = getUint(_value, "value");
         const width = BigInt(getNumber(_width, "width"));
-        assert$2((value >> width) === BN_0$9, "overflow", "NUMERIC_FAULT", {
+        assert$2((value >> width) === BN_0$8, "overflow", "NUMERIC_FAULT", {
             operation: "fromTwos", fault: "overflow", value: _value
         });
         // Top bit set; treat as a negative value
-        if (value >> (width - BN_1$4)) {
-            const mask = (BN_1$4 << width) - BN_1$4;
-            return -(((~value) & mask) + BN_1$4);
+        if (value >> (width - BN_1$3)) {
+            const mask = (BN_1$3 << width) - BN_1$3;
+            return -(((~value) & mask) + BN_1$3);
         }
         return value;
     }
@@ -31002,14 +31006,14 @@ var PolygonIdSdk = (function (exports) {
     function toTwos(_value, _width) {
         let value = getBigInt(_value, "value");
         const width = BigInt(getNumber(_width, "width"));
-        const limit = (BN_1$4 << (width - BN_1$4));
-        if (value < BN_0$9) {
+        const limit = (BN_1$3 << (width - BN_1$3));
+        if (value < BN_0$8) {
             value = -value;
             assert$2(value <= limit, "too low", "NUMERIC_FAULT", {
                 operation: "toTwos", fault: "overflow", value: _value
             });
-            const mask = (BN_1$4 << width) - BN_1$4;
-            return ((~value) & mask) + BN_1$4;
+            const mask = (BN_1$3 << width) - BN_1$3;
+            return ((~value) & mask) + BN_1$3;
         }
         else {
             assert$2(value < limit, "too high", "NUMERIC_FAULT", {
@@ -31024,7 +31028,7 @@ var PolygonIdSdk = (function (exports) {
     function mask(_value, _bits) {
         const value = getUint(_value, "value");
         const bits = BigInt(getNumber(_bits, "bits"));
-        return value & ((BN_1$4 << bits) - BN_1$4);
+        return value & ((BN_1$3 << bits) - BN_1$3);
     }
     /**
      *  Gets a BigInt from %%value%%. If it is an invalid value for
@@ -31059,7 +31063,7 @@ var PolygonIdSdk = (function (exports) {
      */
     function getUint(value, name) {
         const result = getBigInt(value, name);
-        assert$2(result >= BN_0$9, "unsigned value cannot be negative", "NUMERIC_FAULT", {
+        assert$2(result >= BN_0$8, "unsigned value cannot be negative", "NUMERIC_FAULT", {
             fault: "overflow", operation: "getUint", value
         });
         return result;
@@ -31145,7 +31149,7 @@ var PolygonIdSdk = (function (exports) {
      */
     function toBeArray(_value) {
         const value = getUint(_value, "value");
-        if (value === BN_0$9) {
+        if (value === BN_0$8) {
             return new Uint8Array([]);
         }
         let hex = value.toString(16);
@@ -32377,526 +32381,6 @@ var PolygonIdSdk = (function (exports) {
         return new Promise((resolve) => setTimeout(resolve, delay));
     }
 
-    /**
-     *  The **FixedNumber** class permits using values with decimal places,
-     *  using fixed-pont math.
-     *
-     *  Fixed-point math is still based on integers under-the-hood, but uses an
-     *  internal offset to store fractional components below, and each operation
-     *  corrects for this after each operation.
-     *
-     *  @_section: api/utils/fixed-point-math:Fixed-Point Maths  [about-fixed-point-math]
-     */
-    const BN_N1 = BigInt(-1);
-    const BN_0$8 = BigInt(0);
-    const BN_1$3 = BigInt(1);
-    const BN_5 = BigInt(5);
-    const _guard$3 = {};
-    // Constant to pull zeros from for multipliers
-    let Zeros$1 = "0000";
-    while (Zeros$1.length < 80) {
-        Zeros$1 += Zeros$1;
-    }
-    // Returns a string "1" followed by decimal "0"s
-    function getTens(decimals) {
-        let result = Zeros$1;
-        while (result.length < decimals) {
-            result += result;
-        }
-        return BigInt("1" + result.substring(0, decimals));
-    }
-    function checkValue(val, format, safeOp) {
-        const width = BigInt(format.width);
-        if (format.signed) {
-            const limit = (BN_1$3 << (width - BN_1$3));
-            assert$2(safeOp == null || (val >= -limit && val < limit), "overflow", "NUMERIC_FAULT", {
-                operation: safeOp, fault: "overflow", value: val
-            });
-            if (val > BN_0$8) {
-                val = fromTwos(mask(val, width), width);
-            }
-            else {
-                val = -fromTwos(mask(-val, width), width);
-            }
-        }
-        else {
-            const limit = (BN_1$3 << width);
-            assert$2(safeOp == null || (val >= 0 && val < limit), "overflow", "NUMERIC_FAULT", {
-                operation: safeOp, fault: "overflow", value: val
-            });
-            val = (((val % limit) + limit) % limit) & (limit - BN_1$3);
-        }
-        return val;
-    }
-    function getFormat(value) {
-        if (typeof (value) === "number") {
-            value = `fixed128x${value}`;
-        }
-        let signed = true;
-        let width = 128;
-        let decimals = 18;
-        if (typeof (value) === "string") {
-            // Parse the format string
-            if (value === "fixed") ;
-            else if (value === "ufixed") {
-                signed = false;
-            }
-            else {
-                const match = value.match(/^(u?)fixed([0-9]+)x([0-9]+)$/);
-                assertArgument(match, "invalid fixed format", "format", value);
-                signed = (match[1] !== "u");
-                width = parseInt(match[2]);
-                decimals = parseInt(match[3]);
-            }
-        }
-        else if (value) {
-            // Extract the values from the object
-            const v = value;
-            const check = (key, type, defaultValue) => {
-                if (v[key] == null) {
-                    return defaultValue;
-                }
-                assertArgument(typeof (v[key]) === type, "invalid fixed format (" + key + " not " + type + ")", "format." + key, v[key]);
-                return v[key];
-            };
-            signed = check("signed", "boolean", signed);
-            width = check("width", "number", width);
-            decimals = check("decimals", "number", decimals);
-        }
-        assertArgument((width % 8) === 0, "invalid FixedNumber width (not byte aligned)", "format.width", width);
-        assertArgument(decimals <= 80, "invalid FixedNumber decimals (too large)", "format.decimals", decimals);
-        const name = (signed ? "" : "u") + "fixed" + String(width) + "x" + String(decimals);
-        return { signed, width, decimals, name };
-    }
-    function toString$6(val, decimals) {
-        let negative = "";
-        if (val < BN_0$8) {
-            negative = "-";
-            val *= BN_N1;
-        }
-        let str = val.toString();
-        // No decimal point for whole values
-        if (decimals === 0) {
-            return (negative + str);
-        }
-        // Pad out to the whole component (including a whole digit)
-        while (str.length <= decimals) {
-            str = Zeros$1 + str;
-        }
-        // Insert the decimal point
-        const index = str.length - decimals;
-        str = str.substring(0, index) + "." + str.substring(index);
-        // Trim the whole component (leaving at least one 0)
-        while (str[0] === "0" && str[1] !== ".") {
-            str = str.substring(1);
-        }
-        // Trim the decimal component (leaving at least one 0)
-        while (str[str.length - 1] === "0" && str[str.length - 2] !== ".") {
-            str = str.substring(0, str.length - 1);
-        }
-        return (negative + str);
-    }
-    /**
-     *  A FixedNumber represents a value over its [[FixedFormat]]
-     *  arithmetic field.
-     *
-     *  A FixedNumber can be used to perform math, losslessly, on
-     *  values which have decmial places.
-     *
-     *  A FixedNumber has a fixed bit-width to store values in, and stores all
-     *  values internally by multiplying the value by 10 raised to the power of
-     *  %%decimals%%.
-     *
-     *  If operations are performed that cause a value to grow too high (close to
-     *  positive infinity) or too low (close to negative infinity), the value
-     *  is said to //overflow//.
-     *
-     *  For example, an 8-bit signed value, with 0 decimals may only be within
-     *  the range ``-128`` to ``127``; so ``-128 - 1`` will overflow and become
-     *  ``127``. Likewise, ``127 + 1`` will overflow and become ``-127``.
-     *
-     *  Many operation have a normal and //unsafe// variant. The normal variant
-     *  will throw a [[NumericFaultError]] on any overflow, while the //unsafe//
-     *  variant will silently allow overflow, corrupting its value value.
-     *
-     *  If operations are performed that cause a value to become too small
-     *  (close to zero), the value loses precison and is said to //underflow//.
-     *
-     *  For example, an value with 1 decimal place may store a number as small
-     *  as ``0.1``, but the value of ``0.1 / 2`` is ``0.05``, which cannot fit
-     *  into 1 decimal place, so underflow occurs which means precision is lost
-     *  and the value becomes ``0``.
-     *
-     *  Some operations have a normal and //signalling// variant. The normal
-     *  variant will silently ignore underflow, while the //signalling// variant
-     *  will thow a [[NumericFaultError]] on underflow.
-     */
-    class FixedNumber {
-        /**
-         *  The specific fixed-point arithmetic field for this value.
-         */
-        format;
-        #format;
-        // The actual value (accounting for decimals)
-        #val;
-        // A base-10 value to multiple values by to maintain the magnitude
-        #tens;
-        /**
-         *  This is a property so console.log shows a human-meaningful value.
-         *
-         *  @private
-         */
-        _value;
-        // Use this when changing this file to get some typing info,
-        // but then switch to any to mask the internal type
-        //constructor(guard: any, value: bigint, format: _FixedFormat) {
-        /**
-         *  @private
-         */
-        constructor(guard, value, format) {
-            assertPrivate(guard, _guard$3, "FixedNumber");
-            this.#val = value;
-            this.#format = format;
-            const _value = toString$6(value, format.decimals);
-            defineProperties(this, { format: format.name, _value });
-            this.#tens = getTens(format.decimals);
-        }
-        /**
-         *  If true, negative values are permitted, otherwise only
-         *  positive values and zero are allowed.
-         */
-        get signed() { return this.#format.signed; }
-        /**
-         *  The number of bits available to store the value.
-         */
-        get width() { return this.#format.width; }
-        /**
-         *  The number of decimal places in the fixed-point arithment field.
-         */
-        get decimals() { return this.#format.decimals; }
-        /**
-         *  The value as an integer, based on the smallest unit the
-         *  [[decimals]] allow.
-         */
-        get value() { return this.#val; }
-        #checkFormat(other) {
-            assertArgument(this.format === other.format, "incompatible format; use fixedNumber.toFormat", "other", other);
-        }
-        #checkValue(val, safeOp) {
-            /*
-                    const width = BigInt(this.width);
-                    if (this.signed) {
-                        const limit = (BN_1 << (width - BN_1));
-                        assert(safeOp == null || (val >= -limit  && val < limit), "overflow", "NUMERIC_FAULT", {
-                            operation: <string>safeOp, fault: "overflow", value: val
-                        });
-            
-                        if (val > BN_0) {
-                            val = fromTwos(mask(val, width), width);
-                        } else {
-                            val = -fromTwos(mask(-val, width), width);
-                        }
-            
-                    } else {
-                        const masked = mask(val, width);
-                        assert(safeOp == null || (val >= 0 && val === masked), "overflow", "NUMERIC_FAULT", {
-                            operation: <string>safeOp, fault: "overflow", value: val
-                        });
-                        val = masked;
-                    }
-            */
-            val = checkValue(val, this.#format, safeOp);
-            return new FixedNumber(_guard$3, val, this.#format);
-        }
-        #add(o, safeOp) {
-            this.#checkFormat(o);
-            return this.#checkValue(this.#val + o.#val, safeOp);
-        }
-        /**
-         *  Returns a new [[FixedNumber]] with the result of %%this%% added
-         *  to %%other%%, ignoring overflow.
-         */
-        addUnsafe(other) { return this.#add(other); }
-        /**
-         *  Returns a new [[FixedNumber]] with the result of %%this%% added
-         *  to %%other%%. A [[NumericFaultError]] is thrown if overflow
-         *  occurs.
-         */
-        add(other) { return this.#add(other, "add"); }
-        #sub(o, safeOp) {
-            this.#checkFormat(o);
-            return this.#checkValue(this.#val - o.#val, safeOp);
-        }
-        /**
-         *  Returns a new [[FixedNumber]] with the result of %%other%% subtracted
-         *  from %%this%%, ignoring overflow.
-         */
-        subUnsafe(other) { return this.#sub(other); }
-        /**
-         *  Returns a new [[FixedNumber]] with the result of %%other%% subtracted
-         *  from %%this%%. A [[NumericFaultError]] is thrown if overflow
-         *  occurs.
-         */
-        sub(other) { return this.#sub(other, "sub"); }
-        #mul(o, safeOp) {
-            this.#checkFormat(o);
-            return this.#checkValue((this.#val * o.#val) / this.#tens, safeOp);
-        }
-        /**
-         *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
-         *  by %%other%%, ignoring overflow and underflow (precision loss).
-         */
-        mulUnsafe(other) { return this.#mul(other); }
-        /**
-         *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
-         *  by %%other%%. A [[NumericFaultError]] is thrown if overflow
-         *  occurs.
-         */
-        mul(other) { return this.#mul(other, "mul"); }
-        /**
-         *  Returns a new [[FixedNumber]] with the result of %%this%% multiplied
-         *  by %%other%%. A [[NumericFaultError]] is thrown if overflow
-         *  occurs or if underflow (precision loss) occurs.
-         */
-        mulSignal(other) {
-            this.#checkFormat(other);
-            const value = this.#val * other.#val;
-            assert$2((value % this.#tens) === BN_0$8, "precision lost during signalling mul", "NUMERIC_FAULT", {
-                operation: "mulSignal", fault: "underflow", value: this
-            });
-            return this.#checkValue(value / this.#tens, "mulSignal");
-        }
-        #div(o, safeOp) {
-            assert$2(o.#val !== BN_0$8, "division by zero", "NUMERIC_FAULT", {
-                operation: "div", fault: "divide-by-zero", value: this
-            });
-            this.#checkFormat(o);
-            return this.#checkValue((this.#val * this.#tens) / o.#val, safeOp);
-        }
-        /**
-         *  Returns a new [[FixedNumber]] with the result of %%this%% divided
-         *  by %%other%%, ignoring underflow (precision loss). A
-         *  [[NumericFaultError]] is thrown if overflow occurs.
-         */
-        divUnsafe(other) { return this.#div(other); }
-        /**
-         *  Returns a new [[FixedNumber]] with the result of %%this%% divided
-         *  by %%other%%, ignoring underflow (precision loss). A
-         *  [[NumericFaultError]] is thrown if overflow occurs.
-         */
-        div(other) { return this.#div(other, "div"); }
-        /**
-         *  Returns a new [[FixedNumber]] with the result of %%this%% divided
-         *  by %%other%%. A [[NumericFaultError]] is thrown if underflow
-         *  (precision loss) occurs.
-         */
-        divSignal(other) {
-            assert$2(other.#val !== BN_0$8, "division by zero", "NUMERIC_FAULT", {
-                operation: "div", fault: "divide-by-zero", value: this
-            });
-            this.#checkFormat(other);
-            const value = (this.#val * this.#tens);
-            assert$2((value % other.#val) === BN_0$8, "precision lost during signalling div", "NUMERIC_FAULT", {
-                operation: "divSignal", fault: "underflow", value: this
-            });
-            return this.#checkValue(value / other.#val, "divSignal");
-        }
-        /**
-         *  Returns a comparison result between %%this%% and %%other%%.
-         *
-         *  This is suitable for use in sorting, where ``-1`` implies %%this%%
-         *  is smaller, ``1`` implies %%this%% is larger and ``0`` implies
-         *  both are equal.
-         */
-        cmp(other) {
-            let a = this.value, b = other.value;
-            // Coerce a and b to the same magnitude
-            const delta = this.decimals - other.decimals;
-            if (delta > 0) {
-                b *= getTens(delta);
-            }
-            else if (delta < 0) {
-                a *= getTens(-delta);
-            }
-            // Comnpare
-            if (a < b) {
-                return -1;
-            }
-            if (a > b) {
-                return 1;
-            }
-            return 0;
-        }
-        /**
-         *  Returns true if %%other%% is equal to %%this%%.
-         */
-        eq(other) { return this.cmp(other) === 0; }
-        /**
-         *  Returns true if %%other%% is less than to %%this%%.
-         */
-        lt(other) { return this.cmp(other) < 0; }
-        /**
-         *  Returns true if %%other%% is less than or equal to %%this%%.
-         */
-        lte(other) { return this.cmp(other) <= 0; }
-        /**
-         *  Returns true if %%other%% is greater than to %%this%%.
-         */
-        gt(other) { return this.cmp(other) > 0; }
-        /**
-         *  Returns true if %%other%% is greater than or equal to %%this%%.
-         */
-        gte(other) { return this.cmp(other) >= 0; }
-        /**
-         *  Returns a new [[FixedNumber]] which is the largest **integer**
-         *  that is less than or equal to %%this%%.
-         *
-         *  The decimal component of the result will always be ``0``.
-         */
-        floor() {
-            let val = this.#val;
-            if (this.#val < BN_0$8) {
-                val -= this.#tens - BN_1$3;
-            }
-            val = (this.#val / this.#tens) * this.#tens;
-            return this.#checkValue(val, "floor");
-        }
-        /**
-         *  Returns a new [[FixedNumber]] which is the smallest **integer**
-         *  that is greater than or equal to %%this%%.
-         *
-         *  The decimal component of the result will always be ``0``.
-         */
-        ceiling() {
-            let val = this.#val;
-            if (this.#val > BN_0$8) {
-                val += this.#tens - BN_1$3;
-            }
-            val = (this.#val / this.#tens) * this.#tens;
-            return this.#checkValue(val, "ceiling");
-        }
-        /**
-         *  Returns a new [[FixedNumber]] with the decimal component
-         *  rounded up on ties at %%decimals%% places.
-         */
-        round(decimals) {
-            if (decimals == null) {
-                decimals = 0;
-            }
-            // Not enough precision to not already be rounded
-            if (decimals >= this.decimals) {
-                return this;
-            }
-            const delta = this.decimals - decimals;
-            const bump = BN_5 * getTens(delta - 1);
-            let value = this.value + bump;
-            const tens = getTens(delta);
-            value = (value / tens) * tens;
-            checkValue(value, this.#format, "round");
-            return new FixedNumber(_guard$3, value, this.#format);
-        }
-        /**
-         *  Returns true if %%this%% is equal to ``0``.
-         */
-        isZero() { return (this.#val === BN_0$8); }
-        /**
-         *  Returns true if %%this%% is less than ``0``.
-         */
-        isNegative() { return (this.#val < BN_0$8); }
-        /**
-         *  Returns the string representation of %%this%%.
-         */
-        toString() { return this._value; }
-        /**
-         *  Returns a float approximation.
-         *
-         *  Due to IEEE 754 precission (or lack thereof), this function
-         *  can only return an approximation and most values will contain
-         *  rounding errors.
-         */
-        toUnsafeFloat() { return parseFloat(this.toString()); }
-        /**
-         *  Return a new [[FixedNumber]] with the same value but has had
-         *  its field set to %%format%%.
-         *
-         *  This will throw if the value cannot fit into %%format%%.
-         */
-        toFormat(format) {
-            return FixedNumber.fromString(this.toString(), format);
-        }
-        /**
-         *  Creates a new [[FixedNumber]] for %%value%% divided by
-         *  %%decimal%% places with %%format%%.
-         *
-         *  This will throw a [[NumericFaultError]] if %%value%% (once adjusted
-         *  for %%decimals%%) cannot fit in %%format%%, either due to overflow
-         *  or underflow (precision loss).
-         */
-        static fromValue(_value, _decimals, _format) {
-            const decimals = (_decimals == null) ? 0 : getNumber(_decimals);
-            const format = getFormat(_format);
-            let value = getBigInt(_value, "value");
-            const delta = decimals - format.decimals;
-            if (delta > 0) {
-                const tens = getTens(delta);
-                assert$2((value % tens) === BN_0$8, "value loses precision for format", "NUMERIC_FAULT", {
-                    operation: "fromValue", fault: "underflow", value: _value
-                });
-                value /= tens;
-            }
-            else if (delta < 0) {
-                value *= getTens(-delta);
-            }
-            checkValue(value, format, "fromValue");
-            return new FixedNumber(_guard$3, value, format);
-        }
-        /**
-         *  Creates a new [[FixedNumber]] for %%value%% with %%format%%.
-         *
-         *  This will throw a [[NumericFaultError]] if %%value%% cannot fit
-         *  in %%format%%, either due to overflow or underflow (precision loss).
-         */
-        static fromString(_value, _format) {
-            const match = _value.match(/^(-?)([0-9]*)\.?([0-9]*)$/);
-            assertArgument(match && (match[2].length + match[3].length) > 0, "invalid FixedNumber string value", "value", _value);
-            const format = getFormat(_format);
-            let whole = (match[2] || "0"), decimal = (match[3] || "");
-            // Pad out the decimals
-            while (decimal.length < format.decimals) {
-                decimal += Zeros$1;
-            }
-            // Check precision is safe
-            assert$2(decimal.substring(format.decimals).match(/^0*$/), "too many decimals for format", "NUMERIC_FAULT", {
-                operation: "fromString", fault: "underflow", value: _value
-            });
-            // Remove extra padding
-            decimal = decimal.substring(0, format.decimals);
-            const value = BigInt(match[1] + whole + decimal);
-            checkValue(value, format, "fromString");
-            return new FixedNumber(_guard$3, value, format);
-        }
-        /**
-         *  Creates a new [[FixedNumber]] with the big-endian representation
-         *  %%value%% with %%format%%.
-         *
-         *  This will throw a [[NumericFaultError]] if %%value%% cannot fit
-         *  in %%format%% due to overflow.
-         */
-        static fromBytes(_value, _format) {
-            let value = toBigInt(getBytes(_value, "value"));
-            const format = getFormat(_format);
-            if (format.signed) {
-                value = fromTwos(value, format.width);
-            }
-            checkValue(value, format, "fromBytes");
-            return new FixedNumber(_guard$3, value, format);
-        }
-    }
-    //const f1 = FixedNumber.fromString("12.56", "fixed16x2");
-    //const f2 = FixedNumber.fromString("0.3", "fixed16x2");
-    //console.log(f1.divSignal(f2));
-    //const BUMP = FixedNumber.from("0.5");
-
     //See: https://github.com/ethereum/wiki/wiki/RLP
     function hexlifyByte(value) {
         let result = value.toString(16);
@@ -33021,62 +32505,6 @@ var PolygonIdSdk = (function (exports) {
         return result;
     }
 
-    /**
-     *  Most interactions with Ethereum requires integer values, which use
-     *  the smallest magnitude unit.
-     *
-     *  For example, imagine dealing with dollars and cents. Since dollars
-     *  are divisible, non-integer values are possible, such as ``$10.77``.
-     *  By using the smallest indivisible unit (i.e. cents), the value can
-     *  be kept as the integer ``1077``.
-     *
-     *  When receiving decimal input from the user (as a decimal string),
-     *  the value should be converted to an integer and when showing a user
-     *  a value, the integer value should be converted to a decimal string.
-     *
-     *  This creates a clear distinction, between values to be used by code
-     *  (integers) and values used for display logic to users (decimals).
-     *
-     *  The native unit in Ethereum, //ether// is divisible to 18 decimal places,
-     *  where each individual unit is called a //wei//.
-     *
-     *  @_subsection api/utils:Unit Conversion  [about-units]
-     */
-    const names = [
-        "wei",
-        "kwei",
-        "mwei",
-        "gwei",
-        "szabo",
-        "finney",
-        "ether",
-    ];
-    /**
-     *  Converts the //decimal string// %%value%% to a BigInt, assuming
-     *  %%unit%% decimal places. The %%unit%% may the number of decimal places
-     *  or the name of a unit (e.g. ``"gwei"`` for 9 decimal places).
-     */
-    function parseUnits$1(value, unit) {
-        assertArgument(typeof (value) === "string", "value must be a string", "value", value);
-        let decimals = 18;
-        if (typeof (unit) === "string") {
-            const index = names.indexOf(unit);
-            assertArgument(index >= 0, "invalid unit", "unit", unit);
-            decimals = 3 * index;
-        }
-        else if (unit != null) {
-            decimals = getNumber(unit, "unit");
-        }
-        return FixedNumber.fromString(value, { decimals, width: 512 }).value;
-    }
-    /**
-     *  Converts the //decimal string// %%ether%% to a BigInt, using 18
-     *  decimal places.
-     */
-    function parseEther(ether) {
-        return parseUnits$1(ether, 18);
-    }
-
     /**
      * @_ignore:
      */
@@ -51945,6 +51373,12 @@ var PolygonIdSdk = (function (exports) {
             this.GISTRoot = V$1.fromString(sVals[2]);
             return this;
         }
+        getStatesInfo() {
+            return {
+                states: [],
+                gists: [{ id: this.userID, root: this.GISTRoot }]
+            };
+        }
     }
 
     /**
@@ -54375,54 +53809,60 @@ var PolygonIdSdk = (function (exports) {
             const { txnHash } = await transactionService.sendTransactionRequest(ethSigner, request);
             return new Map().set(txnHash, zkProofResponses);
         }
+        static getCrossChainResolvers(source, txDataChainId, type, didResolverUrl) {
+            return [
+                ...new Set(source.map((info) => JSON.stringify({
+                    id: info.id.string(),
+                    [type]: type === 'gist' ? info.root?.string() : info.state?.string()
+                })))
+            ].reduce((acc, s) => {
+                const info = JSON.parse(s);
+                const id = $$1.fromString(info.id);
+                const chainId = rt$2(Q$2.parseFromId(id));
+                if (txDataChainId === chainId) {
+                    return acc;
+                }
+                const promise = this.resolveDidDocumentEip712MessageAndSignature(Q$2.parseFromId($$1.fromString(info.id)), didResolverUrl, {
+                    [type]: V$1.fromString(info[type])
+                });
+                return [...acc, promise];
+            }, []);
+        }
         static async prepareTxArgsSubmitV2(resolverUrl, txData, zkProofResponses) {
             if (txData.method_id.replace('0x', '') !== exports.FunctionSignatures.SubmitZKPResponseV2) {
                 throw new Error(`submit cross chain doesn't implement requested method id. Only '0x${exports.FunctionSignatures.SubmitZKPResponseV2}' is supported.`);
             }
-            const gistUpdateArr = [];
-            const stateUpdateArr = [];
+            const gistUpdates = [];
+            const stateUpdates = [];
             const payload = [];
-            // Resolved gists and states to avoid duplicate requests
-            const gistUpdateResolutionsPending = [];
-            const stateUpdateResolutionsPending = [];
+            const emptyBytes = '0x';
             for (const zkProof of zkProofResponses) {
-                const requestID = zkProof.id;
-                const inputs = zkProof.pub_signals;
-                if (!this._supportedCircuits.includes(zkProof.circuitId)) {
+                const { id: requestId, pub_signals: inputs } = zkProof;
+                const proofCircuitId = zkProof.circuitId;
+                if (!this._supportedCircuits.includes(proofCircuitId)) {
                     throw new Error(`Circuit ${zkProof.circuitId} not supported by OnChainZKPVerifier`);
                 }
+                if (inputs.length === 0) {
+                    payload.push({
+                        requestId: requestId,
+                        zkProof: emptyBytes,
+                        data: emptyBytes
+                    });
+                    continue;
+                }
                 const zkProofEncoded = this.packZkpProof(inputs, zkProof.proof.pi_a.slice(0, 2), [
                     [zkProof.proof.pi_b[0][1], zkProof.proof.pi_b[0][0]],
                     [zkProof.proof.pi_b[1][1], zkProof.proof.pi_b[1][0]]
                 ], zkProof.proof.pi_c.slice(0, 2));
-                const stateInfo = this.getOnChainGistRootStatePubSignals(zkProof.circuitId, zkProof.pub_signals);
-                const gistUpdateResolutions = [];
-                for (const gist of stateInfo.gists) {
-                    const gistResolutionPending = gistUpdateResolutionsPending.find((g) => g == JSON.stringify(gist));
-                    if (gistResolutionPending) {
-                        continue;
-                    }
-                    gistUpdateResolutionsPending.push(JSON.stringify(gist));
-                    gistUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(Q$2.parseFromId(gist.id), resolverUrl, {
-                        gist: gist.root
-                    }));
-                }
-                const stateUpdateResolutions = [];
-                for (const state of stateInfo.states) {
-                    const stateResolutionPending = stateUpdateResolutionsPending.find((s) => s == JSON.stringify(state));
-                    if (stateResolutionPending) {
-                        continue;
-                    }
-                    stateUpdateResolutionsPending.push(JSON.stringify(state));
-                    stateUpdateResolutions.push(this.resolveDidDocumentEip712MessageAndSignature(Q$2.parseFromId(state.id), resolverUrl, {
-                        state: state.state
-                    }));
-                }
+                const stateInfo = this.getOnChainGistRootStatePubSignals(proofCircuitId, inputs);
+                const chainId = txData.chain_id;
+                const gistUpdateResolutions = this.getCrossChainResolvers(stateInfo.gists, chainId, 'gist', resolverUrl);
+                const stateUpdateResolutions = this.getCrossChainResolvers(stateInfo.states, chainId, 'state', resolverUrl);
                 if (gistUpdateResolutions.length > 0) {
-                    gistUpdateArr.push(...(await Promise.all(gistUpdateResolutions)));
+                    gistUpdates.push(...(await Promise.all(gistUpdateResolutions)));
                 }
                 if (stateUpdateResolutions.length > 0) {
-                    stateUpdateArr.push(...(await Promise.all(stateUpdateResolutions)));
+                    stateUpdates.push(...(await Promise.all(stateUpdateResolutions)));
                 }
                 const metadataArr = [];
                 if (zkProof.vp) {
@@ -54438,14 +53878,16 @@ var PolygonIdSdk = (function (exports) {
                         });
                     }
                 }
-                const metadata = metadataArr.length ? this.packMetadatas(metadataArr) : '0x';
+                const metadata = metadataArr.length ? this.packMetadatas(metadataArr) : emptyBytes;
                 payload.push({
-                    requestId: requestID,
+                    requestId: requestId,
                     zkProof: zkProofEncoded,
                     data: metadata
                 });
             }
-            const crossChainProofs = this.packCrossChainProofs(gistUpdateArr, stateUpdateArr);
+            const crossChainProofs = gistUpdates.length || stateUpdates.length
+                ? this.packCrossChainProofs(gistUpdates, stateUpdates)
+                : emptyBytes;
             return [payload, crossChainProofs];
         }
         async prepareTxArgsSubmitV2(txData, zkProofResponses) {
@@ -54503,18 +53945,11 @@ var PolygonIdSdk = (function (exports) {
             return new AbiCoder().encode(['tuple(' + 'string key,' + 'bytes value' + ')[]'], [metas]);
         }
         static getOnChainGistRootStatePubSignals(onChainCircuitId, inputs) {
-            let atomicQueryPubSignals;
-            switch (onChainCircuitId) {
-                case exports.CircuitId.AtomicQueryMTPV2OnChain:
-                    atomicQueryPubSignals = new AtomicQueryMTPV2OnChainPubSignals();
-                    break;
-                case exports.CircuitId.AtomicQuerySigV2OnChain:
-                    atomicQueryPubSignals = new AtomicQuerySigV2OnChainPubSignals();
-                    break;
-                case exports.CircuitId.AtomicQueryV3OnChain:
-                    atomicQueryPubSignals = new AtomicQueryV3OnChainPubSignals();
-                    break;
+            const PubSignals = this._supportedCircuitsPubSignalsMap[onChainCircuitId];
+            if (!PubSignals) {
+                throw new Error(`Circuit ${onChainCircuitId} not supported by OnChainZKPVerifier`);
             }
+            const atomicQueryPubSignals = new PubSignals();
             const encodedInputs = byteEncoder.encode(JSON.stringify(inputs));
             atomicQueryPubSignals.pubSignalsUnmarshal(encodedInputs);
             return atomicQueryPubSignals.getStatesInfo();
@@ -54556,10 +53991,17 @@ var PolygonIdSdk = (function (exports) {
      * supported circuits
      */
     OnChainZKPVerifier._supportedCircuits = [
+        exports.CircuitId.AuthV2,
         exports.CircuitId.AtomicQueryMTPV2OnChain,
         exports.CircuitId.AtomicQuerySigV2OnChain,
         exports.CircuitId.AtomicQueryV3OnChain
     ];
+    OnChainZKPVerifier._supportedCircuitsPubSignalsMap = {
+        [exports.CircuitId.AtomicQueryMTPV2OnChain]: AtomicQueryMTPV2OnChainPubSignals,
+        [exports.CircuitId.AtomicQuerySigV2OnChain]: AtomicQuerySigV2OnChainPubSignals,
+        [exports.CircuitId.AtomicQueryV3OnChain]: AtomicQueryV3OnChainPubSignals,
+        [exports.CircuitId.AuthV2]: AuthV2PubSignals
+    };
 
     var abi$1 = [
     	{
@@ -58983,6 +58425,7 @@ var PolygonIdSdk = (function (exports) {
     }
 
     const IDEN3_PROTOCOL = 'https://iden3-communication.io/';
+    const DIDCOMM_PROTOCOL = 'https://didcomm.org/';
     /**
      * Constants for Iden3 protocol
      */
@@ -59026,7 +58469,11 @@ var PolygonIdSdk = (function (exports) {
         // PaymentRequestMessageType is type for payment-request message
         PAYMENT_REQUEST_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/payment-request`,
         // PaymentMessageType is type for payment message
-        PAYMENT_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/payment`
+        PAYMENT_MESSAGE_TYPE: `${IDEN3_PROTOCOL}credentials/0.1/payment`,
+        // DiscoveryProtocolQueriesMessageType is type for didcomm discovery protocol queries
+        DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}discover-features/2.0/queries`,
+        // DiscoveryProtocolDiscloseMessageType is type for didcomm discovery protocol disclose
+        DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE: `${DIDCOMM_PROTOCOL}discover-features/2.0/disclose`
     });
     /**
      * Media types for iden3 comm communication protocol
@@ -80913,6 +80360,18 @@ var PolygonIdSdk = (function (exports) {
         constructor() {
             this.packers = new Map();
         }
+        /** {@inheritDoc IPackageManager.getSupportedProfiles} */
+        getSupportedProfiles() {
+            const acceptProfiles = [];
+            const mediaTypes = this.getSupportedMediaTypes();
+            for (const mediaType of mediaTypes) {
+                const p = this.packers.get(mediaType);
+                if (p) {
+                    acceptProfiles.push(...p.getSupportedProfiles());
+                }
+            }
+            return [...new Set(acceptProfiles)];
+        }
         /** {@inheritDoc IPackageManager.isProfileSupported} */
         isProfileSupported(mediaType, profile) {
             const p = this.packers.get(mediaType);
@@ -81226,6 +80685,9 @@ var PolygonIdSdk = (function (exports) {
             this.provingParamsMap = provingParamsMap;
             this.verificationParamsMap = verificationParamsMap;
             this._opts = _opts;
+            this.supportedProtocolVersions = [ProtocolVersion.V1];
+            this.supportedAlgorithms = [AcceptJwzAlgorithms.Groth16];
+            this.supportedCircuitIds = [AcceptAuthCircuits.AuthV2];
         }
         /**
          * Packs a basic message using the specified parameters.
@@ -81287,28 +80749,23 @@ var PolygonIdSdk = (function (exports) {
         }
         /** {@inheritDoc IPacker.getSupportedProfiles} */
         getSupportedProfiles() {
-            return [
-                `env=${this.mediaType()}&alg=${this.getSupportedAlgorithms().join(',')}&circuitIds=${this.getSupportedCircuitIds().join(',')}`
-            ];
+            return this.supportedProtocolVersions.map((v) => `${v};env=${this.mediaType()};alg=${this.supportedAlgorithms.join(',')};circuitIds=${this.supportedCircuitIds.join(',')}`);
         }
         /** {@inheritDoc IPacker.isProfileSupported} */
         isProfileSupported(profile) {
-            const { env, circuits, alg } = parseAcceptProfile(profile);
+            const { protocolVersion, env, circuits, alg } = parseAcceptProfile(profile);
+            if (!this.supportedProtocolVersions.includes(protocolVersion)) {
+                return false;
+            }
             if (env !== this.mediaType()) {
                 return false;
             }
-            const supportedCircuitIds = this.getSupportedCircuitIds();
+            const supportedCircuitIds = this.supportedCircuitIds;
             const circuitIdSupported = !circuits?.length || circuits.some((c) => supportedCircuitIds.includes(c));
-            const supportedAlgArr = this.getSupportedAlgorithms();
+            const supportedAlgArr = this.supportedAlgorithms;
             const algSupported = !alg?.length || alg.some((a) => supportedAlgArr.includes(a));
             return algSupported && circuitIdSupported;
         }
-        getSupportedAlgorithms() {
-            return [AcceptJwzAlgorithms.Groth16];
-        }
-        getSupportedCircuitIds() {
-            return [AcceptAuthCircuits.AuthV2];
-        }
     }
     const verifySender = async (token, msg) => {
         switch (token.circuitId) {
@@ -81342,6 +80799,9 @@ var PolygonIdSdk = (function (exports) {
      * @implements implements IPacker interface
      */
     class PlainPacker {
+        constructor() {
+            this.supportedProtocolVersions = [ProtocolVersion.V1];
+        }
         /**
          * Packs a basic message using the specified parameters.
          *
@@ -81385,11 +80845,14 @@ var PolygonIdSdk = (function (exports) {
         }
         /** {@inheritDoc IPacker.getSupportedProfiles} */
         getSupportedProfiles() {
-            return [`env=${this.mediaType()}`];
+            return this.supportedProtocolVersions.map((v) => `${v};env=${this.mediaType()}`);
         }
         /** {@inheritDoc IPacker.isProfileSupported} */
         isProfileSupported(profile) {
-            const { env, circuits, alg } = parseAcceptProfile(profile);
+            const { protocolVersion, env, circuits, alg } = parseAcceptProfile(profile);
+            if (!this.supportedProtocolVersions.includes(protocolVersion)) {
+                return false;
+            }
             if (env !== this.mediaType()) {
                 return false;
             }
@@ -81421,6 +80884,8 @@ var PolygonIdSdk = (function (exports) {
         constructor(_kms, _documentResolver) {
             this._kms = _kms;
             this._documentResolver = _documentResolver;
+            this.supportedAlgorithms = [AcceptJwsAlgorithms.ES256K, AcceptJwsAlgorithms.ES256KR];
+            this.supportedProtocolVersions = [ProtocolVersion.V1];
         }
         /**
          * Packs the given payload and returns a promise that resolves to the packed data.
@@ -81483,24 +80948,23 @@ var PolygonIdSdk = (function (exports) {
         }
         /** {@inheritDoc IPacker.getSupportedProfiles} */
         getSupportedProfiles() {
-            return [`env=${this.mediaType()}&alg=${this.getSupportedAlgorithms().join(',')}`];
+            return this.supportedProtocolVersions.map((v) => `${v};env=${this.mediaType()};alg=${this.supportedAlgorithms.join(',')}`);
         }
         /** {@inheritDoc IPacker.isProfileSupported} */
         isProfileSupported(profile) {
-            const { env, circuits, alg } = parseAcceptProfile(profile);
+            const { protocolVersion, env, circuits, alg } = parseAcceptProfile(profile);
+            if (!this.supportedProtocolVersions.includes(protocolVersion)) {
+                return false;
+            }
             if (env !== this.mediaType()) {
                 return false;
             }
             if (circuits) {
                 throw new Error(`Circuits are not supported for ${env} media type`);
             }
-            const supportedAlgArr = this.getSupportedAlgorithms();
-            const algSupported = !alg?.length || alg.some((a) => supportedAlgArr.includes(a));
+            const algSupported = !alg?.length || alg.some((a) => this.supportedAlgorithms.includes(a));
             return algSupported;
         }
-        getSupportedAlgorithms() {
-            return [AcceptJwsAlgorithms.ES256K, AcceptJwsAlgorithms.ES256KR];
-        }
         async resolveDidDoc(from) {
             let didDocument;
             try {
@@ -81576,6 +81040,20 @@ var PolygonIdSdk = (function (exports) {
         CredentialOfferStatus["Rejected"] = "rejected";
     })(exports.CredentialOfferStatus || (exports.CredentialOfferStatus = {}));
 
+    /** @beta DiscoverFeatureQueryType is enum for query type fields */
+    exports.DiscoverFeatureQueryType = void 0;
+    (function (DiscoverFeatureQueryType) {
+        DiscoverFeatureQueryType["FeatureType"] = "feature-type";
+    })(exports.DiscoverFeatureQueryType || (exports.DiscoverFeatureQueryType = {}));
+    /** @beta DiscoveryProtocolFeatureType is enum for supported feature-types */
+    exports.DiscoveryProtocolFeatureType = void 0;
+    (function (DiscoveryProtocolFeatureType) {
+        DiscoveryProtocolFeatureType["Accept"] = "accept";
+        DiscoveryProtocolFeatureType["Protocol"] = "protocol";
+        DiscoveryProtocolFeatureType["GoalCode"] = "goal-code";
+        DiscoveryProtocolFeatureType["Header"] = "header";
+    })(exports.DiscoveryProtocolFeatureType || (exports.DiscoveryProtocolFeatureType = {}));
+
     /**
      * Groups the ZeroKnowledgeProofRequest objects based on their groupId.
      * Returns a Map where the key is the groupId and the value is an object containing the query and linkNonce.
@@ -82021,32 +81499,24 @@ var PolygonIdSdk = (function (exports) {
         }
         getSupportedMediaTypeByProfile(ctx, responseType, profile) {
             let mediaType;
-            if (profile?.length) {
-                const supportedMediaTypes = [];
-                for (const acceptProfile of profile) {
-                    // 1. check protocol version
-                    const { protocolVersion, env } = parseAcceptProfile(acceptProfile);
-                    const responseTypeVersion = Number(responseType.split('/').at(-2));
-                    if (protocolVersion !== ProtocolVersion.V1 ||
-                        (protocolVersion === ProtocolVersion.V1 &&
-                            (responseTypeVersion < 1 || responseTypeVersion >= 2))) {
-                        continue;
-                    }
-                    // 2. check packer support
-                    if (this._packerMgr.isProfileSupported(env, acceptProfile)) {
-                        supportedMediaTypes.push(env);
-                    }
-                }
-                if (!supportedMediaTypes.length) {
-                    throw new Error('no packer with profile which meets `accept` header requirements');
-                }
-                mediaType = supportedMediaTypes[0];
-                if (ctx.mediaType && supportedMediaTypes.includes(ctx.mediaType)) {
-                    mediaType = ctx.mediaType;
+            if (!profile?.length) {
+                return ctx.mediaType || MediaType.ZKPMessage;
+            }
+            const supportedMediaTypes = [];
+            for (const acceptProfile of profile) {
+                const { env } = parseAcceptProfile(acceptProfile);
+                if (this._packerMgr.isProfileSupported(env, acceptProfile)) {
+                    supportedMediaTypes.push(env);
                 }
             }
-            else {
-                mediaType = ctx.mediaType || MediaType.ZKPMessage;
+            if (!supportedMediaTypes.length) {
+                throw new Error('no packer with profile which meets `accept` header requirements');
+            }
+            mediaType = supportedMediaTypes.includes(MediaType.ZKPMessage)
+                ? MediaType.ZKPMessage
+                : supportedMediaTypes[0];
+            if (ctx.mediaType && supportedMediaTypes.includes(ctx.mediaType)) {
+                mediaType = ctx.mediaType;
             }
             return mediaType;
         }
@@ -82313,6 +81783,7 @@ var PolygonIdSdk = (function (exports) {
             this._proofService = _proofService;
             this._zkpVerifier = _zkpVerifier;
             this._supportedCircuits = [
+                exports.CircuitId.AuthV2,
                 exports.CircuitId.AtomicQueryMTPV2OnChain,
                 exports.CircuitId.AtomicQuerySigV2OnChain,
                 exports.CircuitId.AtomicQueryV3OnChain
@@ -82343,7 +81814,12 @@ var PolygonIdSdk = (function (exports) {
                 throw new Error(`Invalid chain id ${chain_id}`);
             }
             const verifierDid = message.from ? Q$2.parse(message.from) : undefined;
-            const zkpResponses = await processZeroKnowledgeProofRequests(did, message?.body?.scope, verifierDid, this._proofService, { ethSigner, challenge, supportedCircuits: this._supportedCircuits });
+            const { scope = [] } = message.body;
+            const zkpResponses = await processZeroKnowledgeProofRequests(did, scope, verifierDid, this._proofService, {
+                ethSigner,
+                challenge,
+                supportedCircuits: this._supportedCircuits
+            });
             const methodId = message.body.transaction_data.method_id.replace('0x', '');
             switch (methodId) {
                 case exports.FunctionSignatures.SubmitZKPResponseV2:
@@ -82864,11 +82340,10 @@ var PolygonIdSdk = (function (exports) {
         return request;
     }
     async function verifyEIP712TypedData(data, resolver) {
-        const convertedAmount = await convertPaymentAmount(data.amount, data.currency);
         const paymentData = data.type === exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1
             ? {
                 recipient: data.recipient,
-                amount: convertedAmount,
+                amount: data.amount,
                 expirationDate: b$4(new Date(data.expirationDate)),
                 nonce: data.nonce,
                 metadata: '0x'
@@ -82876,7 +82351,7 @@ var PolygonIdSdk = (function (exports) {
             : {
                 tokenAddress: data.tokenAddress,
                 recipient: data.recipient,
-                amount: convertedAmount,
+                amount: data.amount,
                 expirationDate: b$4(new Date(data.expirationDate)),
                 nonce: data.nonce,
                 metadata: '0x'
@@ -82900,30 +82375,6 @@ var PolygonIdSdk = (function (exports) {
         }
         throw new Error(`failed request. no matching verificationMethod`);
     }
-    async function convertPaymentAmount(amount, currency) {
-        let convertedAmount = 0n;
-        switch (currency) {
-            case exports.SupportedCurrencies.ETH:
-            case exports.SupportedCurrencies.POL:
-            case exports.SupportedCurrencies.MATIC:
-                convertedAmount = parseEther(amount.toString());
-                break;
-            case exports.SupportedCurrencies.ETH_WEI:
-                convertedAmount = parseUnits$1(amount.toString(), 'wei');
-                break;
-            case exports.SupportedCurrencies.ETH_GWEI:
-                convertedAmount = parseUnits$1(amount.toString(), 'gwei');
-                break;
-            case exports.SupportedCurrencies.USDC:
-            case exports.SupportedCurrencies.USDT: {
-                convertedAmount = parseUnits$1(amount.toString(), 6);
-                break;
-            }
-            default:
-                throw new Error(`failed request. unsupported currency ${currency}`);
-        }
-        return convertedAmount;
-    }
     /**
      * @beta
      * createPayment is a function to create protocol payment message
@@ -83110,35 +82561,38 @@ var PolygonIdSdk = (function (exports) {
             for (let i = 0; i < payments.length; i++) {
                 const { credentials, description } = payments[i];
                 const dataArr = [];
-                for (let j = 0; j < payments[i].chains.length; j++) {
-                    const { features, nonce, amount, currency, chainId, expirationDate, type } = payments[i].chains[j];
+                for (let j = 0; j < payments[i].options.length; j++) {
+                    const { nonce, amount, chainId, optionId, expirationDate } = payments[i].options[j];
                     const multiChainConfig = this._params.multiChainPaymentConfig?.find((c) => c.chainId === chainId);
                     if (!multiChainConfig) {
                         throw new Error(`failed request. no config for chain ${chainId}`);
                     }
-                    const { recipient, paymentContract, erc20TokenAddressArr } = multiChainConfig;
-                    const tokenAddress = erc20TokenAddressArr.find((t) => t.symbol === currency)?.address;
-                    if (type === exports.PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1 && !tokenAddress) {
-                        throw new Error(`failed request. no token address for currency ${currency}`);
+                    const { recipient, paymentRails, options } = multiChainConfig;
+                    const option = options.find((t) => t.id === optionId);
+                    if (!option) {
+                        throw new Error(`failed request. no option for id ${optionId}`);
+                    }
+                    if (option.type === exports.PaymentRequestDataType.Iden3PaymentRailsERC20RequestV1 &&
+                        !option.contractAddress) {
+                        throw new Error(`failed request. no token address for option id ${optionId}`);
                     }
                     const expirationDateRequired = expirationDate ?? new Date(new Date().setHours(new Date().getHours() + 1));
-                    const typeUrl = `https://schema.iden3.io/core/json/${type}.json`;
+                    const typeUrl = `https://schema.iden3.io/core/json/${option.type}.json`;
                     const typesFetchResult = await fetch(typeUrl);
                     const types = await typesFetchResult.json();
                     delete types.EIP712Domain;
-                    const convertedAmount = await convertPaymentAmount(amount, currency);
-                    const paymentData = type === exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                    const paymentData = option.type === exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1
                         ? {
                             recipient,
-                            amount: convertedAmount,
+                            amount: amount,
                             expirationDate: b$4(expirationDateRequired),
                             nonce,
                             metadata: '0x'
                         }
                         : {
-                            tokenAddress,
+                            tokenAddress: option.contractAddress,
                             recipient,
-                            amount: convertedAmount,
+                            amount: amount,
                             expirationDate: b$4(expirationDateRequired),
                             nonce,
                             metadata: '0x'
@@ -83147,7 +82601,7 @@ var PolygonIdSdk = (function (exports) {
                         name: 'MCPayment',
                         version: '1.0.0',
                         chainId,
-                        verifyingContract: paymentContract
+                        verifyingContract: paymentRails
                     };
                     const signature = await signer.signTypedData(domain, types, paymentData);
                     const proof = [
@@ -83167,20 +82621,24 @@ var PolygonIdSdk = (function (exports) {
                     const d = {
                         type: exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1,
                         '@context': [
-                            `https://schema.iden3.io/core/jsonld/payment.jsonld#${type}`,
+                            `https://schema.iden3.io/core/jsonld/payment.jsonld#${option.type}`,
                             'https://w3id.org/security/suites/eip712sig-2021/v1'
                         ],
                         recipient,
                         amount: amount.toString(),
-                        currency,
                         expirationDate: expirationDateRequired.toISOString(),
                         nonce: nonce.toString(),
                         metadata: '0x',
                         proof
                     };
-                    dataArr.push(type === exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1
+                    dataArr.push(option.type === exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1
                         ? d
-                        : { ...d, type, tokenAddress: tokenAddress || '', features: features || [] });
+                        : {
+                            ...d,
+                            type: option.type,
+                            tokenAddress: option.contractAddress || '',
+                            features: option.features || []
+                        });
                 }
                 paymentRequestInfo.push({
                     data: dataArr,
@@ -83265,6 +82723,170 @@ var PolygonIdSdk = (function (exports) {
         }
     }
 
+    /**
+     * @beta
+     * createDiscoveryFeatureQueryMessage is a function to create didcomm protocol discovery-feature query message
+     * @param opts - discovery-feature query options
+     * @returns `DiscoverFeatureQueriesMessage`
+     */
+    function createDiscoveryFeatureQueryMessage(queries, opts) {
+        const uuidv4 = v4();
+        return {
+            id: uuidv4,
+            thid: uuidv4,
+            typ: MediaType.PlainMessage,
+            type: PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE,
+            body: {
+                queries
+            },
+            from: opts?.from,
+            to: opts?.to,
+            created_time: b$4(new Date()),
+            expires_time: opts?.expires_time
+        };
+    }
+    /**
+     * @beta
+     * createDiscoveryFeatureDiscloseMessage is a function to create didcomm protocol discovery-feature disclose message
+     * @param {DiscoverFeatureDisclosure[]} disclosures - array of disclosures
+     * @param opts - basic message options
+     * @returns `DiscoverFeatureQueriesMessage`
+     */
+    function createDiscoveryFeatureDiscloseMessage(disclosures, opts) {
+        const uuidv4 = v4();
+        return {
+            id: uuidv4,
+            typ: MediaType.PlainMessage,
+            thid: uuidv4,
+            type: PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_DISCLOSE_MESSAGE_TYPE,
+            body: {
+                disclosures
+            },
+            from: opts?.from,
+            to: opts?.to,
+            created_time: b$4(new Date()),
+            expires_time: opts?.expires_time
+        };
+    }
+    /**
+     *
+     * Handler for discovery protocol
+     *
+     * @public
+     * @beta
+     * @class DiscoveryProtocolHandler
+     * @implements implements DiscoveryProtocolHandler interface
+     */
+    class DiscoveryProtocolHandler extends AbstractMessageHandler {
+        /**
+         * Creates an instance of DiscoveryProtocolHandler.
+         * @param {DiscoveryProtocolOptions} _options - discovery protocol options
+         */
+        constructor(_options) {
+            super();
+            this._options = _options;
+            const headers = [
+                'id',
+                'typ',
+                'type',
+                'thid',
+                'body',
+                'from',
+                'to',
+                'created_time',
+                'expires_time'
+            ];
+            if (!_options.headers) {
+                _options.headers = headers;
+            }
+        }
+        /**
+         * @inheritdoc IProtocolMessageHandler#handle
+         */
+        async handle(message, context) {
+            switch (message.type) {
+                case PROTOCOL_MESSAGE_TYPE.DISCOVERY_PROTOCOL_QUERIES_MESSAGE_TYPE:
+                    return await this.handleDiscoveryQuery(message, context);
+                default:
+                    return super.handle(message, context);
+            }
+        }
+        /**
+         * @inheritdoc IDiscoveryProtocolHandler#handleDiscoveryQuery
+         */
+        async handleDiscoveryQuery(message, opts) {
+            if (!opts?.allowExpiredMessages) {
+                verifyExpiresTime(message);
+            }
+            const disclosures = [];
+            for (const query of message.body.queries) {
+                disclosures.push(...this.handleQuery(query));
+            }
+            return Promise.resolve(createDiscoveryFeatureDiscloseMessage(disclosures, {
+                to: message.from,
+                from: message.to,
+                expires_time: opts?.disclosureExpiresDate
+                    ? b$4(opts.disclosureExpiresDate)
+                    : undefined
+            }));
+        }
+        handleQuery(query) {
+            let result = [];
+            switch (query[exports.DiscoverFeatureQueryType.FeatureType]) {
+                case exports.DiscoveryProtocolFeatureType.Accept:
+                    result = this.handleAcceptQuery();
+                    break;
+                case exports.DiscoveryProtocolFeatureType.Protocol:
+                    result = this.handleProtocolQuery();
+                    break;
+                case exports.DiscoveryProtocolFeatureType.GoalCode:
+                    result = this.handleGoalCodeQuery();
+                    break;
+                case exports.DiscoveryProtocolFeatureType.Header:
+                    result = this.handleHeaderQuery();
+                    break;
+            }
+            return this.handleMatch(result, query.match);
+        }
+        handleAcceptQuery() {
+            const acceptProfiles = this._options.packageManager.getSupportedProfiles();
+            return acceptProfiles.map((profile) => ({
+                [exports.DiscoverFeatureQueryType.FeatureType]: exports.DiscoveryProtocolFeatureType.Accept,
+                id: profile
+            }));
+        }
+        handleProtocolQuery() {
+            return (this._options.protocols?.map((protocol) => ({
+                [exports.DiscoverFeatureQueryType.FeatureType]: exports.DiscoveryProtocolFeatureType.Protocol,
+                id: protocol
+            })) ?? []);
+        }
+        handleGoalCodeQuery() {
+            return (this._options.goalCodes?.map((goalCode) => ({
+                [exports.DiscoverFeatureQueryType.FeatureType]: exports.DiscoveryProtocolFeatureType.GoalCode,
+                id: goalCode
+            })) ?? []);
+        }
+        handleHeaderQuery() {
+            return (this._options.headers?.map((header) => ({
+                [exports.DiscoverFeatureQueryType.FeatureType]: exports.DiscoveryProtocolFeatureType.Header,
+                id: header
+            })) ?? []);
+        }
+        handleMatch(disclosures, match) {
+            if (!match || match === '*') {
+                return disclosures;
+            }
+            const regExp = this.wildcardToRegExp(match);
+            return disclosures.filter((disclosure) => regExp.test(disclosure.id));
+        }
+        wildcardToRegExp(match) {
+            // Escape special regex characters, then replace `*` with `.*`
+            const regexPattern = match.replace(/[.+^${}()|[\]\\]/g, '\\$&').replace(/\*/g, '.*');
+            return new RegExp(`^${regexPattern}$`);
+        }
+    }
+
     const allOperations = Object.values(QueryOperators);
     const v2Operations = [
         exports.Operators.NOOP,
@@ -84535,6 +84157,12 @@ var PolygonIdSdk = (function (exports) {
             authInputs.gistProof = gistProof;
             return authInputs.inputsMarshal();
         }
+        /** {@inheritdoc IProofService.generateAuthV2Proof} */
+        async generateAuthV2Proof(challenge, did) {
+            const authInputs = await this.generateAuthV2Inputs(challenge, did, exports.CircuitId.AuthV2);
+            const zkProof = await this._prover.generate(authInputs, exports.CircuitId.AuthV2);
+            return zkProof;
+        }
         async verifyState(circuitId, pubSignals, opts = {
             acceptedStateTransitionDelay: DEFAULT_AUTH_VERIFY_DELAY
         }) {
@@ -85334,6 +84962,7 @@ var PolygonIdSdk = (function (exports) {
     exports.DataPrepareHandlerFunc = DataPrepareHandlerFunc;
     exports.DidDocumentCredentialStatusResolver = DidDocumentCredentialStatusResolver;
     exports.DidResolverStateReadonlyStorage = DidResolverStateReadonlyStorage;
+    exports.DiscoveryProtocolHandler = DiscoveryProtocolHandler;
     exports.Ed25519Provider = Ed25519Provider;
     exports.ErrorEmptyAuthClaimNonRevProof = ErrorEmptyAuthClaimNonRevProof;
     exports.ErrorEmptyAuthClaimProof = ErrorEmptyAuthClaimProof;
@@ -85430,10 +85059,11 @@ var PolygonIdSdk = (function (exports) {
     exports.checkQueryRequest = checkQueryRequest;
     exports.circuitValidator = circuitValidator;
     exports.comparatorOptions = comparatorOptions;
-    exports.convertPaymentAmount = convertPaymentAmount;
     exports.core = index$1;
     exports.createAuthorizationRequest = createAuthorizationRequest;
     exports.createAuthorizationRequestWithMessage = createAuthorizationRequestWithMessage;
+    exports.createDiscoveryFeatureDiscloseMessage = createDiscoveryFeatureDiscloseMessage;
+    exports.createDiscoveryFeatureQueryMessage = createDiscoveryFeatureQueryMessage;
     exports.createPayment = createPayment;
     exports.createPaymentRequest = createPaymentRequest;
     exports.createProposal = createProposal;