@kaspacom/swap-sdk 1.0.11 → 1.1.0

package/dist/index.js

@@ -139,8 +139,1079 @@ var WalletService = class {
 
 // src/services/swap.service.ts
 import { Contract, parseUnits, formatUnits, ZeroAddress, ethers, hexlify } from "ethers";
-import { CurrencyAmount, Percent, Token, TradeType } from "@uniswap/sdk-core";
-import { Trade, Pair, Route } from "@uniswap/v2-sdk";
+import { CurrencyAmount as CurrencyAmount2, Percent, Token as Token2, TradeType } from "@uniswap/sdk-core";
+import { Trade, Route } from "@uniswap/v2-sdk";
+
+// src/types/CustomFeePair.ts
+import { CurrencyAmount } from "@uniswap/sdk-core";
+import { Pair as UniPair } from "@uniswap/v2-sdk";
+
+// node_modules/jsbi/dist/jsbi.mjs
+var JSBI = class _JSBI extends Array {
+  constructor(i, _) {
+    if (super(i), this.sign = _, i > _JSBI.__kMaxLength) throw new RangeError("Maximum BigInt size exceeded");
+  }
+  static BigInt(i) {
+    var _ = Math.floor, t = Number.isFinite;
+    if ("number" == typeof i) {
+      if (0 === i) return _JSBI.__zero();
+      if (_JSBI.__isOneDigitInt(i)) return 0 > i ? _JSBI.__oneDigit(-i, true) : _JSBI.__oneDigit(i, false);
+      if (!t(i) || _(i) !== i) throw new RangeError("The number " + i + " cannot be converted to BigInt because it is not an integer");
+      return _JSBI.__fromDouble(i);
+    }
+    if ("string" == typeof i) {
+      const _2 = _JSBI.__fromString(i);
+      if (null === _2) throw new SyntaxError("Cannot convert " + i + " to a BigInt");
+      return _2;
+    }
+    if ("boolean" == typeof i) return true === i ? _JSBI.__oneDigit(1, false) : _JSBI.__zero();
+    if ("object" == typeof i) {
+      if (i.constructor === _JSBI) return i;
+      const _2 = _JSBI.__toPrimitive(i);
+      return _JSBI.BigInt(_2);
+    }
+    throw new TypeError("Cannot convert " + i + " to a BigInt");
+  }
+  toDebugString() {
+    const i = ["BigInt["];
+    for (const _ of this) i.push((_ ? (_ >>> 0).toString(16) : _) + ", ");
+    return i.push("]"), i.join("");
+  }
+  toString(i = 10) {
+    if (2 > i || 36 < i) throw new RangeError("toString() radix argument must be between 2 and 36");
+    return 0 === this.length ? "0" : 0 == (i & i - 1) ? _JSBI.__toStringBasePowerOfTwo(this, i) : _JSBI.__toStringGeneric(this, i, false);
+  }
+  static toNumber(i) {
+    const _ = i.length;
+    if (0 === _) return 0;
+    if (1 === _) {
+      const _2 = i.__unsignedDigit(0);
+      return i.sign ? -_2 : _2;
+    }
+    const t = i.__digit(_ - 1), e = _JSBI.__clz30(t), n = 30 * _ - e;
+    if (1024 < n) return i.sign ? -Infinity : 1 / 0;
+    let g = n - 1, o = t, s = _ - 1;
+    const l = e + 3;
+    let r = 32 === l ? 0 : o << l;
+    r >>>= 12;
+    const a = l - 12;
+    let u = 12 <= l ? 0 : o << 20 + l, d = 20 + l;
+    for (0 < a && 0 < s && (s--, o = i.__digit(s), r |= o >>> 30 - a, u = o << a + 2, d = a + 2); 0 < d && 0 < s; ) s--, o = i.__digit(s), u |= 30 <= d ? o << d - 30 : o >>> 30 - d, d -= 30;
+    const h = _JSBI.__decideRounding(i, d, s, o);
+    if ((1 === h || 0 === h && 1 == (1 & u)) && (u = u + 1 >>> 0, 0 === u && (r++, 0 != r >>> 20 && (r = 0, g++, 1023 < g)))) return i.sign ? -Infinity : 1 / 0;
+    const m = i.sign ? -2147483648 : 0;
+    return g = g + 1023 << 20, _JSBI.__kBitConversionInts[1] = m | g | r, _JSBI.__kBitConversionInts[0] = u, _JSBI.__kBitConversionDouble[0];
+  }
+  static unaryMinus(i) {
+    if (0 === i.length) return i;
+    const _ = i.__copy();
+    return _.sign = !i.sign, _;
+  }
+  static bitwiseNot(i) {
+    return i.sign ? _JSBI.__absoluteSubOne(i).__trim() : _JSBI.__absoluteAddOne(i, true);
+  }
+  static exponentiate(i, _) {
+    if (_.sign) throw new RangeError("Exponent must be positive");
+    if (0 === _.length) return _JSBI.__oneDigit(1, false);
+    if (0 === i.length) return i;
+    if (1 === i.length && 1 === i.__digit(0)) return i.sign && 0 == (1 & _.__digit(0)) ? _JSBI.unaryMinus(i) : i;
+    if (1 < _.length) throw new RangeError("BigInt too big");
+    let t = _.__unsignedDigit(0);
+    if (1 === t) return i;
+    if (t >= _JSBI.__kMaxLengthBits) throw new RangeError("BigInt too big");
+    if (1 === i.length && 2 === i.__digit(0)) {
+      const _2 = 1 + (0 | t / 30), e2 = i.sign && 0 != (1 & t), n2 = new _JSBI(_2, e2);
+      n2.__initializeDigits();
+      const g = 1 << t % 30;
+      return n2.__setDigit(_2 - 1, g), n2;
+    }
+    let e = null, n = i;
+    for (0 != (1 & t) && (e = i), t >>= 1; 0 !== t; t >>= 1) n = _JSBI.multiply(n, n), 0 != (1 & t) && (null === e ? e = n : e = _JSBI.multiply(e, n));
+    return e;
+  }
+  static multiply(_, t) {
+    if (0 === _.length) return _;
+    if (0 === t.length) return t;
+    let i = _.length + t.length;
+    30 <= _.__clzmsd() + t.__clzmsd() && i--;
+    const e = new _JSBI(i, _.sign !== t.sign);
+    e.__initializeDigits();
+    for (let n = 0; n < _.length; n++) _JSBI.__multiplyAccumulate(t, _.__digit(n), e, n);
+    return e.__trim();
+  }
+  static divide(i, _) {
+    if (0 === _.length) throw new RangeError("Division by zero");
+    if (0 > _JSBI.__absoluteCompare(i, _)) return _JSBI.__zero();
+    const t = i.sign !== _.sign, e = _.__unsignedDigit(0);
+    let n;
+    if (1 === _.length && 32767 >= e) {
+      if (1 === e) return t === i.sign ? i : _JSBI.unaryMinus(i);
+      n = _JSBI.__absoluteDivSmall(i, e, null);
+    } else n = _JSBI.__absoluteDivLarge(i, _, true, false);
+    return n.sign = t, n.__trim();
+  }
+  static remainder(i, _) {
+    if (0 === _.length) throw new RangeError("Division by zero");
+    if (0 > _JSBI.__absoluteCompare(i, _)) return i;
+    const t = _.__unsignedDigit(0);
+    if (1 === _.length && 32767 >= t) {
+      if (1 === t) return _JSBI.__zero();
+      const _2 = _JSBI.__absoluteModSmall(i, t);
+      return 0 === _2 ? _JSBI.__zero() : _JSBI.__oneDigit(_2, i.sign);
+    }
+    const e = _JSBI.__absoluteDivLarge(i, _, false, true);
+    return e.sign = i.sign, e.__trim();
+  }
+  static add(i, _) {
+    const t = i.sign;
+    return t === _.sign ? _JSBI.__absoluteAdd(i, _, t) : 0 <= _JSBI.__absoluteCompare(i, _) ? _JSBI.__absoluteSub(i, _, t) : _JSBI.__absoluteSub(_, i, !t);
+  }
+  static subtract(i, _) {
+    const t = i.sign;
+    return t === _.sign ? 0 <= _JSBI.__absoluteCompare(i, _) ? _JSBI.__absoluteSub(i, _, t) : _JSBI.__absoluteSub(_, i, !t) : _JSBI.__absoluteAdd(i, _, t);
+  }
+  static leftShift(i, _) {
+    return 0 === _.length || 0 === i.length ? i : _.sign ? _JSBI.__rightShiftByAbsolute(i, _) : _JSBI.__leftShiftByAbsolute(i, _);
+  }
+  static signedRightShift(i, _) {
+    return 0 === _.length || 0 === i.length ? i : _.sign ? _JSBI.__leftShiftByAbsolute(i, _) : _JSBI.__rightShiftByAbsolute(i, _);
+  }
+  static unsignedRightShift() {
+    throw new TypeError("BigInts have no unsigned right shift; use >> instead");
+  }
+  static lessThan(i, _) {
+    return 0 > _JSBI.__compareToBigInt(i, _);
+  }
+  static lessThanOrEqual(i, _) {
+    return 0 >= _JSBI.__compareToBigInt(i, _);
+  }
+  static greaterThan(i, _) {
+    return 0 < _JSBI.__compareToBigInt(i, _);
+  }
+  static greaterThanOrEqual(i, _) {
+    return 0 <= _JSBI.__compareToBigInt(i, _);
+  }
+  static equal(_, t) {
+    if (_.sign !== t.sign) return false;
+    if (_.length !== t.length) return false;
+    for (let e = 0; e < _.length; e++) if (_.__digit(e) !== t.__digit(e)) return false;
+    return true;
+  }
+  static notEqual(i, _) {
+    return !_JSBI.equal(i, _);
+  }
+  static bitwiseAnd(i, _) {
+    var t = Math.max;
+    if (!i.sign && !_.sign) return _JSBI.__absoluteAnd(i, _).__trim();
+    if (i.sign && _.sign) {
+      const e = t(i.length, _.length) + 1;
+      let n = _JSBI.__absoluteSubOne(i, e);
+      const g = _JSBI.__absoluteSubOne(_);
+      return n = _JSBI.__absoluteOr(n, g, n), _JSBI.__absoluteAddOne(n, true, n).__trim();
+    }
+    return i.sign && ([i, _] = [_, i]), _JSBI.__absoluteAndNot(i, _JSBI.__absoluteSubOne(_)).__trim();
+  }
+  static bitwiseXor(i, _) {
+    var t = Math.max;
+    if (!i.sign && !_.sign) return _JSBI.__absoluteXor(i, _).__trim();
+    if (i.sign && _.sign) {
+      const e2 = t(i.length, _.length), n2 = _JSBI.__absoluteSubOne(i, e2), g = _JSBI.__absoluteSubOne(_);
+      return _JSBI.__absoluteXor(n2, g, n2).__trim();
+    }
+    const e = t(i.length, _.length) + 1;
+    i.sign && ([i, _] = [_, i]);
+    let n = _JSBI.__absoluteSubOne(_, e);
+    return n = _JSBI.__absoluteXor(n, i, n), _JSBI.__absoluteAddOne(n, true, n).__trim();
+  }
+  static bitwiseOr(i, _) {
+    var t = Math.max;
+    const e = t(i.length, _.length);
+    if (!i.sign && !_.sign) return _JSBI.__absoluteOr(i, _).__trim();
+    if (i.sign && _.sign) {
+      let t2 = _JSBI.__absoluteSubOne(i, e);
+      const n2 = _JSBI.__absoluteSubOne(_);
+      return t2 = _JSBI.__absoluteAnd(t2, n2, t2), _JSBI.__absoluteAddOne(t2, true, t2).__trim();
+    }
+    i.sign && ([i, _] = [_, i]);
+    let n = _JSBI.__absoluteSubOne(_, e);
+    return n = _JSBI.__absoluteAndNot(n, i, n), _JSBI.__absoluteAddOne(n, true, n).__trim();
+  }
+  static asIntN(_, t) {
+    var i = Math.floor;
+    if (0 === t.length) return t;
+    if (_ = i(_), 0 > _) throw new RangeError("Invalid value: not (convertible to) a safe integer");
+    if (0 === _) return _JSBI.__zero();
+    if (_ >= _JSBI.__kMaxLengthBits) return t;
+    const e = 0 | (_ + 29) / 30;
+    if (t.length < e) return t;
+    const g = t.__unsignedDigit(e - 1), o = 1 << (_ - 1) % 30;
+    if (t.length === e && g < o) return t;
+    if (!((g & o) === o)) return _JSBI.__truncateToNBits(_, t);
+    if (!t.sign) return _JSBI.__truncateAndSubFromPowerOfTwo(_, t, true);
+    if (0 == (g & o - 1)) {
+      for (let n = e - 2; 0 <= n; n--) if (0 !== t.__digit(n)) return _JSBI.__truncateAndSubFromPowerOfTwo(_, t, false);
+      return t.length === e && g === o ? t : _JSBI.__truncateToNBits(_, t);
+    }
+    return _JSBI.__truncateAndSubFromPowerOfTwo(_, t, false);
+  }
+  static asUintN(i, _) {
+    var t = Math.floor;
+    if (0 === _.length) return _;
+    if (i = t(i), 0 > i) throw new RangeError("Invalid value: not (convertible to) a safe integer");
+    if (0 === i) return _JSBI.__zero();
+    if (_.sign) {
+      if (i > _JSBI.__kMaxLengthBits) throw new RangeError("BigInt too big");
+      return _JSBI.__truncateAndSubFromPowerOfTwo(i, _, false);
+    }
+    if (i >= _JSBI.__kMaxLengthBits) return _;
+    const e = 0 | (i + 29) / 30;
+    if (_.length < e) return _;
+    const g = i % 30;
+    if (_.length == e) {
+      if (0 === g) return _;
+      const i2 = _.__digit(e - 1);
+      if (0 == i2 >>> g) return _;
+    }
+    return _JSBI.__truncateToNBits(i, _);
+  }
+  static ADD(i, _) {
+    if (i = _JSBI.__toPrimitive(i), _ = _JSBI.__toPrimitive(_), "string" == typeof i) return "string" != typeof _ && (_ = _.toString()), i + _;
+    if ("string" == typeof _) return i.toString() + _;
+    if (i = _JSBI.__toNumeric(i), _ = _JSBI.__toNumeric(_), _JSBI.__isBigInt(i) && _JSBI.__isBigInt(_)) return _JSBI.add(i, _);
+    if ("number" == typeof i && "number" == typeof _) return i + _;
+    throw new TypeError("Cannot mix BigInt and other types, use explicit conversions");
+  }
+  static LT(i, _) {
+    return _JSBI.__compare(i, _, 0);
+  }
+  static LE(i, _) {
+    return _JSBI.__compare(i, _, 1);
+  }
+  static GT(i, _) {
+    return _JSBI.__compare(i, _, 2);
+  }
+  static GE(i, _) {
+    return _JSBI.__compare(i, _, 3);
+  }
+  static EQ(i, _) {
+    for (; ; ) {
+      if (_JSBI.__isBigInt(i)) return _JSBI.__isBigInt(_) ? _JSBI.equal(i, _) : _JSBI.EQ(_, i);
+      if ("number" == typeof i) {
+        if (_JSBI.__isBigInt(_)) return _JSBI.__equalToNumber(_, i);
+        if ("object" != typeof _) return i == _;
+        _ = _JSBI.__toPrimitive(_);
+      } else if ("string" == typeof i) {
+        if (_JSBI.__isBigInt(_)) return i = _JSBI.__fromString(i), null !== i && _JSBI.equal(i, _);
+        if ("object" != typeof _) return i == _;
+        _ = _JSBI.__toPrimitive(_);
+      } else if ("boolean" == typeof i) {
+        if (_JSBI.__isBigInt(_)) return _JSBI.__equalToNumber(_, +i);
+        if ("object" != typeof _) return i == _;
+        _ = _JSBI.__toPrimitive(_);
+      } else if ("symbol" == typeof i) {
+        if (_JSBI.__isBigInt(_)) return false;
+        if ("object" != typeof _) return i == _;
+        _ = _JSBI.__toPrimitive(_);
+      } else if ("object" == typeof i) {
+        if ("object" == typeof _ && _.constructor !== _JSBI) return i == _;
+        i = _JSBI.__toPrimitive(i);
+      } else return i == _;
+    }
+  }
+  static NE(i, _) {
+    return !_JSBI.EQ(i, _);
+  }
+  static __zero() {
+    return new _JSBI(0, false);
+  }
+  static __oneDigit(i, _) {
+    const t = new _JSBI(1, _);
+    return t.__setDigit(0, i), t;
+  }
+  __copy() {
+    const _ = new _JSBI(this.length, this.sign);
+    for (let t = 0; t < this.length; t++) _[t] = this[t];
+    return _;
+  }
+  __trim() {
+    let i = this.length, _ = this[i - 1];
+    for (; 0 === _; ) i--, _ = this[i - 1], this.pop();
+    return 0 === i && (this.sign = false), this;
+  }
+  __initializeDigits() {
+    for (let _ = 0; _ < this.length; _++) this[_] = 0;
+  }
+  static __decideRounding(i, _, t, e) {
+    if (0 < _) return -1;
+    let n;
+    if (0 > _) n = -_ - 1;
+    else {
+      if (0 === t) return -1;
+      t--, e = i.__digit(t), n = 29;
+    }
+    let g = 1 << n;
+    if (0 == (e & g)) return -1;
+    if (g -= 1, 0 != (e & g)) return 1;
+    for (; 0 < t; ) if (t--, 0 !== i.__digit(t)) return 1;
+    return 0;
+  }
+  static __fromDouble(i) {
+    _JSBI.__kBitConversionDouble[0] = i;
+    const _ = 2047 & _JSBI.__kBitConversionInts[1] >>> 20, t = _ - 1023, e = (0 | t / 30) + 1, n = new _JSBI(e, 0 > i);
+    let g = 1048575 & _JSBI.__kBitConversionInts[1] | 1048576, o = _JSBI.__kBitConversionInts[0];
+    const s = 20, l = t % 30;
+    let r, a = 0;
+    if (l < 20) {
+      const i2 = s - l;
+      a = i2 + 32, r = g >>> i2, g = g << 32 - i2 | o >>> i2, o <<= 32 - i2;
+    } else if (l === 20) a = 32, r = g, g = o, o = 0;
+    else {
+      const i2 = l - s;
+      a = 32 - i2, r = g << i2 | o >>> 32 - i2, g = o << i2, o = 0;
+    }
+    n.__setDigit(e - 1, r);
+    for (let _2 = e - 2; 0 <= _2; _2--) 0 < a ? (a -= 30, r = g >>> 2, g = g << 30 | o >>> 2, o <<= 30) : r = 0, n.__setDigit(_2, r);
+    return n.__trim();
+  }
+  static __isWhitespace(i) {
+    return !!(13 >= i && 9 <= i) || (159 >= i ? 32 == i : 131071 >= i ? 160 == i || 5760 == i : 196607 >= i ? (i &= 131071, 10 >= i || 40 == i || 41 == i || 47 == i || 95 == i || 4096 == i) : 65279 == i);
+  }
+  static __fromString(i, _ = 0) {
+    let t = 0;
+    const e = i.length;
+    let n = 0;
+    if (n === e) return _JSBI.__zero();
+    let g = i.charCodeAt(n);
+    for (; _JSBI.__isWhitespace(g); ) {
+      if (++n === e) return _JSBI.__zero();
+      g = i.charCodeAt(n);
+    }
+    if (43 === g) {
+      if (++n === e) return null;
+      g = i.charCodeAt(n), t = 1;
+    } else if (45 === g) {
+      if (++n === e) return null;
+      g = i.charCodeAt(n), t = -1;
+    }
+    if (0 === _) {
+      if (_ = 10, 48 === g) {
+        if (++n === e) return _JSBI.__zero();
+        if (g = i.charCodeAt(n), 88 === g || 120 === g) {
+          if (_ = 16, ++n === e) return null;
+          g = i.charCodeAt(n);
+        } else if (79 === g || 111 === g) {
+          if (_ = 8, ++n === e) return null;
+          g = i.charCodeAt(n);
+        } else if (66 === g || 98 === g) {
+          if (_ = 2, ++n === e) return null;
+          g = i.charCodeAt(n);
+        }
+      }
+    } else if (16 === _ && 48 === g) {
+      if (++n === e) return _JSBI.__zero();
+      if (g = i.charCodeAt(n), 88 === g || 120 === g) {
+        if (++n === e) return null;
+        g = i.charCodeAt(n);
+      }
+    }
+    if (0 != t && 10 !== _) return null;
+    for (; 48 === g; ) {
+      if (++n === e) return _JSBI.__zero();
+      g = i.charCodeAt(n);
+    }
+    const o = e - n;
+    let s = _JSBI.__kMaxBitsPerChar[_], l = _JSBI.__kBitsPerCharTableMultiplier - 1;
+    if (o > 1073741824 / s) return null;
+    const r = s * o + l >>> _JSBI.__kBitsPerCharTableShift, a = new _JSBI(0 | (r + 29) / 30, false), u = 10 > _ ? _ : 10, h = 10 < _ ? _ - 10 : 0;
+    if (0 == (_ & _ - 1)) {
+      s >>= _JSBI.__kBitsPerCharTableShift;
+      const _2 = [], t2 = [];
+      let o2 = false;
+      do {
+        let l2 = 0, r2 = 0;
+        for (; ; ) {
+          let _3;
+          if (g - 48 >>> 0 < u) _3 = g - 48;
+          else if ((32 | g) - 97 >>> 0 < h) _3 = (32 | g) - 87;
+          else {
+            o2 = true;
+            break;
+          }
+          if (r2 += s, l2 = l2 << s | _3, ++n === e) {
+            o2 = true;
+            break;
+          }
+          if (g = i.charCodeAt(n), 30 < r2 + s) break;
+        }
+        _2.push(l2), t2.push(r2);
+      } while (!o2);
+      _JSBI.__fillFromParts(a, _2, t2);
+    } else {
+      a.__initializeDigits();
+      let t2 = false, o2 = 0;
+      do {
+        let r2 = 0, b = 1;
+        for (; ; ) {
+          let s2;
+          if (g - 48 >>> 0 < u) s2 = g - 48;
+          else if ((32 | g) - 97 >>> 0 < h) s2 = (32 | g) - 87;
+          else {
+            t2 = true;
+            break;
+          }
+          const l2 = b * _;
+          if (1073741823 < l2) break;
+          if (b = l2, r2 = r2 * _ + s2, o2++, ++n === e) {
+            t2 = true;
+            break;
+          }
+          g = i.charCodeAt(n);
+        }
+        l = 30 * _JSBI.__kBitsPerCharTableMultiplier - 1;
+        const D = 0 | (s * o2 + l >>> _JSBI.__kBitsPerCharTableShift) / 30;
+        a.__inplaceMultiplyAdd(b, r2, D);
+      } while (!t2);
+    }
+    if (n !== e) {
+      if (!_JSBI.__isWhitespace(g)) return null;
+      for (n++; n < e; n++) if (g = i.charCodeAt(n), !_JSBI.__isWhitespace(g)) return null;
+    }
+    return a.sign = -1 == t, a.__trim();
+  }
+  static __fillFromParts(_, t, e) {
+    let n = 0, g = 0, o = 0;
+    for (let s = t.length - 1; 0 <= s; s--) {
+      const i = t[s], l = e[s];
+      g |= i << o, o += l, 30 === o ? (_.__setDigit(n++, g), o = 0, g = 0) : 30 < o && (_.__setDigit(n++, 1073741823 & g), o -= 30, g = i >>> l - o);
+    }
+    if (0 !== g) {
+      if (n >= _.length) throw new Error("implementation bug");
+      _.__setDigit(n++, g);
+    }
+    for (; n < _.length; n++) _.__setDigit(n, 0);
+  }
+  static __toStringBasePowerOfTwo(_, i) {
+    const t = _.length;
+    let e = i - 1;
+    e = (85 & e >>> 1) + (85 & e), e = (51 & e >>> 2) + (51 & e), e = (15 & e >>> 4) + (15 & e);
+    const n = e, g = i - 1, o = _.__digit(t - 1), s = _JSBI.__clz30(o);
+    let l = 0 | (30 * t - s + n - 1) / n;
+    if (_.sign && l++, 268435456 < l) throw new Error("string too long");
+    const r = Array(l);
+    let a = l - 1, u = 0, d = 0;
+    for (let e2 = 0; e2 < t - 1; e2++) {
+      const i2 = _.__digit(e2), t2 = (u | i2 << d) & g;
+      r[a--] = _JSBI.__kConversionChars[t2];
+      const o2 = n - d;
+      for (u = i2 >>> o2, d = 30 - o2; d >= n; ) r[a--] = _JSBI.__kConversionChars[u & g], u >>>= n, d -= n;
+    }
+    const h = (u | o << d) & g;
+    for (r[a--] = _JSBI.__kConversionChars[h], u = o >>> n - d; 0 !== u; ) r[a--] = _JSBI.__kConversionChars[u & g], u >>>= n;
+    if (_.sign && (r[a--] = "-"), -1 != a) throw new Error("implementation bug");
+    return r.join("");
+  }
+  static __toStringGeneric(_, i, t) {
+    const e = _.length;
+    if (0 === e) return "";
+    if (1 === e) {
+      let e2 = _.__unsignedDigit(0).toString(i);
+      return false === t && _.sign && (e2 = "-" + e2), e2;
+    }
+    const n = 30 * e - _JSBI.__clz30(_.__digit(e - 1)), g = _JSBI.__kMaxBitsPerChar[i], o = g - 1;
+    let s = n * _JSBI.__kBitsPerCharTableMultiplier;
+    s += o - 1, s = 0 | s / o;
+    const l = s + 1 >> 1, r = _JSBI.exponentiate(_JSBI.__oneDigit(i, false), _JSBI.__oneDigit(l, false));
+    let a, u;
+    const d = r.__unsignedDigit(0);
+    if (1 === r.length && 32767 >= d) {
+      a = new _JSBI(_.length, false), a.__initializeDigits();
+      let t2 = 0;
+      for (let e2 = 2 * _.length - 1; 0 <= e2; e2--) {
+        const i2 = t2 << 15 | _.__halfDigit(e2);
+        a.__setHalfDigit(e2, 0 | i2 / d), t2 = 0 | i2 % d;
+      }
+      u = t2.toString(i);
+    } else {
+      const t2 = _JSBI.__absoluteDivLarge(_, r, true, true);
+      a = t2.quotient;
+      const e2 = t2.remainder.__trim();
+      u = _JSBI.__toStringGeneric(e2, i, true);
+    }
+    a.__trim();
+    let h = _JSBI.__toStringGeneric(a, i, true);
+    for (; u.length < l; ) u = "0" + u;
+    return false === t && _.sign && (h = "-" + h), h + u;
+  }
+  static __unequalSign(i) {
+    return i ? -1 : 1;
+  }
+  static __absoluteGreater(i) {
+    return i ? -1 : 1;
+  }
+  static __absoluteLess(i) {
+    return i ? 1 : -1;
+  }
+  static __compareToBigInt(i, _) {
+    const t = i.sign;
+    if (t !== _.sign) return _JSBI.__unequalSign(t);
+    const e = _JSBI.__absoluteCompare(i, _);
+    return 0 < e ? _JSBI.__absoluteGreater(t) : 0 > e ? _JSBI.__absoluteLess(t) : 0;
+  }
+  static __compareToNumber(i, _) {
+    if (_JSBI.__isOneDigitInt(_)) {
+      const t = i.sign, e = 0 > _;
+      if (t !== e) return _JSBI.__unequalSign(t);
+      if (0 === i.length) {
+        if (e) throw new Error("implementation bug");
+        return 0 === _ ? 0 : -1;
+      }
+      if (1 < i.length) return _JSBI.__absoluteGreater(t);
+      const n = Math.abs(_), g = i.__unsignedDigit(0);
+      return g > n ? _JSBI.__absoluteGreater(t) : g < n ? _JSBI.__absoluteLess(t) : 0;
+    }
+    return _JSBI.__compareToDouble(i, _);
+  }
+  static __compareToDouble(i, _) {
+    if (_ !== _) return _;
+    if (_ === 1 / 0) return -1;
+    if (_ === -Infinity) return 1;
+    const t = i.sign;
+    if (t !== 0 > _) return _JSBI.__unequalSign(t);
+    if (0 === _) throw new Error("implementation bug: should be handled elsewhere");
+    if (0 === i.length) return -1;
+    _JSBI.__kBitConversionDouble[0] = _;
+    const e = 2047 & _JSBI.__kBitConversionInts[1] >>> 20;
+    if (2047 == e) throw new Error("implementation bug: handled elsewhere");
+    const n = e - 1023;
+    if (0 > n) return _JSBI.__absoluteGreater(t);
+    const g = i.length;
+    let o = i.__digit(g - 1);
+    const s = _JSBI.__clz30(o), l = 30 * g - s, r = n + 1;
+    if (l < r) return _JSBI.__absoluteLess(t);
+    if (l > r) return _JSBI.__absoluteGreater(t);
+    let a = 1048576 | 1048575 & _JSBI.__kBitConversionInts[1], u = _JSBI.__kBitConversionInts[0];
+    const d = 20, h = 29 - s;
+    if (h !== (0 | (l - 1) % 30)) throw new Error("implementation bug");
+    let m, b = 0;
+    if (20 > h) {
+      const i2 = d - h;
+      b = i2 + 32, m = a >>> i2, a = a << 32 - i2 | u >>> i2, u <<= 32 - i2;
+    } else if (20 === h) b = 32, m = a, a = u, u = 0;
+    else {
+      const i2 = h - d;
+      b = 32 - i2, m = a << i2 | u >>> 32 - i2, a = u << i2, u = 0;
+    }
+    if (o >>>= 0, m >>>= 0, o > m) return _JSBI.__absoluteGreater(t);
+    if (o < m) return _JSBI.__absoluteLess(t);
+    for (let e2 = g - 2; 0 <= e2; e2--) {
+      0 < b ? (b -= 30, m = a >>> 2, a = a << 30 | u >>> 2, u <<= 30) : m = 0;
+      const _2 = i.__unsignedDigit(e2);
+      if (_2 > m) return _JSBI.__absoluteGreater(t);
+      if (_2 < m) return _JSBI.__absoluteLess(t);
+    }
+    if (0 !== a || 0 !== u) {
+      if (0 === b) throw new Error("implementation bug");
+      return _JSBI.__absoluteLess(t);
+    }
+    return 0;
+  }
+  static __equalToNumber(i, _) {
+    var t = Math.abs;
+    return _JSBI.__isOneDigitInt(_) ? 0 === _ ? 0 === i.length : 1 === i.length && i.sign === 0 > _ && i.__unsignedDigit(0) === t(_) : 0 === _JSBI.__compareToDouble(i, _);
+  }
+  static __comparisonResultToBool(i, _) {
+    return 0 === _ ? 0 > i : 1 === _ ? 0 >= i : 2 === _ ? 0 < i : 3 === _ ? 0 <= i : void 0;
+  }
+  static __compare(i, _, t) {
+    if (i = _JSBI.__toPrimitive(i), _ = _JSBI.__toPrimitive(_), "string" == typeof i && "string" == typeof _) switch (t) {
+      case 0:
+        return i < _;
+      case 1:
+        return i <= _;
+      case 2:
+        return i > _;
+      case 3:
+        return i >= _;
+    }
+    if (_JSBI.__isBigInt(i) && "string" == typeof _) return _ = _JSBI.__fromString(_), null !== _ && _JSBI.__comparisonResultToBool(_JSBI.__compareToBigInt(i, _), t);
+    if ("string" == typeof i && _JSBI.__isBigInt(_)) return i = _JSBI.__fromString(i), null !== i && _JSBI.__comparisonResultToBool(_JSBI.__compareToBigInt(i, _), t);
+    if (i = _JSBI.__toNumeric(i), _ = _JSBI.__toNumeric(_), _JSBI.__isBigInt(i)) {
+      if (_JSBI.__isBigInt(_)) return _JSBI.__comparisonResultToBool(_JSBI.__compareToBigInt(i, _), t);
+      if ("number" != typeof _) throw new Error("implementation bug");
+      return _JSBI.__comparisonResultToBool(_JSBI.__compareToNumber(i, _), t);
+    }
+    if ("number" != typeof i) throw new Error("implementation bug");
+    if (_JSBI.__isBigInt(_)) return _JSBI.__comparisonResultToBool(_JSBI.__compareToNumber(_, i), 2 ^ t);
+    if ("number" != typeof _) throw new Error("implementation bug");
+    return 0 === t ? i < _ : 1 === t ? i <= _ : 2 === t ? i > _ : 3 === t ? i >= _ : void 0;
+  }
+  __clzmsd() {
+    return _JSBI.__clz30(this.__digit(this.length - 1));
+  }
+  static __absoluteAdd(_, t, e) {
+    if (_.length < t.length) return _JSBI.__absoluteAdd(t, _, e);
+    if (0 === _.length) return _;
+    if (0 === t.length) return _.sign === e ? _ : _JSBI.unaryMinus(_);
+    let n = _.length;
+    (0 === _.__clzmsd() || t.length === _.length && 0 === t.__clzmsd()) && n++;
+    const g = new _JSBI(n, e);
+    let o = 0, s = 0;
+    for (; s < t.length; s++) {
+      const i = _.__digit(s) + t.__digit(s) + o;
+      o = i >>> 30, g.__setDigit(s, 1073741823 & i);
+    }
+    for (; s < _.length; s++) {
+      const i = _.__digit(s) + o;
+      o = i >>> 30, g.__setDigit(s, 1073741823 & i);
+    }
+    return s < g.length && g.__setDigit(s, o), g.__trim();
+  }
+  static __absoluteSub(_, t, e) {
+    if (0 === _.length) return _;
+    if (0 === t.length) return _.sign === e ? _ : _JSBI.unaryMinus(_);
+    const n = new _JSBI(_.length, e);
+    let g = 0, o = 0;
+    for (; o < t.length; o++) {
+      const i = _.__digit(o) - t.__digit(o) - g;
+      g = 1 & i >>> 30, n.__setDigit(o, 1073741823 & i);
+    }
+    for (; o < _.length; o++) {
+      const i = _.__digit(o) - g;
+      g = 1 & i >>> 30, n.__setDigit(o, 1073741823 & i);
+    }
+    return n.__trim();
+  }
+  static __absoluteAddOne(_, i, t = null) {
+    const e = _.length;
+    null === t ? t = new _JSBI(e, i) : t.sign = i;
+    let n = 1;
+    for (let g = 0; g < e; g++) {
+      const i2 = _.__digit(g) + n;
+      n = i2 >>> 30, t.__setDigit(g, 1073741823 & i2);
+    }
+    return 0 != n && t.__setDigitGrow(e, 1), t;
+  }
+  static __absoluteSubOne(_, t) {
+    const e = _.length;
+    t = t || e;
+    const n = new _JSBI(t, false);
+    let g = 1;
+    for (let o = 0; o < e; o++) {
+      const i = _.__digit(o) - g;
+      g = 1 & i >>> 30, n.__setDigit(o, 1073741823 & i);
+    }
+    if (0 != g) throw new Error("implementation bug");
+    for (let g2 = e; g2 < t; g2++) n.__setDigit(g2, 0);
+    return n;
+  }
+  static __absoluteAnd(_, t, e = null) {
+    let n = _.length, g = t.length, o = g;
+    if (n < g) {
+      o = n;
+      const i = _, e2 = n;
+      _ = t, n = g, t = i, g = e2;
+    }
+    let s = o;
+    null === e ? e = new _JSBI(s, false) : s = e.length;
+    let l = 0;
+    for (; l < o; l++) e.__setDigit(l, _.__digit(l) & t.__digit(l));
+    for (; l < s; l++) e.__setDigit(l, 0);
+    return e;
+  }
+  static __absoluteAndNot(_, t, e = null) {
+    const n = _.length, g = t.length;
+    let o = g;
+    n < g && (o = n);
+    let s = n;
+    null === e ? e = new _JSBI(s, false) : s = e.length;
+    let l = 0;
+    for (; l < o; l++) e.__setDigit(l, _.__digit(l) & ~t.__digit(l));
+    for (; l < n; l++) e.__setDigit(l, _.__digit(l));
+    for (; l < s; l++) e.__setDigit(l, 0);
+    return e;
+  }
+  static __absoluteOr(_, t, e = null) {
+    let n = _.length, g = t.length, o = g;
+    if (n < g) {
+      o = n;
+      const i = _, e2 = n;
+      _ = t, n = g, t = i, g = e2;
+    }
+    let s = n;
+    null === e ? e = new _JSBI(s, false) : s = e.length;
+    let l = 0;
+    for (; l < o; l++) e.__setDigit(l, _.__digit(l) | t.__digit(l));
+    for (; l < n; l++) e.__setDigit(l, _.__digit(l));
+    for (; l < s; l++) e.__setDigit(l, 0);
+    return e;
+  }
+  static __absoluteXor(_, t, e = null) {
+    let n = _.length, g = t.length, o = g;
+    if (n < g) {
+      o = n;
+      const i = _, e2 = n;
+      _ = t, n = g, t = i, g = e2;
+    }
+    let s = n;
+    null === e ? e = new _JSBI(s, false) : s = e.length;
+    let l = 0;
+    for (; l < o; l++) e.__setDigit(l, _.__digit(l) ^ t.__digit(l));
+    for (; l < n; l++) e.__setDigit(l, _.__digit(l));
+    for (; l < s; l++) e.__setDigit(l, 0);
+    return e;
+  }
+  static __absoluteCompare(_, t) {
+    const e = _.length - t.length;
+    if (0 != e) return e;
+    let n = _.length - 1;
+    for (; 0 <= n && _.__digit(n) === t.__digit(n); ) n--;
+    return 0 > n ? 0 : _.__unsignedDigit(n) > t.__unsignedDigit(n) ? 1 : -1;
+  }
+  static __multiplyAccumulate(_, t, e, n) {
+    if (0 === t) return;
+    const g = 32767 & t, o = t >>> 15;
+    let s = 0, l = 0;
+    for (let r, a = 0; a < _.length; a++, n++) {
+      r = e.__digit(n);
+      const i = _.__digit(a), t2 = 32767 & i, u = i >>> 15, d = _JSBI.__imul(t2, g), h = _JSBI.__imul(t2, o), m = _JSBI.__imul(u, g), b = _JSBI.__imul(u, o);
+      r += l + d + s, s = r >>> 30, r &= 1073741823, r += ((32767 & h) << 15) + ((32767 & m) << 15), s += r >>> 30, l = b + (h >>> 15) + (m >>> 15), e.__setDigit(n, 1073741823 & r);
+    }
+    for (; 0 != s || 0 !== l; n++) {
+      let i = e.__digit(n);
+      i += s + l, l = 0, s = i >>> 30, e.__setDigit(n, 1073741823 & i);
+    }
+  }
+  static __internalMultiplyAdd(_, t, e, g, o) {
+    let s = e, l = 0;
+    for (let n = 0; n < g; n++) {
+      const i = _.__digit(n), e2 = _JSBI.__imul(32767 & i, t), g2 = _JSBI.__imul(i >>> 15, t), a = e2 + ((32767 & g2) << 15) + l + s;
+      s = a >>> 30, l = g2 >>> 15, o.__setDigit(n, 1073741823 & a);
+    }
+    if (o.length > g) for (o.__setDigit(g++, s + l); g < o.length; ) o.__setDigit(g++, 0);
+    else if (0 !== s + l) throw new Error("implementation bug");
+  }
+  __inplaceMultiplyAdd(i, _, t) {
+    t > this.length && (t = this.length);
+    const e = 32767 & i, n = i >>> 15;
+    let g = 0, o = _;
+    for (let s = 0; s < t; s++) {
+      const i2 = this.__digit(s), _2 = 32767 & i2, t2 = i2 >>> 15, l = _JSBI.__imul(_2, e), r = _JSBI.__imul(_2, n), a = _JSBI.__imul(t2, e), u = _JSBI.__imul(t2, n);
+      let d = o + l + g;
+      g = d >>> 30, d &= 1073741823, d += ((32767 & r) << 15) + ((32767 & a) << 15), g += d >>> 30, o = u + (r >>> 15) + (a >>> 15), this.__setDigit(s, 1073741823 & d);
+    }
+    if (0 != g || 0 !== o) throw new Error("implementation bug");
+  }
+  static __absoluteDivSmall(_, t, e = null) {
+    null === e && (e = new _JSBI(_.length, false));
+    let n = 0;
+    for (let g, o = 2 * _.length - 1; 0 <= o; o -= 2) {
+      g = (n << 15 | _.__halfDigit(o)) >>> 0;
+      const i = 0 | g / t;
+      n = 0 | g % t, g = (n << 15 | _.__halfDigit(o - 1)) >>> 0;
+      const s = 0 | g / t;
+      n = 0 | g % t, e.__setDigit(o >>> 1, i << 15 | s);
+    }
+    return e;
+  }
+  static __absoluteModSmall(_, t) {
+    let e = 0;
+    for (let n = 2 * _.length - 1; 0 <= n; n--) {
+      const i = (e << 15 | _.__halfDigit(n)) >>> 0;
+      e = 0 | i % t;
+    }
+    return e;
+  }
+  static __absoluteDivLarge(i, _, t, e) {
+    const g = _.__halfDigitLength(), n = _.length, o = i.__halfDigitLength() - g;
+    let s = null;
+    t && (s = new _JSBI(o + 2 >>> 1, false), s.__initializeDigits());
+    const l = new _JSBI(g + 2 >>> 1, false);
+    l.__initializeDigits();
+    const r = _JSBI.__clz15(_.__halfDigit(g - 1));
+    0 < r && (_ = _JSBI.__specialLeftShift(_, r, 0));
+    const a = _JSBI.__specialLeftShift(i, r, 1), u = _.__halfDigit(g - 1);
+    let d = 0;
+    for (let r2, h = o; 0 <= h; h--) {
+      r2 = 32767;
+      const i2 = a.__halfDigit(h + g);
+      if (i2 !== u) {
+        const t2 = (i2 << 15 | a.__halfDigit(h + g - 1)) >>> 0;
+        r2 = 0 | t2 / u;
+        let e3 = 0 | t2 % u;
+        const n2 = _.__halfDigit(g - 2), o2 = a.__halfDigit(h + g - 2);
+        for (; _JSBI.__imul(r2, n2) >>> 0 > (e3 << 16 | o2) >>> 0 && (r2--, e3 += u, !(32767 < e3)); ) ;
+      }
+      _JSBI.__internalMultiplyAdd(_, r2, 0, n, l);
+      let e2 = a.__inplaceSub(l, h, g + 1);
+      0 !== e2 && (e2 = a.__inplaceAdd(_, h, g), a.__setHalfDigit(h + g, 32767 & a.__halfDigit(h + g) + e2), r2--), t && (1 & h ? d = r2 << 15 : s.__setDigit(h >>> 1, d | r2));
+    }
+    if (e) return a.__inplaceRightShift(r), t ? { quotient: s, remainder: a } : a;
+    if (t) return s;
+    throw new Error("unreachable");
+  }
+  static __clz15(i) {
+    return _JSBI.__clz30(i) - 15;
+  }
+  __inplaceAdd(_, t, e) {
+    let n = 0;
+    for (let g = 0; g < e; g++) {
+      const i = this.__halfDigit(t + g) + _.__halfDigit(g) + n;
+      n = i >>> 15, this.__setHalfDigit(t + g, 32767 & i);
+    }
+    return n;
+  }
+  __inplaceSub(_, t, e) {
+    let n = 0;
+    if (1 & t) {
+      t >>= 1;
+      let g = this.__digit(t), o = 32767 & g, s = 0;
+      for (; s < e - 1 >>> 1; s++) {
+        const i2 = _.__digit(s), e2 = (g >>> 15) - (32767 & i2) - n;
+        n = 1 & e2 >>> 15, this.__setDigit(t + s, (32767 & e2) << 15 | 32767 & o), g = this.__digit(t + s + 1), o = (32767 & g) - (i2 >>> 15) - n, n = 1 & o >>> 15;
+      }
+      const i = _.__digit(s), l = (g >>> 15) - (32767 & i) - n;
+      n = 1 & l >>> 15, this.__setDigit(t + s, (32767 & l) << 15 | 32767 & o);
+      if (t + s + 1 >= this.length) throw new RangeError("out of bounds");
+      0 == (1 & e) && (g = this.__digit(t + s + 1), o = (32767 & g) - (i >>> 15) - n, n = 1 & o >>> 15, this.__setDigit(t + _.length, 1073709056 & g | 32767 & o));
+    } else {
+      t >>= 1;
+      let g = 0;
+      for (; g < _.length - 1; g++) {
+        const i2 = this.__digit(t + g), e2 = _.__digit(g), o2 = (32767 & i2) - (32767 & e2) - n;
+        n = 1 & o2 >>> 15;
+        const s2 = (i2 >>> 15) - (e2 >>> 15) - n;
+        n = 1 & s2 >>> 15, this.__setDigit(t + g, (32767 & s2) << 15 | 32767 & o2);
+      }
+      const i = this.__digit(t + g), o = _.__digit(g), s = (32767 & i) - (32767 & o) - n;
+      n = 1 & s >>> 15;
+      let l = 0;
+      0 == (1 & e) && (l = (i >>> 15) - (o >>> 15) - n, n = 1 & l >>> 15), this.__setDigit(t + g, (32767 & l) << 15 | 32767 & s);
+    }
+    return n;
+  }
+  __inplaceRightShift(_) {
+    if (0 === _) return;
+    let t = this.__digit(0) >>> _;
+    const e = this.length - 1;
+    for (let n = 0; n < e; n++) {
+      const i = this.__digit(n + 1);
+      this.__setDigit(n, 1073741823 & i << 30 - _ | t), t = i >>> _;
+    }
+    this.__setDigit(e, t);
+  }
+  static __specialLeftShift(_, t, e) {
+    const g = _.length, n = new _JSBI(g + e, false);
+    if (0 === t) {
+      for (let t2 = 0; t2 < g; t2++) n.__setDigit(t2, _.__digit(t2));
+      return 0 < e && n.__setDigit(g, 0), n;
+    }
+    let o = 0;
+    for (let s = 0; s < g; s++) {
+      const i = _.__digit(s);
+      n.__setDigit(s, 1073741823 & i << t | o), o = i >>> 30 - t;
+    }
+    return 0 < e && n.__setDigit(g, o), n;
+  }
+  static __leftShiftByAbsolute(_, i) {
+    const t = _JSBI.__toShiftAmount(i);
+    if (0 > t) throw new RangeError("BigInt too big");
+    const e = 0 | t / 30, n = t % 30, g = _.length, o = 0 !== n && 0 != _.__digit(g - 1) >>> 30 - n, s = g + e + (o ? 1 : 0), l = new _JSBI(s, _.sign);
+    if (0 === n) {
+      let t2 = 0;
+      for (; t2 < e; t2++) l.__setDigit(t2, 0);
+      for (; t2 < s; t2++) l.__setDigit(t2, _.__digit(t2 - e));
+    } else {
+      let t2 = 0;
+      for (let _2 = 0; _2 < e; _2++) l.__setDigit(_2, 0);
+      for (let o2 = 0; o2 < g; o2++) {
+        const i2 = _.__digit(o2);
+        l.__setDigit(o2 + e, 1073741823 & i2 << n | t2), t2 = i2 >>> 30 - n;
+      }
+      if (o) l.__setDigit(g + e, t2);
+      else if (0 !== t2) throw new Error("implementation bug");
+    }
+    return l.__trim();
+  }
+  static __rightShiftByAbsolute(_, i) {
+    const t = _.length, e = _.sign, n = _JSBI.__toShiftAmount(i);
+    if (0 > n) return _JSBI.__rightShiftByMaximum(e);
+    const g = 0 | n / 30, o = n % 30;
+    let s = t - g;
+    if (0 >= s) return _JSBI.__rightShiftByMaximum(e);
+    let l = false;
+    if (e) {
+      if (0 != (_.__digit(g) & (1 << o) - 1)) l = true;
+      else for (let t2 = 0; t2 < g; t2++) if (0 !== _.__digit(t2)) {
+        l = true;
+        break;
+      }
+    }
+    if (l && 0 === o) {
+      const i2 = _.__digit(t - 1);
+      0 == ~i2 && s++;
+    }
+    let r = new _JSBI(s, e);
+    if (0 === o) {
+      r.__setDigit(s - 1, 0);
+      for (let e2 = g; e2 < t; e2++) r.__setDigit(e2 - g, _.__digit(e2));
+    } else {
+      let e2 = _.__digit(g) >>> o;
+      const n2 = t - g - 1;
+      for (let t2 = 0; t2 < n2; t2++) {
+        const i2 = _.__digit(t2 + g + 1);
+        r.__setDigit(t2, 1073741823 & i2 << 30 - o | e2), e2 = i2 >>> o;
+      }
+      r.__setDigit(n2, e2);
+    }
+    return l && (r = _JSBI.__absoluteAddOne(r, true, r)), r.__trim();
+  }
+  static __rightShiftByMaximum(i) {
+    return i ? _JSBI.__oneDigit(1, true) : _JSBI.__zero();
+  }
+  static __toShiftAmount(i) {
+    if (1 < i.length) return -1;
+    const _ = i.__unsignedDigit(0);
+    return _ > _JSBI.__kMaxLengthBits ? -1 : _;
+  }
+  static __toPrimitive(i, _ = "default") {
+    if ("object" != typeof i) return i;
+    if (i.constructor === _JSBI) return i;
+    if ("undefined" != typeof Symbol && "symbol" == typeof Symbol.toPrimitive) {
+      const t2 = i[Symbol.toPrimitive];
+      if (t2) {
+        const i2 = t2(_);
+        if ("object" != typeof i2) return i2;
+        throw new TypeError("Cannot convert object to primitive value");
+      }
+    }
+    const t = i.valueOf;
+    if (t) {
+      const _2 = t.call(i);
+      if ("object" != typeof _2) return _2;
+    }
+    const e = i.toString;
+    if (e) {
+      const _2 = e.call(i);
+      if ("object" != typeof _2) return _2;
+    }
+    throw new TypeError("Cannot convert object to primitive value");
+  }
+  static __toNumeric(i) {
+    return _JSBI.__isBigInt(i) ? i : +i;
+  }
+  static __isBigInt(i) {
+    return "object" == typeof i && null !== i && i.constructor === _JSBI;
+  }
+  static __truncateToNBits(i, _) {
+    const t = 0 | (i + 29) / 30, e = new _JSBI(t, _.sign), n = t - 1;
+    for (let t2 = 0; t2 < n; t2++) e.__setDigit(t2, _.__digit(t2));
+    let g = _.__digit(n);
+    if (0 != i % 30) {
+      const _2 = 32 - i % 30;
+      g = g << _2 >>> _2;
+    }
+    return e.__setDigit(n, g), e.__trim();
+  }
+  static __truncateAndSubFromPowerOfTwo(_, t, e) {
+    var n = Math.min;
+    const g = 0 | (_ + 29) / 30, o = new _JSBI(g, e);
+    let s = 0;
+    const l = g - 1;
+    let a = 0;
+    for (const i = n(l, t.length); s < i; s++) {
+      const i2 = 0 - t.__digit(s) - a;
+      a = 1 & i2 >>> 30, o.__setDigit(s, 1073741823 & i2);
+    }
+    for (; s < l; s++) o.__setDigit(s, 0 | 1073741823 & -a);
+    let u = l < t.length ? t.__digit(l) : 0;
+    const d = _ % 30;
+    let h;
+    if (0 == d) h = 0 - u - a, h &= 1073741823;
+    else {
+      const i = 32 - d;
+      u = u << i >>> i;
+      const _2 = 1 << 32 - i;
+      h = _2 - u - a, h &= _2 - 1;
+    }
+    return o.__setDigit(l, h), o.__trim();
+  }
+  __digit(_) {
+    return this[_];
+  }
+  __unsignedDigit(_) {
+    return this[_] >>> 0;
+  }
+  __setDigit(_, i) {
+    this[_] = 0 | i;
+  }
+  __setDigitGrow(_, i) {
+    this[_] = 0 | i;
+  }
+  __halfDigitLength() {
+    const i = this.length;
+    return 32767 >= this.__unsignedDigit(i - 1) ? 2 * i - 1 : 2 * i;
+  }
+  __halfDigit(_) {
+    return 32767 & this[_ >>> 1] >>> 15 * (1 & _);
+  }
+  __setHalfDigit(_, i) {
+    const t = _ >>> 1, e = this.__digit(t), n = 1 & _ ? 32767 & e | i << 15 : 1073709056 & e | 32767 & i;
+    this.__setDigit(t, n);
+  }
+  static __digitPow(i, _) {
+    let t = 1;
+    for (; 0 < _; ) 1 & _ && (t *= i), _ >>>= 1, i *= i;
+    return t;
+  }
+  static __isOneDigitInt(i) {
+    return (1073741823 & i) === i;
+  }
+};
+JSBI.__kMaxLength = 33554432, JSBI.__kMaxLengthBits = JSBI.__kMaxLength << 5, JSBI.__kMaxBitsPerChar = [0, 0, 32, 51, 64, 75, 83, 90, 96, 102, 107, 111, 115, 119, 122, 126, 128, 131, 134, 136, 139, 141, 143, 145, 147, 149, 151, 153, 154, 156, 158, 159, 160, 162, 163, 165, 166], JSBI.__kBitsPerCharTableShift = 5, JSBI.__kBitsPerCharTableMultiplier = 1 << JSBI.__kBitsPerCharTableShift, JSBI.__kConversionChars = ["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"], JSBI.__kBitConversionBuffer = new ArrayBuffer(8), JSBI.__kBitConversionDouble = new Float64Array(JSBI.__kBitConversionBuffer), JSBI.__kBitConversionInts = new Int32Array(JSBI.__kBitConversionBuffer), JSBI.__clz30 = Math.clz32 ? function(i) {
+  return Math.clz32(i) - 2;
+} : function(i) {
+  return 0 === i ? 30 : 0 | 29 - (0 | Math.log(i >>> 0) / Math.LN2);
+}, JSBI.__imul = Math.imul || function(i, _) {
+  return 0 | i * _;
+};
+var jsbi_default = JSBI;
+
+// src/types/CustomFeePair.ts
+var CustomFeePair = class extends UniPair {
+  // Override getOutputAmount for 1% fee
+  getOutputAmount(inputAmount) {
+    const inputReserve = this.reserveOf(inputAmount.currency);
+    const outputCurrency = this.token0.equals(inputAmount.currency) ? this.token1 : this.token0;
+    const outputReserve = this.reserveOf(outputCurrency);
+    const feeNumerator = jsbi_default.BigInt(99);
+    const feeDenominator = jsbi_default.BigInt(100);
+    const inputAmountWithFee = jsbi_default.divide(jsbi_default.multiply(inputAmount.quotient, feeNumerator), feeDenominator);
+    const numerator = jsbi_default.multiply(inputAmountWithFee, outputReserve.quotient);
+    const denominator = jsbi_default.add(inputReserve.quotient, inputAmountWithFee);
+    const outputAmount = jsbi_default.divide(numerator, denominator);
+    return [
+      CurrencyAmount.fromRawAmount(outputCurrency, outputAmount),
+      this
+    ];
+  }
+  // Override getInputAmount for 1% fee
+  getInputAmount(outputAmount) {
+    const outputReserve = this.reserveOf(outputAmount.currency);
+    const inputCurrency = this.token0.equals(outputAmount.currency) ? this.token1 : this.token0;
+    const inputReserve = this.reserveOf(inputCurrency);
+    const feeNumerator = jsbi_default.BigInt(100);
+    const feeDenominator = jsbi_default.BigInt(99);
+    const numerator = jsbi_default.multiply(jsbi_default.multiply(inputReserve.quotient, outputAmount.quotient), feeNumerator);
+    const denominator = jsbi_default.multiply(jsbi_default.subtract(outputReserve.quotient, outputAmount.quotient), feeDenominator);
+    const inputAmount = jsbi_default.add(jsbi_default.divide(numerator, denominator), jsbi_default.BigInt(1));
+    return [
+      CurrencyAmount.fromRawAmount(inputCurrency, inputAmount),
+      this
+    ];
+  }
+};
+
+// src/services/swap.service.ts
 var PARTNER_FEE_BPS_DIVISOR = 10000n;
 var SwapService = class {
   constructor(provider, config, swapOptions) {
@@ -151,9 +1222,8 @@ var SwapService = class {
     this.resolvePairsLoaded = null;
     this.resolvePartnerFeeLoaded = null;
     this.partnerFee = 0n;
-    this.isFeeActive = false;
     this.provider = provider;
-    this.wethAddress = config.wethAddress;
+    this.wethAddress = config.wrappedToken.address;
     this.chainId = config.chainId;
     const routerAbi = [
       // Swaps (ERC20 <-> ERC20)
@@ -179,8 +1249,7 @@ var SwapService = class {
     ];
     const proxyAbi = [
       ...routerAbi,
-      "function partnerFee(bytes32) external view returns (address feeRecipient, uint16 feeBps)",
-      "function feeEnabled() external view returns (bool)"
+      "function partners(bytes32) external view returns (address feeRecipient, uint16 feeBps)"
     ];
     this.routerContract = new Contract(config.routerAddress, routerAbi, provider);
     this.factoryContract = new Contract(config.factoryAddress, factoryAbi, provider);
@@ -201,13 +1270,10 @@ var SwapService = class {
     if (!this.resolvePairsLoaded) {
       return this.partnerFee;
     }
-    if (this.swapOptions.partnerKey) {
-      const [, fee] = await this.proxyContract?.partnerFee(this.swapOptions.partnerKey);
+    if (this.swapOptions.partnerKey && this.proxyContract) {
+      const [, fee] = await this.proxyContract?.partners(this.swapOptions.partnerKey);
       this.partnerFee = fee;
     }
-    this.partnerFee = 100n;
-    const isFeeActive = await this.proxyContract?.feeEnabled();
-    this.isFeeActive = isFeeActive;
     if (this.resolvePartnerFeeLoaded) {
       this.resolvePartnerFeeLoaded();
       this.resolvePartnerFeeLoaded = null;
@@ -296,14 +1362,14 @@ var SwapService = class {
   }
   createSDKPair(pair) {
     const { token0, token1, id, reserve0, reserve1 } = pair;
-    const sdkToken0 = new Token(
+    const sdkToken0 = new Token2(
       this.chainId,
       token0.id,
       Number(token0.decimals),
       token0.symbol,
       token0.name
     );
-    const sdkToken1 = new Token(
+    const sdkToken1 = new Token2(
       this.chainId,
       token1.id,
       Number(token1.decimals),
@@ -318,15 +1384,15 @@ var SwapService = class {
     } else {
       throw new Error("No reserves data");
     }
-    const amount0 = CurrencyAmount.fromRawAmount(
+    const amount0 = CurrencyAmount2.fromRawAmount(
       sdkToken0,
       reserve0BN.toString()
     );
-    const amount1 = CurrencyAmount.fromRawAmount(
+    const amount1 = CurrencyAmount2.fromRawAmount(
       sdkToken1,
       reserve1BN.toString()
     );
-    const sdkPair = new Pair(amount0, amount1);
+    const sdkPair = new CustomFeePair(amount0, amount1);
     return sdkPair;
   }
   /**
@@ -340,21 +1406,21 @@ var SwapService = class {
    * Returns the best path as an array of addresses, or null if no trade found.
    */
   async getBestTrade(fromToken, toToken, amountInWei, isOutputAmount) {
-    const sdkFromToken = new Token(
+    const sdkFromToken = new Token2(
       this.chainId,
       fromToken.address,
       fromToken.decimals,
       fromToken.symbol,
       fromToken.name
     );
-    const sdkToToken = new Token(
+    const sdkToToken = new Token2(
       this.chainId,
       toToken.address,
       toToken.decimals,
       toToken.symbol,
       toToken.name
     );
-    const currencyAmount = CurrencyAmount.fromRawAmount(
+    const currencyAmount = CurrencyAmount2.fromRawAmount(
       isOutputAmount ? sdkToToken : sdkFromToken,
       amountInWei
     );
@@ -406,9 +1472,11 @@ var SwapService = class {
         const denominator = PARTNER_FEE_BPS_DIVISOR - this.partnerFee;
         sellAmountWei = (numerator + denominator - 1n) / denominator;
       }
+      const sellTokenForContracts = sellToken.address == ethers.ZeroAddress ? this.wethToken : sellToken;
+      const buyTokenForContracts = buyToken.address == ethers.ZeroAddress ? this.wethToken : buyToken;
       const trade = await this.getBestTrade(
-        sellToken.address == ethers.ZeroAddress ? this.wethToken : sellToken,
-        buyToken.address == ethers.ZeroAddress ? this.wethToken : buyToken,
+        sellTokenForContracts,
+        buyTokenForContracts,
         sellAmountWei.toString(),
         isOutputAmount
       );
@@ -519,7 +1587,7 @@ var SwapService = class {
       const signerAddress = await this.signer.getAddress();
       const iface = this.proxyContract ? this.proxyContract.interface : this.routerContract.interface;
       let swapData;
-      const to = this.isFeeActive ? this.config.proxyAddress : signerAddress;
+      const to = this.config.proxyAddress ? this.config.proxyAddress : signerAddress;
       if (isOutputAmount) {
         if (fromToken.address === ethers.ZeroAddress) {
           swapData = iface.encodeFunctionData("swapETHForExactTokens", [
@@ -572,7 +1640,7 @@ var SwapService = class {
         }
       }
       if (this.proxyContract) {
-        swapData = hexlify(this.concatSelectorAndParams(ethers.getBytes(swapData), [], "permit", this.swapOptions.partnerKey));
+        swapData = hexlify(this.concatSelectorAndParams(ethers.getBytes(swapData), [], "PERMIT", this.swapOptions.partnerKey));
       }
       tx = await this.signer.sendTransaction({
         to: this.config.proxyAddress || this.config.routerAddress,
@@ -606,21 +1674,21 @@ var SwapService = class {
   // Uniswap SDK methods for advanced trading
   async createTrade(fromToken, toToken, amountIn, slippageTolerance = 0.5) {
     try {
-      const fromTokenInstance = new Token(
+      const fromTokenInstance = new Token2(
         this.chainId,
         fromToken.address,
         fromToken.decimals,
         fromToken.symbol,
         fromToken.name
       );
-      const toTokenInstance = new Token(
+      const toTokenInstance = new Token2(
         this.chainId,
         toToken.address,
         toToken.decimals,
         toToken.symbol,
         toToken.name
       );
-      const currencyAmount = CurrencyAmount.fromRawAmount(
+      const currencyAmount = CurrencyAmount2.fromRawAmount(
         fromTokenInstance,
         parseUnits(amountIn, fromToken.decimals).toString()
       );
@@ -628,9 +1696,9 @@ var SwapService = class {
       if (pairAddress === ZeroAddress) {
         throw new Error("No liquidity pair found");
       }
-      const pair = new Pair(
-        CurrencyAmount.fromRawAmount(fromTokenInstance, "0"),
-        CurrencyAmount.fromRawAmount(toTokenInstance, "0")
+      const pair = new CustomFeePair(
+        CurrencyAmount2.fromRawAmount(fromTokenInstance, "0"),
+        CurrencyAmount2.fromRawAmount(toTokenInstance, "0")
       );
       const route = new Route([pair], fromTokenInstance, toTokenInstance);
       const trade = new Trade(
@@ -709,7 +1777,7 @@ var SwapService = class {
     ];
     if (partnerKey) {
       const partnerKeyBytes = ethers.getBytes(partnerKey);
-      const partnerFlagHash = ethers.keccak256(ethers.toUtf8Bytes("is_partner_fee"));
+      const partnerFlagHash = ethers.keccak256(ethers.toUtf8Bytes("PARTNER"));
       const partnerFlagBytes = ethers.getBytes(partnerFlagHash).slice(0, 16);
       parts.push(partnerKeyBytes, partnerFlagBytes);
     }
@@ -892,7 +1960,7 @@ var SwapSdkController = class {
     }
   }
   async getPartnerFee() {
-    return Number(await this.swapService.loadPartnerFee()) / Number(PARTNER_FEE_BPS_DIVISOR);
+    return Number(await this.swapService.loadPartnerFee()) / 100;
   }
   async getTokensFromGraph(limit = 100, search) {
     if (!this.swapService) {
@@ -906,21 +1974,33 @@ var SwapSdkController = class {
 };
 
 // src/config/networks.ts
+import { ethers as ethers2 } from "ethers";
 var NETWORKS = {
   "kasplex-testnet": {
     name: "Kasplex Test",
     chainId: 167012,
     rpcUrl: "https://rpc.kasplextest.xyz",
-    routerAddress: "0x5A410f79f58a11344E3523d99820Cf231bc888bd",
-    factoryAddress: "0x772B3321B37C1a9aeF0Da1B5A6453E1C2A264beF",
-    proxyAddress: "0xbE448f863d2bB7bCcD9185A854DF2D8d63498dB0",
-    wethAddress: "0x654A3287c317D4Fc6e8482FeF523Dc4572b563AA",
-    graphEndpoint: "https://dev-graph-kasplex.kaspa.com/subgraphs/name/uniswap-v2",
+    routerAddress: "0x81Cc4e7DbC652ec9168Bc2F4435C02d7F315148e",
+    factoryAddress: "0x89d5842017ceA7dd18D10EE6c679cE199d2aD99E",
+    proxyAddress: "0x5B7e7830851816f8ad968B0e0c336bd50b4860Ad",
+    graphEndpoint: "https://dev-graph-kasplex.kaspa.com/subgraphs/name/kasplex-testnet-new-v2-core",
     blockExplorerUrl: "https://explorer.testnet.kasplextest.xyz",
     additionalJsonRpcApiProviderOptionsOptions: {
       batchMaxCount: 1,
       batchMaxSize: 1,
       batchStallTime: 0
+    },
+    wrappedToken: {
+      address: "0xf40178040278E16c8813dB20a84119A605812FB3",
+      decimals: 18,
+      name: "Wrapped Kasplex Kaspa",
+      symbol: "WKAS"
+    },
+    nativeToken: {
+      address: ethers2.ZeroAddress,
+      decimals: 18,
+      name: "Kasplex Kaspa",
+      symbol: "KAS"
     }
   }
   // Add more networks as needed