@kaspacom/swap-sdk 1.1.3 → 1.1.4

package/dist/index.cjs

@@ -0,0 +1,2063 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_SWAP_SETTINGS: () => DEFAULT_SETTINGS,
+  LoaderStatuses: () => LoaderStatuses,
+  NETWORKS: () => NETWORKS,
+  SwapSdkController: () => SwapSdkController,
+  SwapService: () => SwapService,
+  WalletService: () => WalletService,
+  createKaspaComSwapController: () => createKaspaComSwapController
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/index.ts
+var LoaderStatuses = /* @__PURE__ */ ((LoaderStatuses2) => {
+  LoaderStatuses2[LoaderStatuses2["CALCULATING_QUOTE"] = 1] = "CALCULATING_QUOTE";
+  LoaderStatuses2[LoaderStatuses2["APPROVING"] = 2] = "APPROVING";
+  LoaderStatuses2[LoaderStatuses2["SWAPPING"] = 3] = "SWAPPING";
+  return LoaderStatuses2;
+})(LoaderStatuses || {});
+
+// src/services/wallet.service.ts
+var import_ethers = require("ethers");
+var WalletService = class {
+  // injected provider (window.ethereum or similar)
+  constructor(config, injectedProvider) {
+    this.signer = null;
+    this.address = null;
+    this.config = config;
+    this.networkProvider = new import_ethers.JsonRpcProvider(config.rpcUrl, {
+      name: config.name,
+      chainId: config.chainId
+    }, config.additionalJsonRpcApiProviderOptionsOptions);
+    if (injectedProvider) {
+      this.connect(this.injectedProvider);
+    }
+  }
+  async connect(injectedProvider) {
+    if (injectedProvider) {
+      this.injectedProvider = injectedProvider;
+      this.walletProvider = new import_ethers.BrowserProvider(this.injectedProvider);
+    }
+    if (!this.injectedProvider || !this.walletProvider) {
+      throw new Error("Please connect wallet.");
+    }
+    try {
+      const accounts = await this.injectedProvider.request({
+        method: "eth_requestAccounts"
+      });
+      if (accounts.length === 0) {
+        throw new Error("No accounts found");
+      }
+      this.address = accounts[0];
+      const chainId = await this.injectedProvider.request({
+        method: "eth_chainId"
+      });
+      const currentChainId = parseInt(chainId, 16);
+      if (currentChainId !== this.config.chainId) {
+        try {
+          await this.injectedProvider.request({
+            method: "wallet_switchEthereumChain",
+            params: [{ chainId: `0x${this.config.chainId.toString(16)}` }]
+          });
+        } catch (switchError) {
+          if (switchError.code === 4902) {
+            await this.injectedProvider.request({
+              method: "wallet_addEthereumChain",
+              params: [{
+                chainId: `0x${this.config.chainId.toString(16)}`,
+                chainName: this.config.name,
+                nativeCurrency: {
+                  name: "ETH",
+                  symbol: "ETH",
+                  decimals: 18
+                },
+                rpcUrls: [this.config.rpcUrl],
+                blockExplorerUrls: this.config.blockExplorerUrl ? [this.config.blockExplorerUrl] : []
+              }]
+            });
+            await this.injectedProvider.request({
+              method: "wallet_switchEthereumChain",
+              params: [{ chainId: `0x${this.config.chainId.toString(16)}` }]
+            });
+          } else {
+            throw new Error(`Please switch to ${this.config.name} network`);
+          }
+        }
+      }
+      this.signer = await this.walletProvider.getSigner();
+      return this.address;
+    } catch (error) {
+      if (error.code === 4001) {
+        throw new Error("User rejected wallet connection");
+      }
+      throw new Error(`Failed to connect wallet: ${error.message}`);
+    }
+  }
+  disconnect() {
+    this.address = null;
+    this.signer = null;
+  }
+  isConnected() {
+    return !!this.address && !!this.signer;
+  }
+  getAddress() {
+    return this.address;
+  }
+  getProvider() {
+    return this.walletProvider || this.networkProvider;
+  }
+  getSigner() {
+    return this.signer;
+  }
+  // Helper method to get current chain ID
+  async getCurrentChainId() {
+    if (!this.injectedProvider) {
+      throw new Error("No Ethereum wallet detected");
+    }
+    const chainId = await this.injectedProvider.request({
+      method: "eth_chainId"
+    });
+    return parseInt(chainId, 16);
+  }
+  // Connect wallet and emit event with address
+  async connectWallet() {
+    if (this.injectedProvider) {
+      try {
+        const accounts = await this.injectedProvider.request({
+          method: "eth_requestAccounts"
+        });
+        if (accounts.length > 0 && typeof accounts[0] === "string") {
+          const address = accounts[0];
+          this.address = address;
+          return address;
+        } else {
+          throw new Error("No accounts found");
+        }
+      } catch (error) {
+        console.error("Failed to connect wallet:", error);
+        throw error;
+      }
+    } else {
+      throw new Error("No Ethereum wallet detected. Please connect a wallet provider.");
+    }
+  }
+  // Disconnect wallet and emit event
+  disconnectWallet() {
+    this.address = null;
+    this.signer = null;
+  }
+};
+
+// src/services/swap.service.ts
+var import_ethers2 = require("ethers");
+var import_sdk_core2 = require("@uniswap/sdk-core");
+var import_v2_sdk2 = require("@uniswap/v2-sdk");
+
+// src/types/CustomFeePair.ts
+var import_sdk_core = require("@uniswap/sdk-core");
+var import_v2_sdk = require("@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 import_v2_sdk.Pair {
+  // 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 [
+      import_sdk_core.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 [
+      import_sdk_core.CurrencyAmount.fromRawAmount(inputCurrency, inputAmount),
+      this
+    ];
+  }
+};
+
+// src/services/swap.service.ts
+var PARTNER_FEE_BPS_DIVISOR = 10000n;
+var SwapService = class {
+  constructor(provider, config, swapOptions) {
+    this.config = config;
+    this.swapOptions = swapOptions;
+    this.signer = null;
+    this.pairs = [];
+    this.resolvePairsLoaded = null;
+    this.resolvePartnerFeeLoaded = null;
+    this.partnerFee = 0n;
+    this.provider = provider;
+    this.wethAddress = config.wrappedToken.address;
+    this.chainId = config.chainId;
+    const routerAbi = [
+      // Swaps (ERC20 <-> ERC20)
+      "function swapExactTokensForTokens(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)",
+      "function swapTokensForExactTokens(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)",
+      // Swaps (ETH <-> ERC20)
+      "function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts)",
+      "function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline) external payable returns (uint[] memory amounts)",
+      "function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)",
+      "function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline) external returns (uint[] memory amounts)",
+      // Get Amounts
+      "function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts)",
+      "function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut)",
+      "function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) internal pure returns (uint amountIn)",
+      "function getAmountsIn(address factory, uint amountOut, address[] memory path) internal view returns (uint[] memory amounts)",
+      // Get WETH
+      "function WETH() external pure returns (address)"
+    ];
+    const factoryAbi = [
+      "function getPair(address tokenA, address tokenB) external view returns (address pair)",
+      "function allPairs(uint) external view returns (address pair)",
+      "function allPairsLength() external view returns (uint)"
+    ];
+    const proxyAbi = [
+      ...routerAbi,
+      "function partners(bytes32) external view returns (address feeRecipient, uint16 feeBps)"
+    ];
+    this.routerContract = new import_ethers2.Contract(config.routerAddress, routerAbi, provider);
+    this.factoryContract = new import_ethers2.Contract(config.factoryAddress, factoryAbi, provider);
+    if (config.proxyAddress) {
+      this.proxyContract = new import_ethers2.Contract(config.proxyAddress, proxyAbi, provider);
+    }
+    this.pairsLoadedPromise = new Promise((resolve) => {
+      this.resolvePairsLoaded = resolve;
+    });
+    this.partnerFeeLoadedPromise = new Promise((resolve) => {
+      this.resolvePartnerFeeLoaded = resolve;
+    });
+    this.loadAllPairsFromGraph();
+    this.loadPartnerFee();
+  }
+  // parnter fee is BPS_DIVISOR = 10_000n;
+  async loadPartnerFee() {
+    if (!this.resolvePairsLoaded) {
+      return this.partnerFee;
+    }
+    if (this.swapOptions.partnerKey && this.proxyContract) {
+      const [, fee] = await this.proxyContract?.partners(this.swapOptions.partnerKey);
+      this.partnerFee = fee;
+    }
+    if (this.resolvePartnerFeeLoaded) {
+      this.resolvePartnerFeeLoaded();
+      this.resolvePartnerFeeLoaded = null;
+    }
+    return this.partnerFee;
+  }
+  setSigner(signer) {
+    this.signer = signer;
+    this.routerContract = this.routerContract.connect(signer);
+    if (this.proxyContract) {
+      this.proxyContract = this.proxyContract.connect(signer);
+    }
+  }
+  /**
+   * Rounds a number string to the specified number of decimal places
+   * to avoid parseUnits errors with too many decimals
+   */
+  roundToDecimals(value, decimals) {
+    const num = parseFloat(value);
+    if (isNaN(num)) {
+      return "0";
+    }
+    return num.toFixed(decimals);
+  }
+  /**
+   * Loads all pairs from The Graph and caches them as Uniswap SDK Pair instances.
+   * @param graphEndpoint The GraphQL endpoint URL
+   */
+  async loadAllPairsFromGraph() {
+    const query = `{
+      pairs(first: 1000) {
+        id
+        reserve0
+        reserve1
+        token0 { id symbol name decimals }
+        token1 { id symbol name decimals }
+      }
+    }`;
+    try {
+      const response = await fetch(this.config.graphEndpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ query })
+      });
+      if (!response.ok) throw new Error(`Network error: ${response.status}`);
+      const { data } = await response.json();
+      if (!data || !data.pairs) return;
+      const pairs = [];
+      for (const pair of data.pairs) {
+        pairs.push(
+          this.createSDKPair(pair)
+        );
+      }
+      this.pairs = pairs;
+      const wethPair = data.pairs.find(
+        (pair) => pair.token0.id.toLowerCase() === this.wethAddress.toLowerCase() || pair.token1.id.toLowerCase() === this.wethAddress.toLowerCase()
+      );
+      if (wethPair) {
+        const tokenData = wethPair.token0.id.toLowerCase() === this.wethAddress.toLowerCase() ? wethPair.token0 : wethPair.token1;
+        this.wethToken = {
+          address: tokenData.id,
+          symbol: tokenData.symbol,
+          name: tokenData.name,
+          decimals: Number(tokenData.decimals)
+        };
+      } else {
+        throw new Error("No weth token found");
+      }
+      if (this.resolvePairsLoaded) {
+        this.resolvePairsLoaded();
+        this.resolvePairsLoaded = null;
+      }
+    } catch (error) {
+      console.error("Error loading pairs from graph:", error);
+      if (this.resolvePairsLoaded) {
+        this.resolvePairsLoaded();
+        this.resolvePairsLoaded = null;
+      }
+    }
+  }
+  async waitForPairsLoaded() {
+    return await this.pairsLoadedPromise;
+  }
+  async waitForPartnerFeeLoaded() {
+    return await this.partnerFeeLoadedPromise;
+  }
+  createSDKPair(pair) {
+    const { token0, token1, id, reserve0, reserve1 } = pair;
+    const sdkToken0 = new import_sdk_core2.Token(
+      this.chainId,
+      token0.id,
+      Number(token0.decimals),
+      token0.symbol,
+      token0.name
+    );
+    const sdkToken1 = new import_sdk_core2.Token(
+      this.chainId,
+      token1.id,
+      Number(token1.decimals),
+      token1.symbol,
+      token1.name
+    );
+    let reserve0BN;
+    let reserve1BN;
+    if (reserve0 && reserve1) {
+      reserve0BN = (0, import_ethers2.parseUnits)(reserve0, Number(token0.decimals));
+      reserve1BN = (0, import_ethers2.parseUnits)(reserve1, Number(token1.decimals));
+    } else {
+      throw new Error("No reserves data");
+    }
+    const amount0 = import_sdk_core2.CurrencyAmount.fromRawAmount(
+      sdkToken0,
+      reserve0BN.toString()
+    );
+    const amount1 = import_sdk_core2.CurrencyAmount.fromRawAmount(
+      sdkToken1,
+      reserve1BN.toString()
+    );
+    const sdkPair = new CustomFeePair(amount0, amount1);
+    return sdkPair;
+  }
+  /**
+   * Returns the cached pairs for use in routing.
+   */
+  getPairs() {
+    return this.pairs;
+  }
+  /**
+   * Finds the best trade path using Uniswap SDK for a given input amount.
+   * Returns the best path as an array of addresses, or null if no trade found.
+   */
+  async getBestTrade(fromToken, toToken, amountInWei, isOutputAmount) {
+    const sdkFromToken = new import_sdk_core2.Token(
+      this.chainId,
+      fromToken.address,
+      fromToken.decimals,
+      fromToken.symbol,
+      fromToken.name
+    );
+    const sdkToToken = new import_sdk_core2.Token(
+      this.chainId,
+      toToken.address,
+      toToken.decimals,
+      toToken.symbol,
+      toToken.name
+    );
+    const currencyAmount = import_sdk_core2.CurrencyAmount.fromRawAmount(
+      isOutputAmount ? sdkToToken : sdkFromToken,
+      amountInWei
+    );
+    await this.waitForPairsLoaded();
+    await this.waitForPartnerFeeLoaded();
+    const pairs = this.getPairs();
+    if (!pairs || pairs.length === 0) {
+      throw new Error("Pairs not loaded yet. Please wait for initialization.");
+    }
+    const tradeConfig = {
+      maxHops: 3,
+      maxNumResults: 1
+    };
+    const trades = isOutputAmount ? import_v2_sdk2.Trade.bestTradeExactOut(pairs, sdkFromToken, currencyAmount, tradeConfig) : import_v2_sdk2.Trade.bestTradeExactIn(
+      pairs,
+      currencyAmount,
+      sdkToToken,
+      tradeConfig
+    );
+    if (trades.length > 0) {
+      return trades[0];
+    } else {
+      return null;
+    }
+  }
+  trimTrailingZeros(value) {
+    if (!value.includes(".")) return value;
+    value = value.replace(/\.?0+$/, "");
+    return value;
+  }
+  /**
+   * 
+   * @param sellToken 
+   * @param buyToken 
+   * @param targetAmount 
+   * @param isOutputAmount true if user input output (How much tokens to receive) and not input (how much tokens to sell)
+   * @param slippage 
+   * @returns 
+   */
+  async calculateTrade(sellToken, buyToken, targetAmount, isOutputAmount, slippage) {
+    try {
+      const roundedAmountIn = this.roundToDecimals(targetAmount, isOutputAmount ? buyToken.decimals : sellToken.decimals);
+      let sellAmountWei = (0, import_ethers2.parseUnits)(
+        roundedAmountIn,
+        isOutputAmount ? buyToken.decimals : sellToken.decimals
+      );
+      if (isOutputAmount && this.partnerFee && this.partnerFee > 0n) {
+        const numerator = sellAmountWei * PARTNER_FEE_BPS_DIVISOR;
+        const denominator = PARTNER_FEE_BPS_DIVISOR - this.partnerFee;
+        sellAmountWei = (numerator + denominator - 1n) / denominator;
+      }
+      const sellTokenForContracts = sellToken.address == import_ethers2.ethers.ZeroAddress ? this.wethToken : sellToken;
+      const buyTokenForContracts = buyToken.address == import_ethers2.ethers.ZeroAddress ? this.wethToken : buyToken;
+      const trade = await this.getBestTrade(
+        sellTokenForContracts,
+        buyTokenForContracts,
+        sellAmountWei.toString(),
+        isOutputAmount
+      );
+      if (!trade) {
+        throw new Error("No trade path found for the given tokens and amount.");
+      }
+      const amountIn = trade.inputAmount.quotient.toString();
+      const amountOut = trade.outputAmount.quotient.toString();
+      let amounts = {
+        amountIn: (0, import_ethers2.formatUnits)(amountIn, sellToken.decimals),
+        amountOut: isOutputAmount ? this.trimTrailingZeros(roundedAmountIn) : (0, import_ethers2.formatUnits)(amountOut, buyToken.decimals),
+        amountInRaw: amountIn,
+        amountOutRaw: amountOut
+      };
+      const slippagePercent = new import_sdk_core2.Percent(Math.round(parseFloat(slippage) * 100), 1e4);
+      let maxAmountIn, minAmountOut;
+      if (isOutputAmount) {
+        maxAmountIn = trade.maximumAmountIn(slippagePercent).quotient.toString();
+        amounts.maxAmountInRaw = maxAmountIn;
+        amounts.maxAmountIn = (0, import_ethers2.formatUnits)(maxAmountIn, sellToken.decimals);
+      } else {
+        minAmountOut = trade.minimumAmountOut(slippagePercent).quotient.toString();
+        amounts.minAmountOutRaw = minAmountOut;
+        amounts.minAmountOut = (0, import_ethers2.formatUnits)(minAmountOut, buyToken.decimals);
+      }
+      if (this.partnerFee && this.partnerFee > 0n) {
+        if (!isOutputAmount) {
+          const amountOut2 = BigInt(trade.outputAmount.quotient.toString());
+          const amountOutMinusFee = amountOut2 * (PARTNER_FEE_BPS_DIVISOR - this.partnerFee) / PARTNER_FEE_BPS_DIVISOR;
+          amounts.amountOutRaw = amountOutMinusFee.toString();
+          amounts.amountOut = (0, import_ethers2.formatUnits)(amountOutMinusFee, buyToken.decimals);
+          if (minAmountOut) {
+            const minOut = BigInt(minAmountOut.toString());
+            const minOutMinusFee = minOut * (PARTNER_FEE_BPS_DIVISOR - this.partnerFee) / PARTNER_FEE_BPS_DIVISOR;
+            amounts.minAmountOutRaw = minOutMinusFee.toString();
+            amounts.minAmountOut = (0, import_ethers2.formatUnits)(minOutMinusFee, buyToken.decimals);
+          }
+        }
+      }
+      return {
+        trade,
+        computed: amounts
+      };
+    } catch (error) {
+      console.error("Error calculating expected output:", error);
+      throw error;
+    }
+  }
+  async checkApproval(tokenAddress, amount, spenderAddress) {
+    try {
+      const tokenContract = new import_ethers2.Contract(
+        tokenAddress,
+        ["function allowance(address,address) view returns (uint256)"],
+        this.provider
+      );
+      const signerAddress = await this.signer?.getAddress();
+      if (!signerAddress) {
+        throw new Error("Please connect wallet first");
+      }
+      const allowance = await tokenContract.allowance(signerAddress, spenderAddress);
+      const amountWei = (0, import_ethers2.parseUnits)(amount, 18);
+      return allowance >= amountWei;
+    } catch (error) {
+      console.error("Error checking approval:", error);
+      return false;
+    }
+  }
+  async isApprovalNeeded(fromToken, amountInWei) {
+    if (!this.signer) {
+      throw new Error("Please connect wallet first");
+    }
+    if (fromToken.address !== import_ethers2.ethers.ZeroAddress) {
+      const tokenContract = new import_ethers2.Contract(
+        fromToken.address,
+        ["function allowance(address,address) view returns (uint256)", "function approve(address,uint256) returns (bool)"],
+        this.signer
+      );
+      const signerAddress = await this.signer.getAddress();
+      const allowanceTo = this.config.proxyAddress || this.config.routerAddress;
+      const allowance = await tokenContract.allowance(signerAddress, allowanceTo);
+      if (allowance < amountInWei) {
+        return {
+          isApprovalNeeded: true,
+          tokenContract,
+          signerAddress,
+          allowanceTo
+        };
+      }
+    }
+    return {
+      isApprovalNeeded: false
+    };
+  }
+  async approveIfNeedApproval(fromToken, amountInWei) {
+    const isApprovalNeededInfo = await this.isApprovalNeeded(fromToken, amountInWei);
+    if (!isApprovalNeededInfo.isApprovalNeeded) {
+      return null;
+    }
+    return await isApprovalNeededInfo.tokenContract.approve(isApprovalNeededInfo.allowanceTo, import_ethers2.ethers.MaxUint256);
+  }
+  async swapTokens(fromToken, toToken, amountInWei, amountOutWei, path, isOutputAmount, deadline) {
+    if (!this.signer) {
+      throw new Error("Please connect wallet first");
+    }
+    try {
+      const deadlineTimestamp = Math.floor(Date.now() / 1e3) + deadline * 60;
+      let tx;
+      const signerAddress = await this.signer.getAddress();
+      const iface = this.proxyContract ? this.proxyContract.interface : this.routerContract.interface;
+      let swapData;
+      const to = this.config.proxyAddress ? this.config.proxyAddress : signerAddress;
+      if (isOutputAmount) {
+        if (fromToken.address === import_ethers2.ethers.ZeroAddress) {
+          swapData = iface.encodeFunctionData("swapETHForExactTokens", [
+            amountOutWei,
+            path,
+            to,
+            deadlineTimestamp
+          ]);
+        } else if (toToken.address === import_ethers2.ethers.ZeroAddress) {
+          swapData = iface.encodeFunctionData("swapTokensForExactETH", [
+            amountOutWei,
+            amountInWei,
+            path,
+            to,
+            deadlineTimestamp
+          ]);
+        } else {
+          swapData = iface.encodeFunctionData("swapTokensForExactTokens", [
+            amountOutWei,
+            amountInWei,
+            path,
+            to,
+            deadlineTimestamp
+          ]);
+        }
+      } else {
+        if (fromToken.address === import_ethers2.ethers.ZeroAddress) {
+          swapData = iface.encodeFunctionData("swapExactETHForTokens", [
+            amountOutWei,
+            path,
+            to,
+            deadlineTimestamp
+          ]);
+        } else if (toToken.address === import_ethers2.ethers.ZeroAddress) {
+          swapData = iface.encodeFunctionData("swapExactTokensForETH", [
+            amountInWei,
+            amountOutWei,
+            path,
+            to,
+            deadlineTimestamp
+          ]);
+        } else {
+          swapData = iface.encodeFunctionData("swapExactTokensForTokens", [
+            amountInWei,
+            amountOutWei,
+            path,
+            to,
+            deadlineTimestamp
+          ]);
+        }
+      }
+      if (this.proxyContract) {
+        swapData = (0, import_ethers2.hexlify)(this.concatSelectorAndParams(import_ethers2.ethers.getBytes(swapData), [], "PERMIT", this.swapOptions.partnerKey));
+      }
+      tx = await this.signer.sendTransaction({
+        to: this.config.proxyAddress || this.config.routerAddress,
+        from: signerAddress,
+        data: swapData,
+        value: fromToken.address === import_ethers2.ethers.ZeroAddress ? amountInWei : 0n
+      });
+      return tx;
+    } catch (error) {
+      console.error("Error swapping tokens:", error);
+      throw error;
+    }
+  }
+  async getPairAddress(tokenA, tokenB) {
+    try {
+      return await this.factoryContract.getPair(tokenA, tokenB);
+    } catch (error) {
+      console.error("Error getting pair address:", error);
+      throw error;
+    }
+  }
+  async checkLiquidityExists(tokenA, tokenB) {
+    try {
+      const pairAddress = await this.getPairAddress(tokenA, tokenB);
+      return pairAddress !== import_ethers2.ZeroAddress;
+    } catch (error) {
+      console.error("Error checking liquidity:", error);
+      return false;
+    }
+  }
+  // Uniswap SDK methods for advanced trading
+  async createTrade(fromToken, toToken, amountIn, slippageTolerance = 0.5) {
+    try {
+      const fromTokenInstance = new import_sdk_core2.Token(
+        this.chainId,
+        fromToken.address,
+        fromToken.decimals,
+        fromToken.symbol,
+        fromToken.name
+      );
+      const toTokenInstance = new import_sdk_core2.Token(
+        this.chainId,
+        toToken.address,
+        toToken.decimals,
+        toToken.symbol,
+        toToken.name
+      );
+      const currencyAmount = import_sdk_core2.CurrencyAmount.fromRawAmount(
+        fromTokenInstance,
+        (0, import_ethers2.parseUnits)(amountIn, fromToken.decimals).toString()
+      );
+      const pairAddress = await this.getPairAddress(fromToken.address, toToken.address);
+      if (pairAddress === import_ethers2.ZeroAddress) {
+        throw new Error("No liquidity pair found");
+      }
+      const pair = new CustomFeePair(
+        import_sdk_core2.CurrencyAmount.fromRawAmount(fromTokenInstance, "0"),
+        import_sdk_core2.CurrencyAmount.fromRawAmount(toTokenInstance, "0")
+      );
+      const route = new import_v2_sdk2.Route([pair], fromTokenInstance, toTokenInstance);
+      const trade = new import_v2_sdk2.Trade(
+        route,
+        currencyAmount,
+        import_sdk_core2.TradeType.EXACT_INPUT
+      );
+      return trade;
+    } catch (error) {
+      console.error("Error creating trade:", error);
+      throw error;
+    }
+  }
+  /**
+   * Fetch tokens from the graph endpoint (subgraph)
+   * @param graphEndpoint The GraphQL endpoint URL
+   * @param search Optional search string for symbol or name
+   */
+  async getTokensFromGraph(limit = 100, search) {
+    const finalLimit = Math.min(limit, 1e3);
+    const query = `{
+      tokens(first: ${finalLimit}, where: {
+        ${search ? `or: [
+          { symbol_contains_nocase: "${search}" }
+          { name_contains_nocase: "${search}" }
+        ]` : ""}
+      }) {
+        id
+        symbol
+        name
+        decimals
+      }
+    }`;
+    try {
+      const response = await fetch(this.config.graphEndpoint, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ query })
+      });
+      if (!response.ok) throw new Error(`Network error: ${response.status}`);
+      const { data } = await response.json();
+      if (!data || !data.tokens) return [];
+      return data.tokens.map((token) => ({
+        address: token.id,
+        symbol: token.symbol,
+        name: token.name,
+        decimals: Number(token.decimals)
+      }));
+    } catch (error) {
+      console.error("Error fetching tokens from graph:", error);
+      return [];
+    }
+  }
+  /**
+   * Concatenates bytes: selector, array of bytes (each element is Uint8Array), array length (uint8, 1 byte), marker (bytes16(keccak256(markerString)))
+   * @param selectorBytes Uint8Array — function selector (usually 4 bytes)
+   * @param arrayOfBytes Uint8Array[] — array of bytes (each element is Uint8Array)
+   * @param markerString string — string from which bytes16(keccak256(...)) will be derived
+   * @returns Uint8Array — concatenated result
+   */
+  concatSelectorAndParams(selectorBytes, arrayOfBytes, markerString, partnerKey) {
+    const paramsBytes = arrayOfBytes.length === 0 ? new Uint8Array(0) : arrayOfBytes.reduce((acc, arr) => {
+      const res = new Uint8Array(acc.length + arr.length);
+      res.set(acc, 0);
+      res.set(arr, acc.length);
+      return res;
+    });
+    const arrayLengthByte = new Uint8Array([arrayOfBytes.length & 255]);
+    const markerHash = import_ethers2.ethers.keccak256(import_ethers2.ethers.toUtf8Bytes(markerString));
+    const markerBytes = import_ethers2.ethers.getBytes(markerHash).slice(0, 16);
+    const parts = [
+      selectorBytes,
+      paramsBytes,
+      arrayLengthByte,
+      markerBytes
+    ];
+    if (partnerKey) {
+      const partnerKeyBytes = import_ethers2.ethers.getBytes(partnerKey);
+      const partnerFlagHash = import_ethers2.ethers.keccak256(import_ethers2.ethers.toUtf8Bytes("PARTNER"));
+      const partnerFlagBytes = import_ethers2.ethers.getBytes(partnerFlagHash).slice(0, 16);
+      parts.push(partnerKeyBytes, partnerFlagBytes);
+    }
+    const totalLen = parts.reduce((sum, p) => sum + p.length, 0);
+    const out = new Uint8Array(totalLen);
+    let offset = 0;
+    for (const p of parts) {
+      out.set(p, offset);
+      offset += p.length;
+    }
+    return out;
+  }
+};
+
+// src/controllers/swap-sdk.controller.ts
+var DEFAULT_SETTINGS = {
+  maxSlippage: "0.5",
+  swapDeadline: 20
+};
+var SwapSdkController = class {
+  constructor(options) {
+    this.state = {
+      loader: null
+    };
+    this.input = {
+      fromToken: null,
+      toToken: null,
+      amount: void 0,
+      isOutputAmount: false,
+      settings: DEFAULT_SETTINGS
+    };
+    this.options = options;
+    this.initServices();
+  }
+  initServices() {
+    this.walletService = new WalletService(
+      this.options.networkConfig,
+      this.options.walletProvider
+    );
+    this.swapService = new SwapService(
+      this.walletService.getProvider(),
+      this.options.networkConfig,
+      this.options
+    );
+  }
+  async setChange(patch) {
+    const next = {
+      ...this.state,
+      ...patch
+    };
+    this.state = next;
+    if (typeof this.options.onChange === "function") {
+      await this.options.onChange(next, patch);
+    }
+  }
+  async connectWallet(injectedProvider) {
+    const address = await this.walletService.connect(injectedProvider);
+    const signer = this.walletService.getSigner();
+    if (signer) this.swapService.setSigner(signer);
+    return address;
+  }
+  disconnectWallet() {
+    this.walletService.disconnect();
+    this.swapService.setSigner(null);
+  }
+  getState() {
+    return this.state;
+  }
+  get settings() {
+    return {
+      ...DEFAULT_SETTINGS,
+      ...this.input.settings || {}
+    };
+  }
+  async calculateQuoteIfNeeded() {
+    const { fromToken, toToken, amount, isOutputAmount } = this.input;
+    if (!fromToken || !toToken || !amount || amount <= 0) {
+      return;
+    }
+    await this.setChange({ loader: 1 /* CALCULATING_QUOTE */, error: void 0 });
+    try {
+      const tradeResult = await this.swapService.calculateTrade(
+        fromToken,
+        toToken,
+        String(amount),
+        isOutputAmount == true,
+        // isOutputAmount: true for input amount, false for output amount
+        this.settings.maxSlippage
+      );
+      await this.setChange({
+        computed: tradeResult.computed,
+        tradeInfo: tradeResult.trade,
+        loader: null
+      });
+    } catch (error) {
+      await this.setChange({ error: error?.message || String(error), loader: null });
+    }
+  }
+  async setData(input) {
+    this.input = {
+      ...this.input,
+      ...input
+    };
+    await this.calculateQuoteIfNeeded();
+    return this.getState();
+  }
+  async isNeedApproval() {
+    if (!this.input || !this.walletService.isConnected() || !this.swapService) throw new Error("Wallet not connected or input missing");
+    const { fromToken, amount } = this.input;
+    if (!fromToken || amount === void 0 || !this.state.computed?.amountInRaw) throw new Error("fromToken or amount missing");
+    return (await this.swapService.isApprovalNeeded(fromToken, BigInt(this.state.computed.amountInRaw))).isApprovalNeeded;
+  }
+  async approveIfNeeded() {
+    if (!this.input || !this.walletService.isConnected()) throw new Error("Wallet not connected or input missing");
+    const { fromToken, amount } = this.input;
+    if (!fromToken || amount === void 0 || !this.state.computed?.amountInRaw) throw new Error("fromToken or amount missing");
+    await this.setChange({ loader: 2 /* APPROVING */ });
+    try {
+      const tx = await this.swapService?.approveIfNeedApproval(
+        fromToken,
+        BigInt(this.state.computed.amountInRaw)
+      );
+      let receipt;
+      if (tx) {
+        await this.setChange({ approveTxHash: tx.hash });
+        receipt = await tx.wait();
+        if (!receipt) {
+          throw new Error("Receipt not found, Please try again");
+        }
+        if (receipt.status != 1) {
+          throw new Error("Transaction Rejected");
+        }
+      }
+      return receipt?.hash;
+    } catch (error) {
+      await this.setChange({ error: error?.message || String(error), loader: null });
+      throw error;
+    }
+  }
+  async swap() {
+    try {
+      await this.setChange({
+        txHash: void 0,
+        approveTxHash: void 0
+      });
+      const { fromToken, toToken, amount } = this.input;
+      if (!fromToken || !toToken || amount === void 0) throw new Error("Tokens or amount not set");
+      await this.approveIfNeeded();
+      await this.setChange({ loader: 3 /* SWAPPING */ });
+      const trade = this.state.tradeInfo;
+      if (!trade) throw new Error("Trade info missing - calculate quote first");
+      const path = trade.route.path.map((token) => token.address);
+      if (path.length === 0) throw new Error("Trade path missing");
+      const computed = this.state.computed;
+      if (!computed) throw new Error("Computed amounts missing");
+      const transaction = await this.swapService.swapTokens(
+        fromToken,
+        toToken,
+        computed.maxAmountInRaw || computed.amountInRaw,
+        computed.minAmountOutRaw || computed.amountOutRaw,
+        path,
+        this.input.isOutputAmount == true,
+        this.settings.swapDeadline
+      );
+      await this.setChange({ txHash: transaction.hash });
+      const receipt = await transaction.wait();
+      if (!receipt) {
+        throw new Error("Receipt not found, Please try again");
+      }
+      if (receipt.status != 1) {
+        throw new Error("Transaction Rejected");
+      }
+      await this.setChange({
+        loader: null
+      });
+      return receipt.hash;
+    } catch (error) {
+      await this.setChange({ error: error?.message || String(error), loader: null });
+      throw error;
+    }
+  }
+  async getPartnerFee() {
+    return Number(await this.swapService.loadPartnerFee()) / 100;
+  }
+  async getTokensFromGraph(limit = 100, search) {
+    if (!this.swapService) {
+      throw new Error("Swap Service not exists");
+    }
+    return await this.swapService.getTokensFromGraph(limit, search);
+  }
+  get currentNetworkConfig() {
+    return this.options.networkConfig;
+  }
+};
+
+// src/config/networks.ts
+var import_ethers3 = require("ethers");
+var NETWORKS = {
+  "kasplex-testnet": {
+    name: "Kasplex Test",
+    chainId: 167012,
+    rpcUrl: "https://rpc.kasplextest.xyz",
+    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: import_ethers3.ethers.ZeroAddress,
+      decimals: 18,
+      name: "Kasplex Kaspa",
+      symbol: "KAS"
+    }
+  }
+  // Add more networks as needed
+};
+
+// src/index.ts
+function createKaspaComSwapController(options) {
+  let resolvedOptions;
+  if ("networkConfig" in options && typeof options.networkConfig === "string") {
+    const networkConfig = NETWORKS[options.networkConfig];
+    if (!networkConfig) throw new Error(`Unknown network key: ${options.networkConfig}`);
+    resolvedOptions = { ...options, networkConfig };
+  } else {
+    resolvedOptions = options;
+  }
+  return new SwapSdkController(resolvedOptions);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_SWAP_SETTINGS,
+  LoaderStatuses,
+  NETWORKS,
+  SwapSdkController,
+  SwapService,
+  WalletService,
+  createKaspaComSwapController
+});
+//# sourceMappingURL=index.cjs.map