@0xpolygonid/js-sdk 1.24.1 → 1.25.1

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 = [
     	{
@@ -82313,6 +81755,7 @@ var PolygonIdSdk = (function (exports) {
             this._proofService = _proofService;
             this._zkpVerifier = _zkpVerifier;
             this._supportedCircuits = [
+                exports.CircuitId.AuthV2,
                 exports.CircuitId.AtomicQueryMTPV2OnChain,
                 exports.CircuitId.AtomicQuerySigV2OnChain,
                 exports.CircuitId.AtomicQueryV3OnChain
@@ -82343,7 +81786,12 @@ var PolygonIdSdk = (function (exports) {
                 throw new Error(`Invalid chain id ${chain_id}`);
             }
             const verifierDid = message.from ? Q$2.parse(message.from) : undefined;
-            const zkpResponses = await processZeroKnowledgeProofRequests(did, message?.body?.scope, verifierDid, this._proofService, { ethSigner, challenge, supportedCircuits: this._supportedCircuits });
+            const { scope = [] } = message.body;
+            const zkpResponses = await processZeroKnowledgeProofRequests(did, scope, verifierDid, this._proofService, {
+                ethSigner,
+                challenge,
+                supportedCircuits: this._supportedCircuits
+            });
             const methodId = message.body.transaction_data.method_id.replace('0x', '');
             switch (methodId) {
                 case exports.FunctionSignatures.SubmitZKPResponseV2:
@@ -82864,11 +82312,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 +82323,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 +82347,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 +82533,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 +82573,7 @@ var PolygonIdSdk = (function (exports) {
                         name: 'MCPayment',
                         version: '1.0.0',
                         chainId,
-                        verifyingContract: paymentContract
+                        verifyingContract: paymentRails
                     };
                     const signature = await signer.signTypedData(domain, types, paymentData);
                     const proof = [
@@ -83167,20 +82593,24 @@ var PolygonIdSdk = (function (exports) {
                     const d = {
                         type: exports.PaymentRequestDataType.Iden3PaymentRailsRequestV1,
                         '@context': [
-                            `https://schema.iden3.io/core/jsonld/payment.jsonld#${type}`,
+                            `https://schema.iden3.io/core/jsonld/payment.jsonld#${option.type}`,
                             'https://w3id.org/security/suites/eip712sig-2021/v1'
                         ],
                         recipient,
                         amount: amount.toString(),
-                        currency,
                         expirationDate: 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,
@@ -84535,6 +83965,12 @@ var PolygonIdSdk = (function (exports) {
             authInputs.gistProof = gistProof;
             return authInputs.inputsMarshal();
         }
+        /** {@inheritdoc IProofService.generateAuthV2Proof} */
+        async generateAuthV2Proof(challenge, did) {
+            const authInputs = await this.generateAuthV2Inputs(challenge, did, exports.CircuitId.AuthV2);
+            const zkProof = await this._prover.generate(authInputs, exports.CircuitId.AuthV2);
+            return zkProof;
+        }
         async verifyState(circuitId, pubSignals, opts = {
             acceptedStateTransitionDelay: DEFAULT_AUTH_VERIFY_DELAY
         }) {
@@ -85430,7 +84866,6 @@ 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;