@tokemak/queries 0.0.9 → 0.0.11

package/dist/index.cjs

@@ -1,4 +1,16 @@
-"use strict";
+'use strict';
+
+var chains = require('viem/chains');
+var constants = require('@tokemak/constants');
+var tokenlist = require('@tokemak/tokenlist');
+var viem = require('viem');
+var utils = require('@tokemak/utils');
+var graphCli = require('@tokemak/graph-cli');
+var config = require('@tokemak/config');
+var core = require('@wagmi/core');
+var abis = require('@tokemak/abis');
+var autopilotSwapRouteCalc = require('@tokemak/autopilot-swap-route-calc');
+
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -8,33 +20,1905 @@ var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/base64-js/index.js
+var require_base64_js = __commonJS({
+  "../../node_modules/base64-js/index.js"(exports) {
+    exports.byteLength = byteLength;
+    exports.toByteArray = toByteArray;
+    exports.fromByteArray = fromByteArray;
+    var lookup = [];
+    var revLookup = [];
+    var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
+    var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    for (i = 0, len = code.length; i < len; ++i) {
+      lookup[i] = code[i];
+      revLookup[code.charCodeAt(i)] = i;
+    }
+    var i;
+    var len;
+    revLookup["-".charCodeAt(0)] = 62;
+    revLookup["_".charCodeAt(0)] = 63;
+    function getLens(b64) {
+      var len2 = b64.length;
+      if (len2 % 4 > 0) {
+        throw new Error("Invalid string. Length must be a multiple of 4");
+      }
+      var validLen = b64.indexOf("=");
+      if (validLen === -1)
+        validLen = len2;
+      var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
+      return [validLen, placeHoldersLen];
+    }
+    function byteLength(b64) {
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    function _byteLength(b64, validLen, placeHoldersLen) {
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    function toByteArray(b64) {
+      var tmp;
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
+      var curByte = 0;
+      var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
+      var i2;
+      for (i2 = 0; i2 < len2; i2 += 4) {
+        tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
+        arr[curByte++] = tmp >> 16 & 255;
+        arr[curByte++] = tmp >> 8 & 255;
+        arr[curByte++] = tmp & 255;
+      }
+      if (placeHoldersLen === 2) {
+        tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
+        arr[curByte++] = tmp & 255;
+      }
+      if (placeHoldersLen === 1) {
+        tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
+        arr[curByte++] = tmp >> 8 & 255;
+        arr[curByte++] = tmp & 255;
+      }
+      return arr;
+    }
+    function tripletToBase64(num) {
+      return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+    }
+    function encodeChunk(uint8, start, end) {
+      var tmp;
+      var output = [];
+      for (var i2 = start; i2 < end; i2 += 3) {
+        tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
+        output.push(tripletToBase64(tmp));
+      }
+      return output.join("");
+    }
+    function fromByteArray(uint8) {
+      var tmp;
+      var len2 = uint8.length;
+      var extraBytes = len2 % 3;
+      var parts = [];
+      var maxChunkLength = 16383;
+      for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
+        parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
+      }
+      if (extraBytes === 1) {
+        tmp = uint8[len2 - 1];
+        parts.push(
+          lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "=="
+        );
+      } else if (extraBytes === 2) {
+        tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
+        parts.push(
+          lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
+        );
+      }
+      return parts.join("");
+    }
+  }
+});
+
+// ../../node_modules/ieee754/index.js
+var require_ieee754 = __commonJS({
+  "../../node_modules/ieee754/index.js"(exports) {
+    exports.read = function(buffer, offset, isLE, mLen, nBytes) {
+      var e, m;
+      var eLen = nBytes * 8 - mLen - 1;
+      var eMax = (1 << eLen) - 1;
+      var eBias = eMax >> 1;
+      var nBits = -7;
+      var i = isLE ? nBytes - 1 : 0;
+      var d = isLE ? -1 : 1;
+      var s = buffer[offset + i];
+      i += d;
+      e = s & (1 << -nBits) - 1;
+      s >>= -nBits;
+      nBits += eLen;
+      for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {
+      }
+      m = e & (1 << -nBits) - 1;
+      e >>= -nBits;
+      nBits += mLen;
+      for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
+      }
+      if (e === 0) {
+        e = 1 - eBias;
+      } else if (e === eMax) {
+        return m ? NaN : (s ? -1 : 1) * Infinity;
+      } else {
+        m = m + Math.pow(2, mLen);
+        e = e - eBias;
+      }
+      return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+    };
+    exports.write = function(buffer, value, offset, isLE, mLen, nBytes) {
+      var e, m, c;
+      var eLen = nBytes * 8 - mLen - 1;
+      var eMax = (1 << eLen) - 1;
+      var eBias = eMax >> 1;
+      var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
+      var i = isLE ? 0 : nBytes - 1;
+      var d = isLE ? 1 : -1;
+      var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+      value = Math.abs(value);
+      if (isNaN(value) || value === Infinity) {
+        m = isNaN(value) ? 1 : 0;
+        e = eMax;
+      } else {
+        e = Math.floor(Math.log(value) / Math.LN2);
+        if (value * (c = Math.pow(2, -e)) < 1) {
+          e--;
+          c *= 2;
+        }
+        if (e + eBias >= 1) {
+          value += rt / c;
+        } else {
+          value += rt * Math.pow(2, 1 - eBias);
+        }
+        if (value * c >= 2) {
+          e++;
+          c /= 2;
+        }
+        if (e + eBias >= eMax) {
+          m = 0;
+          e = eMax;
+        } else if (e + eBias >= 1) {
+          m = (value * c - 1) * Math.pow(2, mLen);
+          e = e + eBias;
+        } else {
+          m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+          e = 0;
+        }
+      }
+      for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
+      }
+      e = e << mLen | m;
+      eLen += mLen;
+      for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+      }
+      buffer[offset + i - d] |= s * 128;
+    };
+  }
+});
+
+// ../../node_modules/buffer/index.js
+var require_buffer = __commonJS({
+  "../../node_modules/buffer/index.js"(exports) {
+    var base64 = require_base64_js();
+    var ieee754 = require_ieee754();
+    var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+    exports.Buffer = Buffer2;
+    exports.SlowBuffer = SlowBuffer;
+    exports.INSPECT_MAX_BYTES = 50;
+    var K_MAX_LENGTH = 2147483647;
+    exports.kMaxLength = K_MAX_LENGTH;
+    Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
+    if (!Buffer2.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
+      console.error(
+        "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
+      );
+    }
+    function typedArraySupport() {
+      try {
+        const arr = new Uint8Array(1);
+        const proto = { foo: function() {
+          return 42;
+        } };
+        Object.setPrototypeOf(proto, Uint8Array.prototype);
+        Object.setPrototypeOf(arr, proto);
+        return arr.foo() === 42;
+      } catch (e) {
+        return false;
+      }
+    }
+    Object.defineProperty(Buffer2.prototype, "parent", {
+      enumerable: true,
+      get: function() {
+        if (!Buffer2.isBuffer(this))
+          return void 0;
+        return this.buffer;
+      }
+    });
+    Object.defineProperty(Buffer2.prototype, "offset", {
+      enumerable: true,
+      get: function() {
+        if (!Buffer2.isBuffer(this))
+          return void 0;
+        return this.byteOffset;
+      }
+    });
+    function createBuffer(length) {
+      if (length > K_MAX_LENGTH) {
+        throw new RangeError('The value "' + length + '" is invalid for option "size"');
+      }
+      const buf = new Uint8Array(length);
+      Object.setPrototypeOf(buf, Buffer2.prototype);
+      return buf;
+    }
+    function Buffer2(arg, encodingOrOffset, length) {
+      if (typeof arg === "number") {
+        if (typeof encodingOrOffset === "string") {
+          throw new TypeError(
+            'The "string" argument must be of type string. Received type number'
+          );
+        }
+        return allocUnsafe(arg);
+      }
+      return from(arg, encodingOrOffset, length);
+    }
+    Buffer2.poolSize = 8192;
+    function from(value, encodingOrOffset, length) {
+      if (typeof value === "string") {
+        return fromString(value, encodingOrOffset);
+      }
+      if (ArrayBuffer.isView(value)) {
+        return fromArrayView(value);
+      }
+      if (value == null) {
+        throw new TypeError(
+          "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+        );
+      }
+      if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
+        return fromArrayBuffer(value, encodingOrOffset, length);
+      }
+      if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
+        return fromArrayBuffer(value, encodingOrOffset, length);
+      }
+      if (typeof value === "number") {
+        throw new TypeError(
+          'The "value" argument must not be of type number. Received type number'
+        );
+      }
+      const valueOf = value.valueOf && value.valueOf();
+      if (valueOf != null && valueOf !== value) {
+        return Buffer2.from(valueOf, encodingOrOffset, length);
+      }
+      const b = fromObject(value);
+      if (b)
+        return b;
+      if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
+        return Buffer2.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
+      }
+      throw new TypeError(
+        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+      );
+    }
+    Buffer2.from = function(value, encodingOrOffset, length) {
+      return from(value, encodingOrOffset, length);
+    };
+    Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
+    Object.setPrototypeOf(Buffer2, Uint8Array);
+    function assertSize(size) {
+      if (typeof size !== "number") {
+        throw new TypeError('"size" argument must be of type number');
+      } else if (size < 0) {
+        throw new RangeError('The value "' + size + '" is invalid for option "size"');
+      }
+    }
+    function alloc(size, fill, encoding) {
+      assertSize(size);
+      if (size <= 0) {
+        return createBuffer(size);
+      }
+      if (fill !== void 0) {
+        return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+      }
+      return createBuffer(size);
+    }
+    Buffer2.alloc = function(size, fill, encoding) {
+      return alloc(size, fill, encoding);
+    };
+    function allocUnsafe(size) {
+      assertSize(size);
+      return createBuffer(size < 0 ? 0 : checked(size) | 0);
+    }
+    Buffer2.allocUnsafe = function(size) {
+      return allocUnsafe(size);
+    };
+    Buffer2.allocUnsafeSlow = function(size) {
+      return allocUnsafe(size);
+    };
+    function fromString(string, encoding) {
+      if (typeof encoding !== "string" || encoding === "") {
+        encoding = "utf8";
+      }
+      if (!Buffer2.isEncoding(encoding)) {
+        throw new TypeError("Unknown encoding: " + encoding);
+      }
+      const length = byteLength(string, encoding) | 0;
+      let buf = createBuffer(length);
+      const actual = buf.write(string, encoding);
+      if (actual !== length) {
+        buf = buf.slice(0, actual);
+      }
+      return buf;
+    }
+    function fromArrayLike(array) {
+      const length = array.length < 0 ? 0 : checked(array.length) | 0;
+      const buf = createBuffer(length);
+      for (let i = 0; i < length; i += 1) {
+        buf[i] = array[i] & 255;
+      }
+      return buf;
+    }
+    function fromArrayView(arrayView) {
+      if (isInstance(arrayView, Uint8Array)) {
+        const copy = new Uint8Array(arrayView);
+        return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+      }
+      return fromArrayLike(arrayView);
+    }
+    function fromArrayBuffer(array, byteOffset, length) {
+      if (byteOffset < 0 || array.byteLength < byteOffset) {
+        throw new RangeError('"offset" is outside of buffer bounds');
+      }
+      if (array.byteLength < byteOffset + (length || 0)) {
+        throw new RangeError('"length" is outside of buffer bounds');
+      }
+      let buf;
+      if (byteOffset === void 0 && length === void 0) {
+        buf = new Uint8Array(array);
+      } else if (length === void 0) {
+        buf = new Uint8Array(array, byteOffset);
+      } else {
+        buf = new Uint8Array(array, byteOffset, length);
+      }
+      Object.setPrototypeOf(buf, Buffer2.prototype);
+      return buf;
+    }
+    function fromObject(obj) {
+      if (Buffer2.isBuffer(obj)) {
+        const len = checked(obj.length) | 0;
+        const buf = createBuffer(len);
+        if (buf.length === 0) {
+          return buf;
+        }
+        obj.copy(buf, 0, 0, len);
+        return buf;
+      }
+      if (obj.length !== void 0) {
+        if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
+          return createBuffer(0);
+        }
+        return fromArrayLike(obj);
+      }
+      if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+        return fromArrayLike(obj.data);
+      }
+    }
+    function checked(length) {
+      if (length >= K_MAX_LENGTH) {
+        throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
+      }
+      return length | 0;
+    }
+    function SlowBuffer(length) {
+      if (+length != length) {
+        length = 0;
+      }
+      return Buffer2.alloc(+length);
+    }
+    Buffer2.isBuffer = function isBuffer(b) {
+      return b != null && b._isBuffer === true && b !== Buffer2.prototype;
+    };
+    Buffer2.compare = function compare(a, b) {
+      if (isInstance(a, Uint8Array))
+        a = Buffer2.from(a, a.offset, a.byteLength);
+      if (isInstance(b, Uint8Array))
+        b = Buffer2.from(b, b.offset, b.byteLength);
+      if (!Buffer2.isBuffer(a) || !Buffer2.isBuffer(b)) {
+        throw new TypeError(
+          'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+        );
+      }
+      if (a === b)
+        return 0;
+      let x = a.length;
+      let y = b.length;
+      for (let i = 0, len = Math.min(x, y); i < len; ++i) {
+        if (a[i] !== b[i]) {
+          x = a[i];
+          y = b[i];
+          break;
+        }
+      }
+      if (x < y)
+        return -1;
+      if (y < x)
+        return 1;
+      return 0;
+    };
+    Buffer2.isEncoding = function isEncoding(encoding) {
+      switch (String(encoding).toLowerCase()) {
+        case "hex":
+        case "utf8":
+        case "utf-8":
+        case "ascii":
+        case "latin1":
+        case "binary":
+        case "base64":
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return true;
+        default:
+          return false;
+      }
+    };
+    Buffer2.concat = function concat(list, length) {
+      if (!Array.isArray(list)) {
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      }
+      if (list.length === 0) {
+        return Buffer2.alloc(0);
+      }
+      let i;
+      if (length === void 0) {
+        length = 0;
+        for (i = 0; i < list.length; ++i) {
+          length += list[i].length;
+        }
+      }
+      const buffer = Buffer2.allocUnsafe(length);
+      let pos = 0;
+      for (i = 0; i < list.length; ++i) {
+        let buf = list[i];
+        if (isInstance(buf, Uint8Array)) {
+          if (pos + buf.length > buffer.length) {
+            if (!Buffer2.isBuffer(buf))
+              buf = Buffer2.from(buf);
+            buf.copy(buffer, pos);
+          } else {
+            Uint8Array.prototype.set.call(
+              buffer,
+              buf,
+              pos
+            );
+          }
+        } else if (!Buffer2.isBuffer(buf)) {
+          throw new TypeError('"list" argument must be an Array of Buffers');
+        } else {
+          buf.copy(buffer, pos);
+        }
+        pos += buf.length;
+      }
+      return buffer;
+    };
+    function byteLength(string, encoding) {
+      if (Buffer2.isBuffer(string)) {
+        return string.length;
+      }
+      if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+        return string.byteLength;
+      }
+      if (typeof string !== "string") {
+        throw new TypeError(
+          'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
+        );
+      }
+      const len = string.length;
+      const mustMatch = arguments.length > 2 && arguments[2] === true;
+      if (!mustMatch && len === 0)
+        return 0;
+      let loweredCase = false;
+      for (; ; ) {
+        switch (encoding) {
+          case "ascii":
+          case "latin1":
+          case "binary":
+            return len;
+          case "utf8":
+          case "utf-8":
+            return utf8ToBytes(string).length;
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return len * 2;
+          case "hex":
+            return len >>> 1;
+          case "base64":
+            return base64ToBytes(string).length;
+          default:
+            if (loweredCase) {
+              return mustMatch ? -1 : utf8ToBytes(string).length;
+            }
+            encoding = ("" + encoding).toLowerCase();
+            loweredCase = true;
+        }
+      }
+    }
+    Buffer2.byteLength = byteLength;
+    function slowToString(encoding, start, end) {
+      let loweredCase = false;
+      if (start === void 0 || start < 0) {
+        start = 0;
+      }
+      if (start > this.length) {
+        return "";
+      }
+      if (end === void 0 || end > this.length) {
+        end = this.length;
+      }
+      if (end <= 0) {
+        return "";
+      }
+      end >>>= 0;
+      start >>>= 0;
+      if (end <= start) {
+        return "";
+      }
+      if (!encoding)
+        encoding = "utf8";
+      while (true) {
+        switch (encoding) {
+          case "hex":
+            return hexSlice(this, start, end);
+          case "utf8":
+          case "utf-8":
+            return utf8Slice(this, start, end);
+          case "ascii":
+            return asciiSlice(this, start, end);
+          case "latin1":
+          case "binary":
+            return latin1Slice(this, start, end);
+          case "base64":
+            return base64Slice(this, start, end);
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return utf16leSlice(this, start, end);
+          default:
+            if (loweredCase)
+              throw new TypeError("Unknown encoding: " + encoding);
+            encoding = (encoding + "").toLowerCase();
+            loweredCase = true;
+        }
+      }
+    }
+    Buffer2.prototype._isBuffer = true;
+    function swap(b, n, m) {
+      const i = b[n];
+      b[n] = b[m];
+      b[m] = i;
+    }
+    Buffer2.prototype.swap16 = function swap16() {
+      const len = this.length;
+      if (len % 2 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 16-bits");
+      }
+      for (let i = 0; i < len; i += 2) {
+        swap(this, i, i + 1);
+      }
+      return this;
+    };
+    Buffer2.prototype.swap32 = function swap32() {
+      const len = this.length;
+      if (len % 4 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 32-bits");
+      }
+      for (let i = 0; i < len; i += 4) {
+        swap(this, i, i + 3);
+        swap(this, i + 1, i + 2);
+      }
+      return this;
+    };
+    Buffer2.prototype.swap64 = function swap64() {
+      const len = this.length;
+      if (len % 8 !== 0) {
+        throw new RangeError("Buffer size must be a multiple of 64-bits");
+      }
+      for (let i = 0; i < len; i += 8) {
+        swap(this, i, i + 7);
+        swap(this, i + 1, i + 6);
+        swap(this, i + 2, i + 5);
+        swap(this, i + 3, i + 4);
+      }
+      return this;
+    };
+    Buffer2.prototype.toString = function toString() {
+      const length = this.length;
+      if (length === 0)
+        return "";
+      if (arguments.length === 0)
+        return utf8Slice(this, 0, length);
+      return slowToString.apply(this, arguments);
+    };
+    Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
+    Buffer2.prototype.equals = function equals(b) {
+      if (!Buffer2.isBuffer(b))
+        throw new TypeError("Argument must be a Buffer");
+      if (this === b)
+        return true;
+      return Buffer2.compare(this, b) === 0;
+    };
+    Buffer2.prototype.inspect = function inspect() {
+      let str = "";
+      const max = exports.INSPECT_MAX_BYTES;
+      str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
+      if (this.length > max)
+        str += " ... ";
+      return "<Buffer " + str + ">";
+    };
+    if (customInspectSymbol) {
+      Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
+    }
+    Buffer2.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+      if (isInstance(target, Uint8Array)) {
+        target = Buffer2.from(target, target.offset, target.byteLength);
+      }
+      if (!Buffer2.isBuffer(target)) {
+        throw new TypeError(
+          'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target
+        );
+      }
+      if (start === void 0) {
+        start = 0;
+      }
+      if (end === void 0) {
+        end = target ? target.length : 0;
+      }
+      if (thisStart === void 0) {
+        thisStart = 0;
+      }
+      if (thisEnd === void 0) {
+        thisEnd = this.length;
+      }
+      if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+        throw new RangeError("out of range index");
+      }
+      if (thisStart >= thisEnd && start >= end) {
+        return 0;
+      }
+      if (thisStart >= thisEnd) {
+        return -1;
+      }
+      if (start >= end) {
+        return 1;
+      }
+      start >>>= 0;
+      end >>>= 0;
+      thisStart >>>= 0;
+      thisEnd >>>= 0;
+      if (this === target)
+        return 0;
+      let x = thisEnd - thisStart;
+      let y = end - start;
+      const len = Math.min(x, y);
+      const thisCopy = this.slice(thisStart, thisEnd);
+      const targetCopy = target.slice(start, end);
+      for (let i = 0; i < len; ++i) {
+        if (thisCopy[i] !== targetCopy[i]) {
+          x = thisCopy[i];
+          y = targetCopy[i];
+          break;
+        }
+      }
+      if (x < y)
+        return -1;
+      if (y < x)
+        return 1;
+      return 0;
+    };
+    function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+      if (buffer.length === 0)
+        return -1;
+      if (typeof byteOffset === "string") {
+        encoding = byteOffset;
+        byteOffset = 0;
+      } else if (byteOffset > 2147483647) {
+        byteOffset = 2147483647;
+      } else if (byteOffset < -2147483648) {
+        byteOffset = -2147483648;
+      }
+      byteOffset = +byteOffset;
+      if (numberIsNaN(byteOffset)) {
+        byteOffset = dir ? 0 : buffer.length - 1;
+      }
+      if (byteOffset < 0)
+        byteOffset = buffer.length + byteOffset;
+      if (byteOffset >= buffer.length) {
+        if (dir)
+          return -1;
+        else
+          byteOffset = buffer.length - 1;
+      } else if (byteOffset < 0) {
+        if (dir)
+          byteOffset = 0;
+        else
+          return -1;
+      }
+      if (typeof val === "string") {
+        val = Buffer2.from(val, encoding);
+      }
+      if (Buffer2.isBuffer(val)) {
+        if (val.length === 0) {
+          return -1;
+        }
+        return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+      } else if (typeof val === "number") {
+        val = val & 255;
+        if (typeof Uint8Array.prototype.indexOf === "function") {
+          if (dir) {
+            return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+          } else {
+            return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+          }
+        }
+        return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+      }
+      throw new TypeError("val must be string, number or Buffer");
+    }
+    function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+      let indexSize = 1;
+      let arrLength = arr.length;
+      let valLength = val.length;
+      if (encoding !== void 0) {
+        encoding = String(encoding).toLowerCase();
+        if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
+          if (arr.length < 2 || val.length < 2) {
+            return -1;
+          }
+          indexSize = 2;
+          arrLength /= 2;
+          valLength /= 2;
+          byteOffset /= 2;
+        }
+      }
+      function read(buf, i2) {
+        if (indexSize === 1) {
+          return buf[i2];
+        } else {
+          return buf.readUInt16BE(i2 * indexSize);
+        }
+      }
+      let i;
+      if (dir) {
+        let foundIndex = -1;
+        for (i = byteOffset; i < arrLength; i++) {
+          if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
+            if (foundIndex === -1)
+              foundIndex = i;
+            if (i - foundIndex + 1 === valLength)
+              return foundIndex * indexSize;
+          } else {
+            if (foundIndex !== -1)
+              i -= i - foundIndex;
+            foundIndex = -1;
+          }
+        }
+      } else {
+        if (byteOffset + valLength > arrLength)
+          byteOffset = arrLength - valLength;
+        for (i = byteOffset; i >= 0; i--) {
+          let found = true;
+          for (let j = 0; j < valLength; j++) {
+            if (read(arr, i + j) !== read(val, j)) {
+              found = false;
+              break;
+            }
+          }
+          if (found)
+            return i;
+        }
+      }
+      return -1;
+    }
+    Buffer2.prototype.includes = function includes(val, byteOffset, encoding) {
+      return this.indexOf(val, byteOffset, encoding) !== -1;
+    };
+    Buffer2.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+    };
+    Buffer2.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+    };
+    function hexWrite(buf, string, offset, length) {
+      offset = Number(offset) || 0;
+      const remaining = buf.length - offset;
+      if (!length) {
+        length = remaining;
+      } else {
+        length = Number(length);
+        if (length > remaining) {
+          length = remaining;
+        }
+      }
+      const strLen = string.length;
+      if (length > strLen / 2) {
+        length = strLen / 2;
+      }
+      let i;
+      for (i = 0; i < length; ++i) {
+        const parsed = parseInt(string.substr(i * 2, 2), 16);
+        if (numberIsNaN(parsed))
+          return i;
+        buf[offset + i] = parsed;
+      }
+      return i;
+    }
+    function utf8Write(buf, string, offset, length) {
+      return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+    }
+    function asciiWrite(buf, string, offset, length) {
+      return blitBuffer(asciiToBytes(string), buf, offset, length);
+    }
+    function base64Write(buf, string, offset, length) {
+      return blitBuffer(base64ToBytes(string), buf, offset, length);
+    }
+    function ucs2Write(buf, string, offset, length) {
+      return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
+    }
+    Buffer2.prototype.write = function write(string, offset, length, encoding) {
+      if (offset === void 0) {
+        encoding = "utf8";
+        length = this.length;
+        offset = 0;
+      } else if (length === void 0 && typeof offset === "string") {
+        encoding = offset;
+        length = this.length;
+        offset = 0;
+      } else if (isFinite(offset)) {
+        offset = offset >>> 0;
+        if (isFinite(length)) {
+          length = length >>> 0;
+          if (encoding === void 0)
+            encoding = "utf8";
+        } else {
+          encoding = length;
+          length = void 0;
+        }
+      } else {
+        throw new Error(
+          "Buffer.write(string, encoding, offset[, length]) is no longer supported"
+        );
+      }
+      const remaining = this.length - offset;
+      if (length === void 0 || length > remaining)
+        length = remaining;
+      if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
+        throw new RangeError("Attempt to write outside buffer bounds");
+      }
+      if (!encoding)
+        encoding = "utf8";
+      let loweredCase = false;
+      for (; ; ) {
+        switch (encoding) {
+          case "hex":
+            return hexWrite(this, string, offset, length);
+          case "utf8":
+          case "utf-8":
+            return utf8Write(this, string, offset, length);
+          case "ascii":
+          case "latin1":
+          case "binary":
+            return asciiWrite(this, string, offset, length);
+          case "base64":
+            return base64Write(this, string, offset, length);
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return ucs2Write(this, string, offset, length);
+          default:
+            if (loweredCase)
+              throw new TypeError("Unknown encoding: " + encoding);
+            encoding = ("" + encoding).toLowerCase();
+            loweredCase = true;
+        }
+      }
+    };
+    Buffer2.prototype.toJSON = function toJSON() {
+      return {
+        type: "Buffer",
+        data: Array.prototype.slice.call(this._arr || this, 0)
+      };
+    };
+    function base64Slice(buf, start, end) {
+      if (start === 0 && end === buf.length) {
+        return base64.fromByteArray(buf);
+      } else {
+        return base64.fromByteArray(buf.slice(start, end));
+      }
+    }
+    function utf8Slice(buf, start, end) {
+      end = Math.min(buf.length, end);
+      const res = [];
+      let i = start;
+      while (i < end) {
+        const firstByte = buf[i];
+        let codePoint = null;
+        let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+        if (i + bytesPerSequence <= end) {
+          let secondByte, thirdByte, fourthByte, tempCodePoint;
+          switch (bytesPerSequence) {
+            case 1:
+              if (firstByte < 128) {
+                codePoint = firstByte;
+              }
+              break;
+            case 2:
+              secondByte = buf[i + 1];
+              if ((secondByte & 192) === 128) {
+                tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+                if (tempCodePoint > 127) {
+                  codePoint = tempCodePoint;
+                }
+              }
+              break;
+            case 3:
+              secondByte = buf[i + 1];
+              thirdByte = buf[i + 2];
+              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+                tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+                if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
+                  codePoint = tempCodePoint;
+                }
+              }
+              break;
+            case 4:
+              secondByte = buf[i + 1];
+              thirdByte = buf[i + 2];
+              fourthByte = buf[i + 3];
+              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+                tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+                if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                  codePoint = tempCodePoint;
+                }
+              }
+          }
+        }
+        if (codePoint === null) {
+          codePoint = 65533;
+          bytesPerSequence = 1;
+        } else if (codePoint > 65535) {
+          codePoint -= 65536;
+          res.push(codePoint >>> 10 & 1023 | 55296);
+          codePoint = 56320 | codePoint & 1023;
+        }
+        res.push(codePoint);
+        i += bytesPerSequence;
+      }
+      return decodeCodePointsArray(res);
+    }
+    var MAX_ARGUMENTS_LENGTH = 4096;
+    function decodeCodePointsArray(codePoints) {
+      const len = codePoints.length;
+      if (len <= MAX_ARGUMENTS_LENGTH) {
+        return String.fromCharCode.apply(String, codePoints);
+      }
+      let res = "";
+      let i = 0;
+      while (i < len) {
+        res += String.fromCharCode.apply(
+          String,
+          codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+        );
+      }
+      return res;
+    }
+    function asciiSlice(buf, start, end) {
+      let ret = "";
+      end = Math.min(buf.length, end);
+      for (let i = start; i < end; ++i) {
+        ret += String.fromCharCode(buf[i] & 127);
+      }
+      return ret;
+    }
+    function latin1Slice(buf, start, end) {
+      let ret = "";
+      end = Math.min(buf.length, end);
+      for (let i = start; i < end; ++i) {
+        ret += String.fromCharCode(buf[i]);
+      }
+      return ret;
+    }
+    function hexSlice(buf, start, end) {
+      const len = buf.length;
+      if (!start || start < 0)
+        start = 0;
+      if (!end || end < 0 || end > len)
+        end = len;
+      let out = "";
+      for (let i = start; i < end; ++i) {
+        out += hexSliceLookupTable[buf[i]];
+      }
+      return out;
+    }
+    function utf16leSlice(buf, start, end) {
+      const bytes = buf.slice(start, end);
+      let res = "";
+      for (let i = 0; i < bytes.length - 1; i += 2) {
+        res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
+      }
+      return res;
+    }
+    Buffer2.prototype.slice = function slice(start, end) {
+      const len = this.length;
+      start = ~~start;
+      end = end === void 0 ? len : ~~end;
+      if (start < 0) {
+        start += len;
+        if (start < 0)
+          start = 0;
+      } else if (start > len) {
+        start = len;
+      }
+      if (end < 0) {
+        end += len;
+        if (end < 0)
+          end = 0;
+      } else if (end > len) {
+        end = len;
+      }
+      if (end < start)
+        end = start;
+      const newBuf = this.subarray(start, end);
+      Object.setPrototypeOf(newBuf, Buffer2.prototype);
+      return newBuf;
+    };
+    function checkOffset(offset, ext, length) {
+      if (offset % 1 !== 0 || offset < 0)
+        throw new RangeError("offset is not uint");
+      if (offset + ext > length)
+        throw new RangeError("Trying to access beyond buffer length");
+    }
+    Buffer2.prototype.readUintLE = Buffer2.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert)
+        checkOffset(offset, byteLength2, this.length);
+      let val = this[offset];
+      let mul = 1;
+      let i = 0;
+      while (++i < byteLength2 && (mul *= 256)) {
+        val += this[offset + i] * mul;
+      }
+      return val;
+    };
+    Buffer2.prototype.readUintBE = Buffer2.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        checkOffset(offset, byteLength2, this.length);
+      }
+      let val = this[offset + --byteLength2];
+      let mul = 1;
+      while (byteLength2 > 0 && (mul *= 256)) {
+        val += this[offset + --byteLength2] * mul;
+      }
+      return val;
+    };
+    Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 1, this.length);
+      return this[offset];
+    };
+    Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 2, this.length);
+      return this[offset] | this[offset + 1] << 8;
+    };
+    Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 2, this.length);
+      return this[offset] << 8 | this[offset + 1];
+    };
+    Buffer2.prototype.readUint32LE = Buffer2.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 4, this.length);
+      return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
+    };
+    Buffer2.prototype.readUint32BE = Buffer2.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 4, this.length);
+      return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+    };
+    Buffer2.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
+      const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
+      return BigInt(lo) + (BigInt(hi) << BigInt(32));
+    });
+    Buffer2.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+      const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
+      return (BigInt(hi) << BigInt(32)) + BigInt(lo);
+    });
+    Buffer2.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert)
+        checkOffset(offset, byteLength2, this.length);
+      let val = this[offset];
+      let mul = 1;
+      let i = 0;
+      while (++i < byteLength2 && (mul *= 256)) {
+        val += this[offset + i] * mul;
+      }
+      mul *= 128;
+      if (val >= mul)
+        val -= Math.pow(2, 8 * byteLength2);
+      return val;
+    };
+    Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert)
+        checkOffset(offset, byteLength2, this.length);
+      let i = byteLength2;
+      let mul = 1;
+      let val = this[offset + --i];
+      while (i > 0 && (mul *= 256)) {
+        val += this[offset + --i] * mul;
+      }
+      mul *= 128;
+      if (val >= mul)
+        val -= Math.pow(2, 8 * byteLength2);
+      return val;
+    };
+    Buffer2.prototype.readInt8 = function readInt8(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 1, this.length);
+      if (!(this[offset] & 128))
+        return this[offset];
+      return (255 - this[offset] + 1) * -1;
+    };
+    Buffer2.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 2, this.length);
+      const val = this[offset] | this[offset + 1] << 8;
+      return val & 32768 ? val | 4294901760 : val;
+    };
+    Buffer2.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 2, this.length);
+      const val = this[offset + 1] | this[offset] << 8;
+      return val & 32768 ? val | 4294901760 : val;
+    };
+    Buffer2.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 4, this.length);
+      return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+    };
+    Buffer2.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 4, this.length);
+      return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+    };
+    Buffer2.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
+      return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
+    });
+    Buffer2.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const val = (first << 24) + // Overflow
+      this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+      return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
+    });
+    Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, true, 23, 4);
+    };
+    Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, false, 23, 4);
+    };
+    Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, true, 52, 8);
+    };
+    Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, false, 52, 8);
+    };
+    function checkInt(buf, value, offset, ext, max, min) {
+      if (!Buffer2.isBuffer(buf))
+        throw new TypeError('"buffer" argument must be a Buffer instance');
+      if (value > max || value < min)
+        throw new RangeError('"value" argument is out of bounds');
+      if (offset + ext > buf.length)
+        throw new RangeError("Index out of range");
+    }
+    Buffer2.prototype.writeUintLE = Buffer2.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        checkInt(this, value, offset, byteLength2, maxBytes, 0);
+      }
+      let mul = 1;
+      let i = 0;
+      this[offset] = value & 255;
+      while (++i < byteLength2 && (mul *= 256)) {
+        this[offset + i] = value / mul & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer2.prototype.writeUintBE = Buffer2.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        checkInt(this, value, offset, byteLength2, maxBytes, 0);
+      }
+      let i = byteLength2 - 1;
+      let mul = 1;
+      this[offset + i] = value & 255;
+      while (--i >= 0 && (mul *= 256)) {
+        this[offset + i] = value / mul & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer2.prototype.writeUint8 = Buffer2.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 1, 255, 0);
+      this[offset] = value & 255;
+      return offset + 1;
+    };
+    Buffer2.prototype.writeUint16LE = Buffer2.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 2, 65535, 0);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      return offset + 2;
+    };
+    Buffer2.prototype.writeUint16BE = Buffer2.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 2, 65535, 0);
+      this[offset] = value >>> 8;
+      this[offset + 1] = value & 255;
+      return offset + 2;
+    };
+    Buffer2.prototype.writeUint32LE = Buffer2.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 4, 4294967295, 0);
+      this[offset + 3] = value >>> 24;
+      this[offset + 2] = value >>> 16;
+      this[offset + 1] = value >>> 8;
+      this[offset] = value & 255;
+      return offset + 4;
+    };
+    Buffer2.prototype.writeUint32BE = Buffer2.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 4, 4294967295, 0);
+      this[offset] = value >>> 24;
+      this[offset + 1] = value >>> 16;
+      this[offset + 2] = value >>> 8;
+      this[offset + 3] = value & 255;
+      return offset + 4;
+    };
+    function wrtBigUInt64LE(buf, value, offset, min, max) {
+      checkIntBI(value, min, max, buf, offset, 7);
+      let lo = Number(value & BigInt(4294967295));
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      return offset;
+    }
+    function wrtBigUInt64BE(buf, value, offset, min, max) {
+      checkIntBI(value, min, max, buf, offset, 7);
+      let lo = Number(value & BigInt(4294967295));
+      buf[offset + 7] = lo;
+      lo = lo >> 8;
+      buf[offset + 6] = lo;
+      lo = lo >> 8;
+      buf[offset + 5] = lo;
+      lo = lo >> 8;
+      buf[offset + 4] = lo;
+      let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+      buf[offset + 3] = hi;
+      hi = hi >> 8;
+      buf[offset + 2] = hi;
+      hi = hi >> 8;
+      buf[offset + 1] = hi;
+      hi = hi >> 8;
+      buf[offset] = hi;
+      return offset + 8;
+    }
+    Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
+      return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+    });
+    Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
+      return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+    });
+    Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        const limit = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+      }
+      let i = 0;
+      let mul = 1;
+      let sub = 0;
+      this[offset] = value & 255;
+      while (++i < byteLength2 && (mul *= 256)) {
+        if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+          sub = 1;
+        }
+        this[offset + i] = (value / mul >> 0) - sub & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer2.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        const limit = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
+      }
+      let i = byteLength2 - 1;
+      let mul = 1;
+      let sub = 0;
+      this[offset + i] = value & 255;
+      while (--i >= 0 && (mul *= 256)) {
+        if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+          sub = 1;
+        }
+        this[offset + i] = (value / mul >> 0) - sub & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer2.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 1, 127, -128);
+      if (value < 0)
+        value = 255 + value + 1;
+      this[offset] = value & 255;
+      return offset + 1;
+    };
+    Buffer2.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 2, 32767, -32768);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      return offset + 2;
+    };
+    Buffer2.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 2, 32767, -32768);
+      this[offset] = value >>> 8;
+      this[offset + 1] = value & 255;
+      return offset + 2;
+    };
+    Buffer2.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 4, 2147483647, -2147483648);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      this[offset + 2] = value >>> 16;
+      this[offset + 3] = value >>> 24;
+      return offset + 4;
+    };
+    Buffer2.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert)
+        checkInt(this, value, offset, 4, 2147483647, -2147483648);
+      if (value < 0)
+        value = 4294967295 + value + 1;
+      this[offset] = value >>> 24;
+      this[offset + 1] = value >>> 16;
+      this[offset + 2] = value >>> 8;
+      this[offset + 3] = value & 255;
+      return offset + 4;
+    };
+    Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
+      return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+    });
+    Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
+      return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+    });
+    function checkIEEE754(buf, value, offset, ext, max, min) {
+      if (offset + ext > buf.length)
+        throw new RangeError("Index out of range");
+      if (offset < 0)
+        throw new RangeError("Index out of range");
+    }
+    function writeFloat(buf, value, offset, littleEndian, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(buf, value, offset, 4);
+      }
+      ieee754.write(buf, value, offset, littleEndian, 23, 4);
+      return offset + 4;
+    }
+    Buffer2.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+      return writeFloat(this, value, offset, true, noAssert);
+    };
+    Buffer2.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+      return writeFloat(this, value, offset, false, noAssert);
+    };
+    function writeDouble(buf, value, offset, littleEndian, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(buf, value, offset, 8);
+      }
+      ieee754.write(buf, value, offset, littleEndian, 52, 8);
+      return offset + 8;
+    }
+    Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, true, noAssert);
+    };
+    Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, false, noAssert);
+    };
+    Buffer2.prototype.copy = function copy(target, targetStart, start, end) {
+      if (!Buffer2.isBuffer(target))
+        throw new TypeError("argument should be a Buffer");
+      if (!start)
+        start = 0;
+      if (!end && end !== 0)
+        end = this.length;
+      if (targetStart >= target.length)
+        targetStart = target.length;
+      if (!targetStart)
+        targetStart = 0;
+      if (end > 0 && end < start)
+        end = start;
+      if (end === start)
+        return 0;
+      if (target.length === 0 || this.length === 0)
+        return 0;
+      if (targetStart < 0) {
+        throw new RangeError("targetStart out of bounds");
+      }
+      if (start < 0 || start >= this.length)
+        throw new RangeError("Index out of range");
+      if (end < 0)
+        throw new RangeError("sourceEnd out of bounds");
+      if (end > this.length)
+        end = this.length;
+      if (target.length - targetStart < end - start) {
+        end = target.length - targetStart + start;
+      }
+      const len = end - start;
+      if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
+        this.copyWithin(targetStart, start, end);
+      } else {
+        Uint8Array.prototype.set.call(
+          target,
+          this.subarray(start, end),
+          targetStart
+        );
+      }
+      return len;
+    };
+    Buffer2.prototype.fill = function fill(val, start, end, encoding) {
+      if (typeof val === "string") {
+        if (typeof start === "string") {
+          encoding = start;
+          start = 0;
+          end = this.length;
+        } else if (typeof end === "string") {
+          encoding = end;
+          end = this.length;
+        }
+        if (encoding !== void 0 && typeof encoding !== "string") {
+          throw new TypeError("encoding must be a string");
+        }
+        if (typeof encoding === "string" && !Buffer2.isEncoding(encoding)) {
+          throw new TypeError("Unknown encoding: " + encoding);
+        }
+        if (val.length === 1) {
+          const code = val.charCodeAt(0);
+          if (encoding === "utf8" && code < 128 || encoding === "latin1") {
+            val = code;
+          }
+        }
+      } else if (typeof val === "number") {
+        val = val & 255;
+      } else if (typeof val === "boolean") {
+        val = Number(val);
+      }
+      if (start < 0 || this.length < start || this.length < end) {
+        throw new RangeError("Out of range index");
+      }
+      if (end <= start) {
+        return this;
+      }
+      start = start >>> 0;
+      end = end === void 0 ? this.length : end >>> 0;
+      if (!val)
+        val = 0;
+      let i;
+      if (typeof val === "number") {
+        for (i = start; i < end; ++i) {
+          this[i] = val;
+        }
+      } else {
+        const bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
+        const len = bytes.length;
+        if (len === 0) {
+          throw new TypeError('The value "' + val + '" is invalid for argument "value"');
+        }
+        for (i = 0; i < end - start; ++i) {
+          this[i + start] = bytes[i % len];
+        }
+      }
+      return this;
+    };
+    var errors = {};
+    function E(sym, getMessage, Base) {
+      errors[sym] = class NodeError extends Base {
+        constructor() {
+          super();
+          Object.defineProperty(this, "message", {
+            value: getMessage.apply(this, arguments),
+            writable: true,
+            configurable: true
+          });
+          this.name = `${this.name} [${sym}]`;
+          this.stack;
+          delete this.name;
+        }
+        get code() {
+          return sym;
+        }
+        set code(value) {
+          Object.defineProperty(this, "code", {
+            configurable: true,
+            enumerable: true,
+            value,
+            writable: true
+          });
+        }
+        toString() {
+          return `${this.name} [${sym}]: ${this.message}`;
+        }
+      };
+    }
+    E(
+      "ERR_BUFFER_OUT_OF_BOUNDS",
+      function(name) {
+        if (name) {
+          return `${name} is outside of buffer bounds`;
+        }
+        return "Attempt to access memory outside buffer bounds";
+      },
+      RangeError
+    );
+    E(
+      "ERR_INVALID_ARG_TYPE",
+      function(name, actual) {
+        return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
+      },
+      TypeError
+    );
+    E(
+      "ERR_OUT_OF_RANGE",
+      function(str, range, input) {
+        let msg = `The value of "${str}" is out of range.`;
+        let received = input;
+        if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
+          received = addNumericalSeparator(String(input));
+        } else if (typeof input === "bigint") {
+          received = String(input);
+          if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {
+            received = addNumericalSeparator(received);
+          }
+          received += "n";
+        }
+        msg += ` It must be ${range}. Received ${received}`;
+        return msg;
+      },
+      RangeError
+    );
+    function addNumericalSeparator(val) {
+      let res = "";
+      let i = val.length;
+      const start = val[0] === "-" ? 1 : 0;
+      for (; i >= start + 4; i -= 3) {
+        res = `_${val.slice(i - 3, i)}${res}`;
+      }
+      return `${val.slice(0, i)}${res}`;
+    }
+    function checkBounds(buf, offset, byteLength2) {
+      validateNumber(offset, "offset");
+      if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) {
+        boundsError(offset, buf.length - (byteLength2 + 1));
+      }
+    }
+    function checkIntBI(value, min, max, buf, offset, byteLength2) {
+      if (value > max || value < min) {
+        const n = typeof min === "bigint" ? "n" : "";
+        let range;
+        if (byteLength2 > 3) {
+          if (min === 0 || min === BigInt(0)) {
+            range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
+          } else {
+            range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
+          }
+        } else {
+          range = `>= ${min}${n} and <= ${max}${n}`;
+        }
+        throw new errors.ERR_OUT_OF_RANGE("value", range, value);
+      }
+      checkBounds(buf, offset, byteLength2);
+    }
+    function validateNumber(value, name) {
+      if (typeof value !== "number") {
+        throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
+      }
+    }
+    function boundsError(value, length, type) {
+      if (Math.floor(value) !== value) {
+        validateNumber(value, type);
+        throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
+      }
+      if (length < 0) {
+        throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
+      }
+      throw new errors.ERR_OUT_OF_RANGE(
+        type || "offset",
+        `>= ${type ? 1 : 0} and <= ${length}`,
+        value
+      );
+    }
+    var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+    function base64clean(str) {
+      str = str.split("=")[0];
+      str = str.trim().replace(INVALID_BASE64_RE, "");
+      if (str.length < 2)
+        return "";
+      while (str.length % 4 !== 0) {
+        str = str + "=";
+      }
+      return str;
+    }
+    function utf8ToBytes(string, units) {
+      units = units || Infinity;
+      let codePoint;
+      const length = string.length;
+      let leadSurrogate = null;
+      const bytes = [];
+      for (let i = 0; i < length; ++i) {
+        codePoint = string.charCodeAt(i);
+        if (codePoint > 55295 && codePoint < 57344) {
+          if (!leadSurrogate) {
+            if (codePoint > 56319) {
+              if ((units -= 3) > -1)
+                bytes.push(239, 191, 189);
+              continue;
+            } else if (i + 1 === length) {
+              if ((units -= 3) > -1)
+                bytes.push(239, 191, 189);
+              continue;
+            }
+            leadSurrogate = codePoint;
+            continue;
+          }
+          if (codePoint < 56320) {
+            if ((units -= 3) > -1)
+              bytes.push(239, 191, 189);
+            leadSurrogate = codePoint;
+            continue;
+          }
+          codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+        } else if (leadSurrogate) {
+          if ((units -= 3) > -1)
+            bytes.push(239, 191, 189);
+        }
+        leadSurrogate = null;
+        if (codePoint < 128) {
+          if ((units -= 1) < 0)
+            break;
+          bytes.push(codePoint);
+        } else if (codePoint < 2048) {
+          if ((units -= 2) < 0)
+            break;
+          bytes.push(
+            codePoint >> 6 | 192,
+            codePoint & 63 | 128
+          );
+        } else if (codePoint < 65536) {
+          if ((units -= 3) < 0)
+            break;
+          bytes.push(
+            codePoint >> 12 | 224,
+            codePoint >> 6 & 63 | 128,
+            codePoint & 63 | 128
+          );
+        } else if (codePoint < 1114112) {
+          if ((units -= 4) < 0)
+            break;
+          bytes.push(
+            codePoint >> 18 | 240,
+            codePoint >> 12 & 63 | 128,
+            codePoint >> 6 & 63 | 128,
+            codePoint & 63 | 128
+          );
+        } else {
+          throw new Error("Invalid code point");
+        }
+      }
+      return bytes;
+    }
+    function asciiToBytes(str) {
+      const byteArray = [];
+      for (let i = 0; i < str.length; ++i) {
+        byteArray.push(str.charCodeAt(i) & 255);
+      }
+      return byteArray;
+    }
+    function utf16leToBytes(str, units) {
+      let c, hi, lo;
+      const byteArray = [];
+      for (let i = 0; i < str.length; ++i) {
+        if ((units -= 2) < 0)
+          break;
+        c = str.charCodeAt(i);
+        hi = c >> 8;
+        lo = c % 256;
+        byteArray.push(lo);
+        byteArray.push(hi);
+      }
+      return byteArray;
+    }
+    function base64ToBytes(str) {
+      return base64.toByteArray(base64clean(str));
+    }
+    function blitBuffer(src, dst, offset, length) {
+      let i;
+      for (i = 0; i < length; ++i) {
+        if (i + offset >= dst.length || i >= src.length)
+          break;
+        dst[i + offset] = src[i];
+      }
+      return i;
+    }
+    function isInstance(obj, type) {
+      return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+    }
+    function numberIsNaN(obj) {
+      return obj !== obj;
+    }
+    var hexSliceLookupTable = function() {
+      const alphabet = "0123456789abcdef";
+      const table = new Array(256);
+      for (let i = 0; i < 16; ++i) {
+        const i16 = i * 16;
+        for (let j = 0; j < 16; ++j) {
+          table[i16 + j] = alphabet[i] + alphabet[j];
+        }
+      }
+      return table;
+    }();
+    function defineBigIntMethod(fn) {
+      return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
+    }
+    function BufferBigIntNotDefined() {
+      throw new Error("BigInt not supported");
+    }
+  }
+});
 
 // ../../node_modules/bn.js/lib/bn.js
 var require_bn = __commonJS({
-  "../../node_modules/bn.js/lib/bn.js"(exports, module2) {
-    (function(module3, exports2) {
-      "use strict";
+  "../../node_modules/bn.js/lib/bn.js"(exports, module) {
+    (function(module2, exports2) {
       function assert(val, msg) {
         if (!val)
           throw new Error(msg || "Assertion failed");
@@ -63,8 +1947,8 @@ var require_bn = __commonJS({
           this._init(number || 0, base2 || 10, endian || "be");
         }
       }
-      if (typeof module3 === "object") {
-        module3.exports = BN2;
+      if (typeof module2 === "object") {
+        module2.exports = BN2;
       } else {
         exports2.BN = BN2;
       }
@@ -75,7 +1959,7 @@ var require_bn = __commonJS({
         if (typeof window !== "undefined" && typeof window.Buffer !== "undefined") {
           Buffer2 = window.Buffer;
         } else {
-          Buffer2 = require("buffer").Buffer;
+          Buffer2 = require_buffer().Buffer;
         }
       } catch (e) {
       }
@@ -1593,149 +3477,6 @@ var require_bn = __commonJS({
         }
         return res;
       };
-      function FFTM(x, y) {
-        this.x = x;
-        this.y = y;
-      }
-      FFTM.prototype.makeRBT = function makeRBT(N) {
-        var t = new Array(N);
-        var l = BN2.prototype._countBits(N) - 1;
-        for (var i = 0; i < N; i++) {
-          t[i] = this.revBin(i, l, N);
-        }
-        return t;
-      };
-      FFTM.prototype.revBin = function revBin(x, l, N) {
-        if (x === 0 || x === N - 1)
-          return x;
-        var rb = 0;
-        for (var i = 0; i < l; i++) {
-          rb |= (x & 1) << l - i - 1;
-          x >>= 1;
-        }
-        return rb;
-      };
-      FFTM.prototype.permute = function permute(rbt, rws, iws, rtws, itws, N) {
-        for (var i = 0; i < N; i++) {
-          rtws[i] = rws[rbt[i]];
-          itws[i] = iws[rbt[i]];
-        }
-      };
-      FFTM.prototype.transform = function transform(rws, iws, rtws, itws, N, rbt) {
-        this.permute(rbt, rws, iws, rtws, itws, N);
-        for (var s = 1; s < N; s <<= 1) {
-          var l = s << 1;
-          var rtwdf = Math.cos(2 * Math.PI / l);
-          var itwdf = Math.sin(2 * Math.PI / l);
-          for (var p = 0; p < N; p += l) {
-            var rtwdf_ = rtwdf;
-            var itwdf_ = itwdf;
-            for (var j = 0; j < s; j++) {
-              var re = rtws[p + j];
-              var ie = itws[p + j];
-              var ro = rtws[p + j + s];
-              var io = itws[p + j + s];
-              var rx = rtwdf_ * ro - itwdf_ * io;
-              io = rtwdf_ * io + itwdf_ * ro;
-              ro = rx;
-              rtws[p + j] = re + ro;
-              itws[p + j] = ie + io;
-              rtws[p + j + s] = re - ro;
-              itws[p + j + s] = ie - io;
-              if (j !== l) {
-                rx = rtwdf * rtwdf_ - itwdf * itwdf_;
-                itwdf_ = rtwdf * itwdf_ + itwdf * rtwdf_;
-                rtwdf_ = rx;
-              }
-            }
-          }
-        }
-      };
-      FFTM.prototype.guessLen13b = function guessLen13b(n, m) {
-        var N = Math.max(m, n) | 1;
-        var odd = N & 1;
-        var i = 0;
-        for (N = N / 2 | 0; N; N = N >>> 1) {
-          i++;
-        }
-        return 1 << i + 1 + odd;
-      };
-      FFTM.prototype.conjugate = function conjugate(rws, iws, N) {
-        if (N <= 1)
-          return;
-        for (var i = 0; i < N / 2; i++) {
-          var t = rws[i];
-          rws[i] = rws[N - i - 1];
-          rws[N - i - 1] = t;
-          t = iws[i];
-          iws[i] = -iws[N - i - 1];
-          iws[N - i - 1] = -t;
-        }
-      };
-      FFTM.prototype.normalize13b = function normalize13b(ws, N) {
-        var carry = 0;
-        for (var i = 0; i < N / 2; i++) {
-          var w = Math.round(ws[2 * i + 1] / N) * 8192 + Math.round(ws[2 * i] / N) + carry;
-          ws[i] = w & 67108863;
-          if (w < 67108864) {
-            carry = 0;
-          } else {
-            carry = w / 67108864 | 0;
-          }
-        }
-        return ws;
-      };
-      FFTM.prototype.convert13b = function convert13b(ws, len, rws, N) {
-        var carry = 0;
-        for (var i = 0; i < len; i++) {
-          carry = carry + (ws[i] | 0);
-          rws[2 * i] = carry & 8191;
-          carry = carry >>> 13;
-          rws[2 * i + 1] = carry & 8191;
-          carry = carry >>> 13;
-        }
-        for (i = 2 * len; i < N; ++i) {
-          rws[i] = 0;
-        }
-        assert(carry === 0);
-        assert((carry & ~8191) === 0);
-      };
-      FFTM.prototype.stub = function stub(N) {
-        var ph = new Array(N);
-        for (var i = 0; i < N; i++) {
-          ph[i] = 0;
-        }
-        return ph;
-      };
-      FFTM.prototype.mulp = function mulp(x, y, out) {
-        var N = 2 * this.guessLen13b(x.length, y.length);
-        var rbt = this.makeRBT(N);
-        var _ = this.stub(N);
-        var rws = new Array(N);
-        var rwst = new Array(N);
-        var iwst = new Array(N);
-        var nrws = new Array(N);
-        var nrwst = new Array(N);
-        var niwst = new Array(N);
-        var rmws = out.words;
-        rmws.length = N;
-        this.convert13b(x.words, x.length, rws, N);
-        this.convert13b(y.words, y.length, nrws, N);
-        this.transform(rws, _, rwst, iwst, N, rbt);
-        this.transform(nrws, _, nrwst, niwst, N, rbt);
-        for (var i = 0; i < N; i++) {
-          var rx = rwst[i] * nrwst[i] - iwst[i] * niwst[i];
-          iwst[i] = rwst[i] * niwst[i] + iwst[i] * nrwst[i];
-          rwst[i] = rx;
-        }
-        this.conjugate(rwst, iwst, N);
-        this.transform(rwst, iwst, rmws, _, N, rbt);
-        this.conjugate(rmws, _, N);
-        this.normalize13b(rmws, N);
-        out.negative = x.negative ^ y.negative;
-        out.length = x.length + y.length;
-        return out._strip();
-      };
       BN2.prototype.mul = function mul(num) {
         var out = new BN2(null);
         out.words = new Array(this.length + num.length);
@@ -1852,8 +3593,7 @@ var require_bn = __commonJS({
           }
           maskedWords.length = s;
         }
-        if (s === 0) {
-        } else if (this.length > s) {
+        if (s === 0) ; else if (this.length > s) {
           this.length -= s;
           for (i = 0; i < this.length; i++) {
             this.words[i] = this.words[i + s];
@@ -2963,14 +4703,13 @@ var require_bn = __commonJS({
         var res = this.imod(a._invmp(this.m).mul(this.r2));
         return res._forceRed(this);
       };
-    })(typeof module2 === "undefined" || module2, exports);
+    })(typeof module === "undefined" || module, exports);
   }
 });
 
 // ../../node_modules/@layerzerolabs/lz-v2-utilities/node_modules/base-x/src/index.js
 var require_src = __commonJS({
-  "../../node_modules/@layerzerolabs/lz-v2-utilities/node_modules/base-x/src/index.js"(exports, module2) {
-    "use strict";
+  "../../node_modules/@layerzerolabs/lz-v2-utilities/node_modules/base-x/src/index.js"(exports, module) {
     function base2(ALPHABET) {
       if (ALPHABET.length >= 255) {
         throw new TypeError("Alphabet too long");
@@ -2992,8 +4731,7 @@ var require_src = __commonJS({
       var FACTOR = Math.log(BASE) / Math.log(256);
       var iFACTOR = Math.log(256) / Math.log(BASE);
       function encode(source) {
-        if (source instanceof Uint8Array) {
-        } else if (ArrayBuffer.isView(source)) {
+        if (source instanceof Uint8Array) ; else if (ArrayBuffer.isView(source)) {
           source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
         } else if (Array.isArray(source)) {
           source = Uint8Array.from(source);
@@ -3099,130 +4837,19 @@ var require_src = __commonJS({
         decode
       };
     }
-    module2.exports = base2;
+    module.exports = base2;
   }
 });
 
 // ../../node_modules/@layerzerolabs/lz-v2-utilities/node_modules/bs58/index.js
 var require_bs58 = __commonJS({
-  "../../node_modules/@layerzerolabs/lz-v2-utilities/node_modules/bs58/index.js"(exports, module2) {
+  "../../node_modules/@layerzerolabs/lz-v2-utilities/node_modules/bs58/index.js"(exports, module) {
     var basex = require_src();
     var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-    module2.exports = basex(ALPHABET);
+    module.exports = basex(ALPHABET);
   }
 });
 
-// index.ts
-var queries_exports = {};
-__export(queries_exports, {
-  AutopoolCategory: () => AutopoolCategory,
-  BASE_ASSETS: () => BASE_ASSETS,
-  BATCH_SIZE: () => BATCH_SIZE,
-  ETH_BASE_ASSETS: () => ETH_BASE_ASSETS,
-  EUR_BASE_ASSETS: () => EUR_BASE_ASSETS,
-  MessageStatus: () => MessageStatus,
-  PRICED_TOKENS: () => PRICED_TOKENS,
-  USD_BASE_ASSETS: () => USD_BASE_ASSETS,
-  aggregateSTokeRewardsDayData: () => aggregateSTokeRewardsDayData,
-  arraysToObject: () => arraysToObject,
-  calculateRebalanceStats: () => calculateRebalanceStats,
-  convertBaseAssetToTokenPrices: () => convertBaseAssetToTokenPrices,
-  convertBaseAssetToTokenPricesAndDenom: () => convertBaseAssetToTokenPricesAndDenom,
-  fetchChainDataMap: () => fetchChainDataMap,
-  fetchChainRebalances: () => fetchChainRebalances,
-  fillMissingDates: () => fillMissingDates,
-  findClosestDateEntry: () => findClosestDateEntry,
-  findClosestEntry: () => findClosestEntry,
-  findClosestTimestampEntry: () => findClosestTimestampEntry,
-  formatDateRange: () => formatDateRange,
-  getAddressFromSystemRegistry: () => getAddressFromSystemRegistry,
-  getAllowance: () => getAllowance,
-  getAmountDeposited: () => getAmountDeposited,
-  getAmountWithdrawn: () => getAmountWithdrawn,
-  getAutopilotRouter: () => getAutopilotRouter,
-  getAutopoolCategory: () => getAutopoolCategory,
-  getAutopoolDayData: () => getAutopoolDayData,
-  getAutopoolInfo: () => getAutopoolInfo,
-  getAutopoolRebalances: () => getAutopoolRebalances,
-  getAutopools: () => getAutopools,
-  getAutopoolsHistory: () => getAutopoolsHistory,
-  getAutopoolsRebalances: () => getAutopoolsRebalances,
-  getBridgeFee: () => getBridgeFee,
-  getChainAutopools: () => getChainAutopools,
-  getChainCycleRolloverBlockNumber: () => getChainCycleRolloverBlockNumber,
-  getChainSToke: () => getChainSToke,
-  getChainSTokeRewards: () => getChainSTokeRewards,
-  getChainSubgraphStatus: () => getChainSubgraphStatus,
-  getChainUserActivity: () => getChainUserActivity,
-  getChainUserAutopools: () => getChainUserAutopools,
-  getChainUserSToke: () => getChainUserSToke,
-  getChainUserSTokeRewards: () => getChainUserSTokeRewards,
-  getChainUserSTokeVotes: () => getChainUserSTokeVotes,
-  getChainsForEnv: () => getChainsForEnv,
-  getCurrentCycleId: () => getCurrentCycleId,
-  getCurveLP: () => getCurveLP,
-  getCycleV1: () => getCycleV1,
-  getDefillamaPrice: () => getDefillamaPrice,
-  getDynamicSwap: () => getDynamicSwap,
-  getEthPrice: () => getEthPrice,
-  getEthPriceAtBlock: () => getEthPriceAtBlock,
-  getExchangeNames: () => getExchangeNames,
-  getGenStratAprs: () => getGenStratAprs,
-  getLayerzeroStatus: () => getLayerzeroStatus,
-  getMutlipleAutopoolRebalances: () => getMutlipleAutopoolRebalances,
-  getPoolStats: () => getPoolStats,
-  getPoolsAndDestinations: () => getPoolsAndDestinations,
-  getProtocolStats: () => getProtocolStats,
-  getRebalanceStats: () => getRebalanceStats,
-  getRebalanceValueUsd: () => getRebalanceValueUsd,
-  getRewardsPayloadV1: () => getRewardsPayloadV1,
-  getSToke: () => getSToke,
-  getSTokeChainsForEnv: () => getSTokeChainsForEnv,
-  getSTokeRewards: () => getSTokeRewards,
-  getSTokeVotes: () => getSTokeVotes,
-  getSubgraphStatus: () => getSubgraphStatus,
-  getSushiLP: () => getSushiLP,
-  getSwapQuote: () => getSwapQuote,
-  getSystemConfig: () => getSystemConfig,
-  getTimestampDaysFromStart: () => getTimestampDaysFromStart,
-  getTokePrice: () => getTokePrice,
-  getTokenList: () => getTokenList,
-  getTokenPrice: () => getTokenPrice,
-  getTokenPrices: () => getTokenPrices,
-  getTopAutopoolHolders: () => getTopAutopoolHolders,
-  getUserActivity: () => getUserActivity,
-  getUserAutoEthRewards: () => getUserAutoEthRewards,
-  getUserAutopool: () => getUserAutopool,
-  getUserAutopools: () => getUserAutopools,
-  getUserAutopoolsHistory: () => getUserAutopoolsHistory,
-  getUserAutopoolsRewards: () => getUserAutopoolsRewards,
-  getUserCurveLP: () => getUserCurveLP,
-  getUserRewardsV1: () => getUserRewardsV1,
-  getUserSToke: () => getUserSToke,
-  getUserSTokeVotes: () => getUserSTokeVotes,
-  getUserSushiLP: () => getUserSushiLP,
-  getUserTokenBalances: () => getUserTokenBalances,
-  getUserV1: () => getUserV1,
-  mergeArrays: () => mergeArrays,
-  mergeArraysWithKey: () => mergeArraysWithKey,
-  mergeStringArrays: () => mergeStringArrays,
-  modifyAutopoolName: () => modifyAutopoolName,
-  nestedArrayToObject: () => nestedArrayToObject,
-  paginateQuery: () => paginateQuery,
-  processRebalance: () => processRebalance,
-  processRebalancesInBatches: () => processRebalancesInBatches,
-  systemRegistryFunctionNames: () => systemRegistryFunctionNames,
-  updateRebalanceStats: () => updateRebalanceStats,
-  waitForMessageReceived: () => waitForMessageReceived
-});
-module.exports = __toCommonJS(queries_exports);
-
-// functions/getEthPrice.ts
-var import_chains = require("viem/chains");
-
-// functions/getTokenPrice.ts
-var import_constants = require("@tokemak/constants");
-
 // functions/getDefillamaPrice.ts
 var getDefillamaPrice = async (tokenAddress) => {
   const response = await fetch(
@@ -3251,7 +4878,7 @@ var getTokenPrice = async ({
     if (excludedSources) {
       params.set("excludedSources", excludedSources.join(","));
     }
-    const response = await fetch(`${import_constants.TOKEMAK_SWAP_PRICING_URL}?${params}`);
+    const response = await fetch(`${constants.TOKEMAK_SWAP_PRICING_URL}?${params}`);
     const data = await response.json();
     return data.price;
   } catch (error) {
@@ -3295,7 +4922,7 @@ async function getTokenPriceFallback(tokenSymbol) {
 var getEthPrice = async () => {
   try {
     return await getTokenPrice({
-      chainId: import_chains.sepolia.id,
+      chainId: chains.sepolia.id,
       tokenAddress: "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE"
     });
   } catch (error) {
@@ -3309,12 +4936,9 @@ var getEthPrice = async () => {
     }
   }
 };
-
-// functions/getTokePrice.ts
-var import_tokenlist = require("@tokemak/tokenlist");
 var getTokePrice = async () => {
   try {
-    return await getTokenPrice({ tokenAddress: import_tokenlist.TOKE_TOKEN.address });
+    return await getTokenPrice({ tokenAddress: tokenlist.TOKE_TOKEN.address });
   } catch (error) {
     console.warn("Primary price fetch failed. Attempting fallback...", error);
     try {
@@ -3489,14 +5113,11 @@ function mergeStringArrays(keys, values) {
   }
   return result;
 }
-
-// utils/getChainsForEnv.ts
-var import_constants2 = require("@tokemak/constants");
 function getChainsForEnv({
   includeTestnet = false
 }) {
   let chains;
-  chains = includeTestnet ? [...import_constants2.SUPPORTED_DEV_CHAINS] : [...import_constants2.SUPPORTED_PROD_CHAINS];
+  chains = includeTestnet ? [...constants.SUPPORTED_DEV_CHAINS] : [...constants.SUPPORTED_PROD_CHAINS];
   return chains;
 }
 
@@ -3508,10 +5129,6 @@ async function fetchChainDataMap(chains, fetchFn) {
     return acc;
   }, {});
 }
-
-// utils/aggregateSTokeRewardsDayData.ts
-var import_viem = require("viem");
-var import_utils = require("@tokemak/utils");
 function aggregateSTokeRewardsDayData(dayDatas) {
   const byTs = {};
   for (const item of dayDatas) {
@@ -3519,8 +5136,8 @@ function aggregateSTokeRewardsDayData(dayDatas) {
     const dateStr = matchDate ? matchDate[0] : item.id;
     const ts = item.timestamp;
     if (!byTs[ts]) {
-      const date = (0, import_utils.convertTimestampToDate)(Number(ts));
-      const formattedDate = (0, import_utils.formatDateToReadable)(date);
+      const date = utils.convertTimestampToDate(Number(ts));
+      const formattedDate = utils.formatDateToReadable(date);
       byTs[ts] = {
         id: dateStr,
         formattedDate,
@@ -3532,10 +5149,10 @@ function aggregateSTokeRewardsDayData(dayDatas) {
       };
     }
     if (typeof item.balance === "string" && typeof item.balanceUSD === "string" && typeof item.earned === "string" && typeof item.earnedUSD === "string") {
-      byTs[ts].balance += Number((0, import_utils.formatEtherNum)(item.balance));
-      byTs[ts].balanceUSD += Number((0, import_viem.formatUnits)(item.balanceUSD, 8));
-      byTs[ts].earned += Number((0, import_utils.formatEtherNum)(item.earned));
-      byTs[ts].earnedUSD += Number((0, import_viem.formatUnits)(item.earnedUSD, 8));
+      byTs[ts].balance += Number(utils.formatEtherNum(item.balance));
+      byTs[ts].balanceUSD += Number(viem.formatUnits(item.balanceUSD, 8));
+      byTs[ts].earned += Number(utils.formatEtherNum(item.earned));
+      byTs[ts].earnedUSD += Number(viem.formatUnits(item.earnedUSD, 8));
     } else if (typeof item.balance === "number" && typeof item.balanceUSD === "number" && typeof item.earned === "number" && typeof item.earnedUSD === "number") {
       byTs[ts].balance += item.balance;
       byTs[ts].balanceUSD += item.balanceUSD;
@@ -3546,14 +5163,11 @@ function aggregateSTokeRewardsDayData(dayDatas) {
   const result = Object.values(byTs).filter((day) => day.earned !== 0);
   return result;
 }
-
-// utils/getSTokeChainsForEnv.ts
-var import_constants3 = require("@tokemak/constants");
 function getSTokeChainsForEnv({
   includeTestnet = false
 }) {
   let chains;
-  chains = includeTestnet ? [...import_constants3.SUPPORTED_STOKE_DEV_CHAINS] : [...import_constants3.SUPPORTED_STOKE_PROD_CHAINS];
+  chains = includeTestnet ? [...constants.SUPPORTED_STOKE_DEV_CHAINS] : [...constants.SUPPORTED_STOKE_PROD_CHAINS];
   return chains;
 }
 
@@ -3605,11 +5219,8 @@ var convertBaseAssetToTokenPricesAndDenom = (baseAsset, baseAssetPrice, denomPri
     denom: baseAsset * baseAssetToDenom
   };
 };
-
-// utils/getAutopoolInfo.ts
-var import_tokenlist2 = require("@tokemak/tokenlist");
 var getAutopoolInfo = (symbol) => {
-  const autopool = import_tokenlist2.ALL_AUTOPOOLS.find((pool) => pool.symbol === symbol);
+  const autopool = tokenlist.ALL_AUTOPOOLS.find((pool) => pool.symbol === symbol);
   return autopool;
 };
 
@@ -3679,9 +5290,6 @@ async function paginateQuery(queryFn, arrayKey, options = {}) {
   return results;
 }
 
-// functions/getPoolsAndDestinationsBackup.ts
-var import_utils2 = require("@tokemak/utils");
-
 // functions/getBlobData.ts
 var getBlobData = async (blobName) => {
   try {
@@ -3704,7 +5312,7 @@ var getBlobData = async (blobName) => {
 // functions/getPoolsAndDestinationsBackup.ts
 var getPoolsAndDestinationsBackup = async (chainId) => {
   try {
-    const networkName = (0, import_utils2.getNetwork)(chainId)?.name.toLowerCase();
+    const networkName = utils.getNetwork(chainId)?.name.toLowerCase();
     const backupData = await getBlobData(
       `${networkName}-getPoolsAndDestinations-latest-success.json`
     );
@@ -3714,10 +5322,6 @@ var getPoolsAndDestinationsBackup = async (chainId) => {
   }
 };
 
-// functions/getChainAutopools.ts
-var import_utils6 = require("@tokemak/utils");
-var import_viem2 = require("viem");
-
 // constants/tokenOrders.ts
 var UITokenOrder = [
   "ETH",
@@ -3753,9 +5357,6 @@ var protocolOrder = [
   "Morpho",
   "Fluid"
 ];
-
-// functions/getGenStratAprs.ts
-var import_constants4 = require("@tokemak/constants");
 var getGenStratAprs = async ({
   chainId = 1
 }) => {
@@ -3764,7 +5365,7 @@ var getGenStratAprs = async ({
       chainId: chainId.toString(),
       systemName: "gen3"
     });
-    const response = await fetch(`${import_constants4.TOKEMAK_GENSTRAT_APRS_API_URL}?${params}`);
+    const response = await fetch(`${constants.TOKEMAK_GENSTRAT_APRS_API_URL}?${params}`);
     const data = await response.json();
     if (data && data.success) {
       return data.aprs.reduce((p, c) => {
@@ -3787,22 +5388,12 @@ var getGenStratAprs = async ({
     return void 0;
   }
 };
-
-// functions/getChainAutopools.ts
-var import_tokenlist3 = require("@tokemak/tokenlist");
-var import_graph_cli = require("@tokemak/graph-cli");
-var import_chains2 = require("viem/chains");
-
-// functions/getPoolsAndDestinations.ts
-var import_config = require("@tokemak/config");
-var import_core = require("@wagmi/core");
-var import_abis = require("@tokemak/abis");
 var getPoolsAndDestinations = async (wagmiConfig, { chainId }) => {
   try {
-    const { lens } = (0, import_config.getCoreConfig)(chainId);
-    const { autoPools, destinations } = await (0, import_core.readContract)(wagmiConfig, {
+    const { lens } = config.getCoreConfig(chainId);
+    const { autoPools, destinations } = await core.readContract(wagmiConfig, {
       address: lens,
-      abi: import_abis.lensAbi,
+      abi: abis.lensAbi,
       functionName: "getPoolsAndDestinations",
       chainId
     });
@@ -3816,12 +5407,9 @@ var getPoolsAndDestinations = async (wagmiConfig, { chainId }) => {
     console.error(`Error on ${chainId} in getPoolsAndDestinations:`, error);
   }
 };
-
-// functions/getBackupApr.ts
-var import_utils4 = require("@tokemak/utils");
 var getBackupApr = async (chainId, poolAddress) => {
   try {
-    const networkName = (0, import_utils4.getNetwork)(chainId)?.name.toLowerCase();
+    const networkName = utils.getNetwork(chainId)?.name.toLowerCase();
     const backupData = await getBlobData(
       `${networkName}-getChainAutopools-latest-success.json`
     );
@@ -3843,10 +5431,10 @@ var getChainAutopools = async (wagmiConfig, {
   chainId,
   prices
 }) => {
-  const { GetVaultAddeds, GetAutopoolsInactiveDestinations } = (0, import_graph_cli.getSdkByChainId)(chainId);
+  const { GetVaultAddeds, GetAutopoolsInactiveDestinations } = graphCli.getSdkByChainId(chainId);
   try {
     const { vaultAddeds } = await GetVaultAddeds();
-    const { GetAutopoolsApr } = (0, import_graph_cli.getSdkByChainId)(chainId);
+    const { GetAutopoolsApr } = graphCli.getSdkByChainId(chainId);
     const { autopools: autopoolsApr } = await GetAutopoolsApr();
     const genStratAprs = await getGenStratAprs({
       chainId
@@ -3868,7 +5456,7 @@ var getChainAutopools = async (wagmiConfig, {
     }, {});
     const autopools = await Promise.all(
       autopoolsAndDestinations.map(async (autopool) => {
-        let baseAsset = (0, import_utils6.getToken)(autopool.baseAsset);
+        let baseAsset = utils.getToken(autopool.baseAsset);
         if (!baseAsset?.symbol) {
           console.error(
             "FIX THIS BEFORE PROD: base asset not found",
@@ -3883,18 +5471,18 @@ var getChainAutopools = async (wagmiConfig, {
           }) || 0;
         }
         const timestamp = vaultAddedMapping[autopool.poolAddress.toLowerCase()];
-        const totalAssets = (0, import_utils6.formatUnitsNum)(
+        const totalAssets = utils.formatUnitsNum(
           autopool.totalAssets,
           baseAsset.decimals
         );
         const tvl = totalAssets * baseAssetPrice;
-        const totalIdleAssets = (0, import_utils6.formatUnitsNum)(
+        const totalIdleAssets = utils.formatUnitsNum(
           autopool.totalIdle,
           baseAsset.decimals
         );
         const exchangeValues = {};
         const destinations = autopool.destinations.map((destination) => {
-          const debtValueHeldByVaultEth = (0, import_utils6.formatUnitsNum)(
+          const debtValueHeldByVaultEth = utils.formatUnitsNum(
             destination.debtValueHeldByVault,
             baseAsset.decimals
           );
@@ -3907,8 +5495,8 @@ var getChainAutopools = async (wagmiConfig, {
             destination.underlyingTokenValueHeld
           );
           let underlyingTokens = tokensWithValue.map((token) => {
-            const tokenDetails = (0, import_utils6.getToken)(token.tokenAddress);
-            let value = (0, import_utils6.formatUnitsNum)(
+            const tokenDetails = utils.getToken(token.tokenAddress);
+            let value = utils.formatUnitsNum(
               token.valueHeldInEth,
               baseAsset.decimals
             );
@@ -3924,7 +5512,7 @@ var getChainAutopools = async (wagmiConfig, {
             if (underlyingTokenAddress) {
               underlyingTokens = [
                 {
-                  ...(0, import_utils6.getToken)(underlyingTokenAddress, chainId),
+                  ...utils.getToken(underlyingTokenAddress, chainId),
                   valueUsd: debtValueHeldByVaultEth * baseAssetPrice,
                   value: debtValueHeldByVaultEth
                 }
@@ -3936,25 +5524,25 @@ var getChainAutopools = async (wagmiConfig, {
             ...destination,
             debtValueHeldByVaultUsd: debtValueHeldByVaultEth * baseAssetPrice,
             debtValueHeldByVaultEth,
-            compositeReturn: isGenStrat ? genStratAprs?.[autopool.poolAddress]?.[destination.vaultAddress]?.apr || 0 : (0, import_utils6.formatEtherNum)(destination.compositeReturn),
+            compositeReturn: isGenStrat ? genStratAprs?.[autopool.poolAddress]?.[destination.vaultAddress]?.apr || 0 : utils.formatEtherNum(destination.compositeReturn),
             debtValueHeldByVaultAllocation: debtValueHeldByVaultEth / totalAssets,
             underlyingTokens,
-            poolName: (0, import_utils6.formatPoolName)(destination.lpTokenName),
-            exchange: (0, import_utils6.getProtocol)(destination.exchangeName)
+            poolName: utils.formatPoolName(destination.lpTokenName),
+            exchange: utils.getProtocol(destination.exchangeName)
           };
         });
         const uniqueExchanges = Array.from(
           new Set(
-            destinations.map((d) => (0, import_utils6.getProtocol)(d.exchangeName)).filter(Boolean)
+            destinations.map((d) => utils.getProtocol(d.exchangeName)).filter(Boolean)
           )
         );
         const uniqueExchangesWithValueHeld = uniqueExchanges.map((exchange) => {
           const exchangeName = exchange.name.toLowerCase();
           let exchangeInfo = exchange;
           const value = exchangeValues[exchangeName];
-          if (chainId === import_chains2.sonic.id) {
+          if (chainId === chains.sonic.id) {
             if (exchangeName === "balancerv3" || exchangeName === "balancer") {
-              exchangeInfo = import_tokenlist3.BEETS_PROTOCOL;
+              exchangeInfo = tokenlist.BEETS_PROTOCOL;
             }
           }
           return {
@@ -4004,26 +5592,26 @@ var getChainAutopools = async (wagmiConfig, {
           }
         );
         let UIBaseAsset = baseAsset;
-        if (baseAsset.symbol?.toLowerCase() === import_tokenlist3.WETH_TOKEN.symbol.toLowerCase()) {
-          UIBaseAsset = import_tokenlist3.ETH_TOKEN;
+        if (baseAsset.symbol?.toLowerCase() === tokenlist.WETH_TOKEN.symbol.toLowerCase()) {
+          UIBaseAsset = tokenlist.ETH_TOKEN;
         }
-        if (baseAsset.symbol?.toLowerCase() === import_tokenlist3.WS_TOKEN.symbol.toLowerCase()) {
-          UIBaseAsset = import_tokenlist3.S_TOKEN;
+        if (baseAsset.symbol?.toLowerCase() === tokenlist.WS_TOKEN.symbol.toLowerCase()) {
+          UIBaseAsset = tokenlist.S_TOKEN;
         }
-        if (baseAsset.symbol?.toLowerCase() === import_tokenlist3.WXPL_TOKEN.symbol.toLowerCase()) {
-          UIBaseAsset = import_tokenlist3.XPL_TOKEN;
+        if (baseAsset.symbol?.toLowerCase() === tokenlist.WXPL_TOKEN.symbol.toLowerCase()) {
+          UIBaseAsset = tokenlist.XPL_TOKEN;
         }
         const isNew = (Date.now() / 1e3 - timestamp) / 60 / 60 / 24 < 45;
         const aprs = autopoolsApr.find(
-          (autopoolApr) => (0, import_viem2.getAddress)(autopoolApr.id) === (0, import_viem2.getAddress)(autopool.poolAddress)
+          (autopoolApr) => viem.getAddress(autopoolApr.id) === viem.getAddress(autopool.poolAddress)
         );
         let baseApr = aprs?.currentApy;
         let boostedApr = 0;
         let extraApr = 0;
-        const formattedRewarder7DayMAApy = (0, import_utils6.formatEtherNum)(
+        const formattedRewarder7DayMAApy = utils.formatEtherNum(
           BigInt(Number(aprs?.rewarder?.day7MAApy) || 0)
         );
-        const formattedRewarder30DayMAApy = (0, import_utils6.formatEtherNum)(
+        const formattedRewarder30DayMAApy = utils.formatEtherNum(
           BigInt(Number(aprs?.rewarder?.day30MAApy) || 0)
         );
         if (formattedRewarder7DayMAApy > 0) {
@@ -4038,9 +5626,9 @@ var getChainAutopools = async (wagmiConfig, {
           }, 0);
           const periodicFeeBps = autopool.periodicFeeBps || 0n;
           const streamingFeeBps = autopool.streamingFeeBps || 0n;
-          baseApr = (weightedCrNum / (1 - totalIdleAssets / totalAssets) - Number((0, import_viem2.formatUnits)(periodicFeeBps, 4))) * (1 - Number((0, import_viem2.formatUnits)(streamingFeeBps, 4)));
+          baseApr = (weightedCrNum / (1 - totalIdleAssets / totalAssets) - Number(viem.formatUnits(periodicFeeBps, 4))) * (1 - Number(viem.formatUnits(streamingFeeBps, 4)));
         } else {
-          baseApr = Number((0, import_viem2.formatUnits)(BigInt(baseApr), baseAsset.decimals));
+          baseApr = Number(viem.formatUnits(BigInt(baseApr), baseAsset.decimals));
         }
         if (!baseApr) {
           baseApr = 0;
@@ -4063,10 +5651,10 @@ var getChainAutopools = async (wagmiConfig, {
         let extraRewards = [];
         if (aprs?.rewarder?.extraRewarders?.length && aprs?.rewarder?.extraRewarders?.length > 0) {
           extraRewards = aprs?.rewarder?.extraRewarders.map((reward) => {
-            const token = (0, import_utils6.getToken)(reward?.rewardToken?.id, chainId);
+            const token = utils.getToken(reward?.rewardToken?.id, chainId);
             return {
               ...token,
-              apr: (0, import_utils6.formatEtherNum)(BigInt(reward.currentApy || 0))
+              apr: utils.formatEtherNum(BigInt(reward.currentApy || 0))
             };
           });
         }
@@ -4075,13 +5663,13 @@ var getChainAutopools = async (wagmiConfig, {
         }
         extraApr = extraRewards.reduce((acc, reward) => acc + reward.apr, 0);
         const combinedApr = baseApr + boostedApr + extraApr;
-        let denominatedToken = import_tokenlist3.ETH_TOKEN;
+        let denominatedToken = tokenlist.ETH_TOKEN;
         let useDenominatedValues = false;
         const denominatedIn = aprs?.denominatedIn;
         if (denominatedIn?.symbol?.toLowerCase() === "weth") {
-          denominatedToken = import_tokenlist3.ETH_TOKEN;
+          denominatedToken = tokenlist.ETH_TOKEN;
         } else {
-          denominatedToken = (0, import_utils6.getToken)(denominatedIn?.id);
+          denominatedToken = utils.getToken(denominatedIn?.id);
           if (denominatedToken) {
             useDenominatedValues = true;
           }
@@ -4096,12 +5684,12 @@ var getChainAutopools = async (wagmiConfig, {
             tokenAddress: denominatedToken.address
           }) || 0;
         }
-        const navPerShareBaseAsset = (0, import_utils6.formatUnitsNum)(
+        const navPerShareBaseAsset = utils.formatUnitsNum(
           autopool.navPerShare,
           baseAsset.decimals
         );
         const assets = convertBaseAssetToTokenPricesAndDenom(
-          (0, import_utils6.formatUnitsNum)(autopool.totalAssets, baseAsset.decimals),
+          utils.formatUnitsNum(autopool.totalAssets, baseAsset.decimals),
           baseAssetPrice,
           denominatedTokenPrice,
           prices
@@ -4138,7 +5726,7 @@ var getChainAutopools = async (wagmiConfig, {
           try {
             const parentAsset = token.extensions?.parentAsset;
             if (parentAsset) {
-              const parentToken = import_tokenlist3.ALL_TOKENS.find(
+              const parentToken = tokenlist.ALL_TOKENS.find(
                 (t) => t.symbol.toLowerCase() === parentAsset.toLowerCase()
               );
               if (parentToken && !acc.some(
@@ -4208,7 +5796,7 @@ var getChainAutopools = async (wagmiConfig, {
         });
         const autopoolInfo = getAutopoolInfo(autopool.symbol);
         if (autopoolInfo && !autopoolInfo.description) {
-          autopoolInfo.description = `Autopool featuring ${UIBaseAsset.symbol} deployed across integrated DEXs and lending protocols on ${(0, import_utils6.getNetwork)(chainId)?.name}.`;
+          autopoolInfo.description = `Autopool featuring ${UIBaseAsset.symbol} deployed across integrated DEXs and lending protocols on ${utils.getNetwork(chainId)?.name}.`;
         }
         return {
           ...autopool,
@@ -4233,7 +5821,7 @@ var getChainAutopools = async (wagmiConfig, {
           UITokens,
           UIExchanges: finalUIExchanges,
           tokens: uniqueTokens,
-          chain: (0, import_utils6.getNetwork)(chainId),
+          chain: utils.getNetwork(chainId),
           apr: {
             base: baseApr,
             boosted: boostedApr,
@@ -4263,10 +5851,6 @@ var getChainAutopools = async (wagmiConfig, {
     return [];
   }
 };
-
-// functions/getAutopools.ts
-var import_config2 = require("@tokemak/config");
-var import_viem3 = require("viem");
 var getAutopools = async (wagmiConfig, {
   prices,
   includeTestnet = false
@@ -4288,18 +5872,15 @@ var getAutopools = async (wagmiConfig, {
       return sortedAutopoolsByTimestamp;
     } else {
       return sortedAutopoolsByTimestamp.filter((pool) => {
-        return import_config2.AUTOPOOLS_WHITELIST_PROD.includes((0, import_viem3.getAddress)(pool.poolAddress));
+        return config.AUTOPOOLS_WHITELIST_PROD.includes(viem.getAddress(pool.poolAddress));
       });
     }
   } catch (e) {
     console.error(e);
   }
 };
-
-// functions/getAutopoolRebalances.ts
-var import_graph_cli2 = require("@tokemak/graph-cli");
 var getAutopoolRebalances = async (id, chainId = 1, options) => {
-  const { GetAutopoolRebalances } = (0, import_graph_cli2.getSdkByChainId)(chainId);
+  const { GetAutopoolRebalances } = graphCli.getSdkByChainId(chainId);
   const first = options?.first ?? 1e3;
   const maxPages = options?.maxPages ?? 100;
   const queryFn = ({ first: first2, skip }) => GetAutopoolRebalances({ address: id, first: first2, skip });
@@ -4314,23 +5895,14 @@ var getAutopoolRebalances = async (id, chainId = 1, options) => {
     ix: length - index
   }));
 };
-
-// functions/getAutopoolsRebalances.ts
-var import_graph_cli3 = require("@tokemak/graph-cli");
 var getAutopoolsRebalances = async (chainId = 1) => {
-  const { GetAutopoolsRebalances } = (0, import_graph_cli3.getSdkByChainId)(chainId);
+  const { GetAutopoolsRebalances } = graphCli.getSdkByChainId(chainId);
   const { autopools } = await GetAutopoolsRebalances();
   const rebalances = autopools.map(({ rebalances: rebalances2 }) => rebalances2);
   return rebalances.flat().sort((a, b) => b.timestamp - a.timestamp);
 };
-
-// functions/getAutopoolsHistory.ts
-var import_viem4 = require("viem");
-
-// functions/getAutopoolsDayData.ts
-var import_graph_cli4 = require("@tokemak/graph-cli");
 var getAutopoolsDayData = async (chainId, timestamp) => {
-  const { GetAutopoolsDayData } = (0, import_graph_cli4.getSdkByChainId)(chainId);
+  const { GetAutopoolsDayData } = graphCli.getSdkByChainId(chainId);
   const PAGE_SIZE = 1e3;
   let allResults = [];
   let hasMore = true;
@@ -4387,7 +5959,7 @@ var getAutopoolsHistory = async (autopools, days, includeTestnet = false) => {
           ...data,
           date: new Date(data.timestamp * 1e3),
           baseAsset: autopools.find(
-            (pool) => (0, import_viem4.getAddress)(pool.poolAddress) === (0, import_viem4.getAddress)(vaultId)
+            (pool) => viem.getAddress(pool.poolAddress) === viem.getAddress(vaultId)
           )?.baseAsset
         });
       }
@@ -4405,13 +5977,9 @@ var getAutopoolsHistory = async (autopools, days, includeTestnet = false) => {
     console.log(e);
   }
 };
-
-// functions/getCurveLP.ts
-var import_config3 = require("@tokemak/config");
-var import_constants5 = require("@tokemak/constants");
 var getCurveLP = async () => {
   let curveData;
-  const { curveRewardsUrl } = (0, import_config3.getMainnetConfig)();
+  const { curveRewardsUrl } = config.getMainnetConfig();
   try {
     const curveRewardsResponse = await fetch(curveRewardsUrl);
     const curveRewardsData = await curveRewardsResponse.json();
@@ -4425,10 +5993,10 @@ var getCurveLP = async () => {
     console.error(e);
   }
   try {
-    const curvePoolsResponse = await fetch(import_constants5.CURVE_API_URL);
+    const curvePoolsResponse = await fetch(constants.CURVE_API_URL);
     const curvePoolsData = await curvePoolsResponse.json();
     const curveTOKEPool = curvePoolsData?.data?.poolData.find(
-      (pool) => pool.id === import_constants5.TOKE_CURVE_POOL_ID
+      (pool) => pool.id === constants.TOKE_CURVE_POOL_ID
     );
     if (curveData) {
       curveData.curveTvl = curveTOKEPool?.usdTotal;
@@ -4439,33 +6007,26 @@ var getCurveLP = async () => {
   }
   return curveData;
 };
-
-// functions/getSushiLP.ts
-var import_abis2 = require("@tokemak/abis");
-var import_config4 = require("@tokemak/config");
-var import_core2 = require("@wagmi/core");
-var import_viem5 = require("viem");
-var import_chains3 = require("viem/chains");
 var getSushiLP = async (wagmiConfig, { ethPrice }) => {
-  const { sushiPool, lpRewardsV1Url } = (0, import_config4.getMainnetConfig)();
+  const { sushiPool, lpRewardsV1Url } = config.getMainnetConfig();
   const sushiPoolContract = {
     address: sushiPool,
-    abi: import_abis2.sushiPoolAbi
+    abi: abis.sushiPoolAbi
   };
   try {
-    const [{ result: reserves }, { result: totalSupply }] = await (0, import_core2.readContracts)(
+    const [{ result: reserves }, { result: totalSupply }] = await core.readContracts(
       wagmiConfig,
       {
         contracts: [
           {
             ...sushiPoolContract,
             functionName: "getReserves",
-            chainId: import_chains3.mainnet.id
+            chainId: chains.mainnet.id
           },
           {
             ...sushiPoolContract,
             functionName: "totalSupply",
-            chainId: import_chains3.mainnet.id
+            chainId: chains.mainnet.id
           }
         ]
       }
@@ -4477,8 +6038,8 @@ var getSushiLP = async (wagmiConfig, { ethPrice }) => {
     );
     if (reserves && totalSupply && ethPrice) {
       const lpReserve = reserves[1] * 2n;
-      const tvl = Number((0, import_viem5.formatEther)(lpReserve)) * ethPrice;
-      const valueOf1LP = tvl / Number((0, import_viem5.formatEther)(totalSupply));
+      const tvl = Number(viem.formatEther(lpReserve)) * ethPrice;
+      const valueOf1LP = tvl / Number(viem.formatEther(totalSupply));
       return {
         tvl,
         lpReserve,
@@ -4493,11 +6054,8 @@ var getSushiLP = async (wagmiConfig, { ethPrice }) => {
     console.log(e);
   }
 };
-
-// functions/getChainUserActivity.ts
-var import_graph_cli5 = require("@tokemak/graph-cli");
 var getChainUserActivity = async (address, chainId = 1) => {
-  const { GetUserBalanceChangeHistory } = (0, import_graph_cli5.getSdkByChainId)(chainId);
+  const { GetUserBalanceChangeHistory } = graphCli.getSdkByChainId(chainId);
   try {
     const { userAutopoolBalanceChanges } = await GetUserBalanceChangeHistory({
       userAddress: address
@@ -4564,11 +6122,6 @@ var getRewardsPayloadV1 = async (cycleHash, account, rewardsV1Url) => {
     return null;
   }
 };
-
-// functions/getUserAutoEthRewards.ts
-var import_abis3 = require("@tokemak/abis");
-var import_core3 = require("@wagmi/core");
-var import_utils10 = require("@tokemak/utils");
 var getAutoEthRewards = async (wagmiConfig, {
   account,
   currentCycleIndex,
@@ -4577,16 +6130,16 @@ var getAutoEthRewards = async (wagmiConfig, {
   chainId
 }) => {
   try {
-    const [, drippingHash] = await (0, import_core3.readContract)(wagmiConfig, {
+    const [, drippingHash] = await core.readContract(wagmiConfig, {
       address: rewardsHash,
-      abi: import_abis3.autoEthRewardsHashAbi,
+      abi: abis.autoEthRewardsHashAbi,
       functionName: "cycleHashes",
       args: [currentCycleIndex - 306n],
       chainId
     });
-    const [, lastWeekHash] = await (0, import_core3.readContract)(wagmiConfig, {
+    const [, lastWeekHash] = await core.readContract(wagmiConfig, {
       address: rewardsHash,
-      abi: import_abis3.autoEthRewardsHashAbi,
+      abi: abis.autoEthRewardsHashAbi,
       functionName: "cycleHashes",
       // -1 to get the previous cycle
       args: [currentCycleIndex - 306n - 1n],
@@ -4606,7 +6159,7 @@ var getAutoEthRewards = async (wagmiConfig, {
     const currentAmount = Number(drippingHashPayload?.summary?.currentAmount);
     const previousAmount = Number(drippingHashPayload?.summary?.previousAmount);
     const cycleDuration = 604800;
-    const lastCycleStart = (0, import_utils10.convertChainCycleToUnix)(Number(currentCycleIndex));
+    const lastCycleStart = utils.convertChainCycleToUnix(Number(currentCycleIndex));
     const timeSinceCycleStart = Date.now() / 1e3 - lastCycleStart;
     const currentUserRewards = currentAmount * Math.min(timeSinceCycleStart, cycleDuration) / cycleDuration + previousAmount;
     const lastWeekRewards = Number(lastWeekHashPayload?.summary?.currentAmount);
@@ -4627,15 +6180,11 @@ var getUserAutoEthRewards = async (wagmiConfig, rewardsV1Url, rewardsHash, addre
     rewardsHash,
     chainId
   });
-  const currentUserRewardsUsd = (0, import_utils10.formatCurrency)(
+  const currentUserRewardsUsd = utils.formatCurrency(
     ethPrice * (autoETHRewards?.currentUserRewards || 0)
   );
   return { ...autoETHRewards, currentUserRewardsUsd };
 };
-
-// functions/getUserRewardsV1.ts
-var import_abis4 = require("@tokemak/abis");
-var import_core4 = require("@wagmi/core");
 var getUserRewardsV1 = async (wagmiConfig, {
   address,
   rewardsCycleIndex,
@@ -4645,11 +6194,11 @@ var getUserRewardsV1 = async (wagmiConfig, {
   chainId
 }) => {
   try {
-    const [latestClaimableHash, cycleRewardsHash] = await (0, import_core4.readContract)(
+    const [latestClaimableHash, cycleRewardsHash] = await core.readContract(
       wagmiConfig,
       {
         address: rewardsV1Hash,
-        abi: import_abis4.rewardsV1HashAbi,
+        abi: abis.rewardsV1HashAbi,
         functionName: "cycleHashes",
         args: [rewardsCycleIndex],
         chainId
@@ -4669,9 +6218,9 @@ var getUserRewardsV1 = async (wagmiConfig, {
       const {
         payload: { chainId: payloadChainId, cycle, wallet, amount }
       } = latestClaimablePayload;
-      const claimable = await (0, import_core4.readContract)(wagmiConfig, {
+      const claimable = await core.readContract(wagmiConfig, {
         address: rewardsV1,
-        abi: import_abis4.rewardsV1Abi,
+        abi: abis.rewardsV1Abi,
         functionName: "getClaimableAmount",
         args: [{ chainId: payloadChainId, cycle, wallet, amount }],
         chainId
@@ -4683,12 +6232,6 @@ var getUserRewardsV1 = async (wagmiConfig, {
     console.log(e);
   }
 };
-
-// functions/getUserV1.ts
-var import_abis5 = require("@tokemak/abis");
-var import_core5 = require("@wagmi/core");
-var import_config5 = require("@tokemak/config");
-var import_chains4 = require("viem/chains");
 var getUserV1 = async (wagmiConfig, {
   currentCycleIndex,
   address,
@@ -4703,14 +6246,14 @@ var getUserV1 = async (wagmiConfig, {
     autoEthGuardedRewards,
     rewardsV1,
     missedTokeRewards
-  } = (0, import_config5.getMainnetConfig)(import_chains4.mainnet.id);
+  } = config.getMainnetConfig(chains.mainnet.id);
   try {
-    const userStakedTokeV1 = await (0, import_core5.readContract)(wagmiConfig, {
+    const userStakedTokeV1 = await core.readContract(wagmiConfig, {
       address: stakingV1,
-      abi: import_abis5.stakingV1Abi,
+      abi: abis.stakingV1Abi,
       functionName: "availableForWithdrawal",
       args: [address, 0n],
-      chainId: import_chains4.mainnet.id
+      chainId: chains.mainnet.id
     });
     const tokeRewards = await getUserRewardsV1(wagmiConfig, {
       address,
@@ -4737,9 +6280,9 @@ var getUserV1 = async (wagmiConfig, {
     const cycle = autoEthGuardedRewardsPayload?.payload?.cycle;
     const wallet = autoEthGuardedRewardsPayload?.payload?.wallet;
     const amount = autoEthGuardedRewardsPayload?.payload?.amount;
-    const claimableAutoEth = await (0, import_core5.readContract)(wagmiConfig, {
+    const claimableAutoEth = await core.readContract(wagmiConfig, {
       address: autoEthGuardedRewards,
-      abi: import_abis5.rewardsV1Abi,
+      abi: abis.rewardsV1Abi,
       functionName: "getClaimableAmount",
       args: [
         {
@@ -4761,9 +6304,9 @@ var getUserV1 = async (wagmiConfig, {
       const {
         payload: { chainId: payloadChainId2, cycle: cycle2, wallet: wallet2, amount: amount2 }
       } = missedTokeRewardsPayload;
-      claimableMissedToke = await (0, import_core5.readContract)(wagmiConfig, {
+      claimableMissedToke = await core.readContract(wagmiConfig, {
         address: missedTokeRewards,
-        abi: import_abis5.rewardsV1Abi,
+        abi: abis.rewardsV1Abi,
         functionName: "getClaimableAmount",
         args: [
           {
@@ -4790,14 +6333,11 @@ var getUserV1 = async (wagmiConfig, {
   } catch (e) {
   }
 };
-
-// functions/getChainUserAutopoolsHistory.tsx
-var import_graph_cli6 = require("@tokemak/graph-cli");
 var getChainUserAutopoolsHistory = async ({
   address,
   chainId = 1
 }) => {
-  const { GetUserVaultsDayData } = (0, import_graph_cli6.getSdkByChainId)(chainId);
+  const { GetUserVaultsDayData } = graphCli.getSdkByChainId(chainId);
   const oneYearAgoTimestamp = Math.floor(Date.now() / 1e3) - 365 * 24 * 60 * 60;
   try {
     if (address) {
@@ -4813,26 +6353,17 @@ var getChainUserAutopoolsHistory = async ({
     return [];
   }
 };
-
-// functions/getUserAutopoolsHistory.ts
-var import_utils14 = require("@tokemak/utils");
-
-// functions/getTokenValueDayDatas.ts
-var import_chains5 = require("viem/chains");
-var import_utils11 = require("@tokemak/utils");
-var import_viem6 = require("viem");
-var import_graph_cli7 = require("@tokemak/graph-cli");
-var getTokenValueDayDatas = async (tokenAddress, chainId = import_chains5.mainnet.id) => {
-  const { GetTokenValueDayDatas } = (0, import_graph_cli7.getSdkByChainId)(chainId);
+var getTokenValueDayDatas = async (tokenAddress, chainId = chains.mainnet.id) => {
+  const { GetTokenValueDayDatas } = graphCli.getSdkByChainId(chainId);
   try {
     const { tokenValueDayDatas } = await GetTokenValueDayDatas({
       tokenAddress: tokenAddress.toLowerCase()
     });
     const historicalPrice = tokenValueDayDatas.map((tokenValueDayData) => {
-      const date = (0, import_utils11.convertTimestampToDate)(
+      const date = utils.convertTimestampToDate(
         tokenValueDayData.lastSnapshotTimestamp
       );
-      const usdPrice = (0, import_viem6.formatUnits)(tokenValueDayData.priceInUsd, 8);
+      const usdPrice = viem.formatUnits(tokenValueDayData.priceInUsd, 8);
       return {
         timestamp: Number(tokenValueDayData.lastSnapshotTimestamp),
         date,
@@ -4845,10 +6376,6 @@ var getTokenValueDayDatas = async (tokenAddress, chainId = import_chains5.mainne
   }
 };
 
-// functions/getTokenPrices.ts
-var import_tokenlist4 = require("@tokemak/tokenlist");
-var import_constants6 = require("@tokemak/constants");
-
 // functions/getBackupTokenPrices.ts
 var getBackupTokenPrices = async () => {
   try {
@@ -4865,26 +6392,26 @@ var getBackupTokenPrices = async () => {
 
 // functions/getTokenPrices.ts
 var BASE_ASSETS = [
-  { ...import_tokenlist4.ETH_TOKEN, symbol: "ETH", coinGeckoId: "ethereum" },
-  { ...import_tokenlist4.PXETH_TOKEN, symbol: "PXETH", coinGeckoId: "dinero-staked-eth" },
-  { ...import_tokenlist4.USDC_TOKEN, symbol: "USDC", coinGeckoId: "usd-coin" },
-  { ...import_tokenlist4.DOLA_TOKEN, symbol: "DOLA", coinGeckoId: "dola-usd" },
-  { ...import_tokenlist4.S_TOKEN, symbol: "S" },
-  { ...import_tokenlist4.EURC_TOKEN, symbol: "EURC", coinGeckoId: "euro-coin" },
-  { ...import_tokenlist4.USDT_TOKEN, symbol: "USDT", coinGeckoId: "tether" },
-  { ...import_tokenlist4.USDT0_TOKEN, symbol: "USDT0", coinGeckoId: "tether" }
+  { ...tokenlist.ETH_TOKEN, symbol: "ETH", coinGeckoId: "ethereum" },
+  { ...tokenlist.PXETH_TOKEN, symbol: "PXETH", coinGeckoId: "dinero-staked-eth" },
+  { ...tokenlist.USDC_TOKEN, symbol: "USDC", coinGeckoId: "usd-coin" },
+  { ...tokenlist.DOLA_TOKEN, symbol: "DOLA", coinGeckoId: "dola-usd" },
+  { ...tokenlist.S_TOKEN, symbol: "S" },
+  { ...tokenlist.EURC_TOKEN, symbol: "EURC", coinGeckoId: "euro-coin" },
+  { ...tokenlist.USDT_TOKEN, symbol: "USDT", coinGeckoId: "tether" },
+  { ...tokenlist.USDT0_TOKEN, symbol: "USDT0", coinGeckoId: "tether" }
 ];
 var PRICED_TOKENS = [
   ...BASE_ASSETS,
-  { ...import_tokenlist4.TOKE_TOKEN, symbol: "TOKE" },
-  { ...import_tokenlist4.SILO_TOKEN, symbol: "SILO" },
-  { ...import_tokenlist4.XPL_TOKEN, address: import_tokenlist4.WXPL_TOKEN.address, symbol: "XPL" },
-  { ...import_tokenlist4.USDT0_TOKEN, symbol: "USDT0" }
+  { ...tokenlist.TOKE_TOKEN, symbol: "TOKE" },
+  { ...tokenlist.SILO_TOKEN, symbol: "SILO" },
+  { ...tokenlist.XPL_TOKEN, address: tokenlist.WXPL_TOKEN.address, symbol: "XPL" },
+  { ...tokenlist.USDT0_TOKEN, symbol: "USDT0" }
 ];
-var WRAPPED_TOKENS = [
-  { ...import_tokenlist4.WETH_TOKEN, symbol: "WETH" },
-  { ...import_tokenlist4.WS_TOKEN, symbol: "WS" },
-  { ...import_tokenlist4.WXPL_TOKEN, symbol: "WXPL" }
+[
+  { ...tokenlist.WETH_TOKEN, symbol: "WETH" },
+  { ...tokenlist.WS_TOKEN, symbol: "WS" },
+  { ...tokenlist.WXPL_TOKEN, symbol: "WXPL" }
 ];
 var isStale = (timestamp) => {
   return timestamp - Math.floor(Date.now() / 1e3) > 5 * 60;
@@ -4899,7 +6426,7 @@ var getTokenPrices = async (isCronJob = false) => {
         timeoutMS: 5 * 1e3
       }))
     };
-    const response = await fetch(`${import_constants6.TOKEMAK_PRICES_STAGING_URL}`, {
+    const response = await fetch(`${constants.TOKEMAK_PRICES_STAGING_URL}`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
@@ -4949,9 +6476,6 @@ var getTokenPrices = async (isCronJob = false) => {
     }
   }
 };
-
-// functions/getHistoricalTokenPrices.ts
-var import_tokenlist5 = require("@tokemak/tokenlist");
 var hasCoinGeckoId = (asset) => typeof asset?.coinGeckoId === "string" && asset.coinGeckoId.length > 0;
 var getBlobHistoricalTokenPrices = async (tokenSymbol) => {
   const blobName = `historical_v2/${tokenSymbol}-latest-success.json`;
@@ -4969,7 +6493,7 @@ var getHistoricalTokenPrices = async () => {
   const historicalBaseAssetPrices = await Promise.all(
     BASE_ASSETS.map(async (baseAsset) => {
       if (!hasCoinGeckoId(baseAsset)) {
-        const address = baseAsset.address === import_tokenlist5.ETH_TOKEN.address ? ETH_ADDRESS_IN_SUBGRAPH : baseAsset.address;
+        const address = baseAsset.address === tokenlist.ETH_TOKEN.address ? ETH_ADDRESS_IN_SUBGRAPH : baseAsset.address;
         const prices2 = await getTokenValueDayDatas(
           address,
           baseAsset.chainId
@@ -5097,7 +6621,7 @@ var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeT
               Math.floor(sharesRatio * Number(SCALE))
             );
             const navBigInt = sharesRatioBigInt * BigInt(dayData.nav) / SCALE;
-            const navNum = (0, import_utils14.formatUnitsNum)(
+            const navNum = utils.formatUnitsNum(
               navBigInt,
               dayData.baseAsset.decimals
             );
@@ -5168,7 +6692,7 @@ var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeT
   let finalAggregatedHistoryArray = Object.keys(aggregatedHistoryArray).map(
     (dateKey) => ({
       date: aggregatedHistoryArray[dateKey].date,
-      formattedDate: (0, import_utils14.formatDateToReadable)(aggregatedHistoryArray[dateKey].date),
+      formattedDate: utils.formatDateToReadable(aggregatedHistoryArray[dateKey].date),
       nav: {
         ETH: aggregatedHistoryArray[dateKey].nav.ETH,
         USD: aggregatedHistoryArray[dateKey].nav.USD,
@@ -5203,7 +6727,7 @@ var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeT
         return eventDate.getTime() >= dayData.date.getTime() && eventDate.getTime() < dayData.date.getTime() + 24 * 60 * 60 * 1e3;
       });
       const differential = eventsForDay.reduce(
-        (sum, event) => sum + (0, import_utils14.formatEtherNum)(BigInt(event?.assetChange || 0n)),
+        (sum, event) => sum + utils.formatEtherNum(BigInt(event?.assetChange || 0n)),
         0
       );
       return {
@@ -5222,11 +6746,6 @@ var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeT
   }
   return result;
 };
-
-// functions/getUserSushiLP.ts
-var import_core6 = require("@wagmi/core");
-var import_abis6 = require("@tokemak/abis");
-var import_config6 = require("@tokemak/config");
 var getUserSushiLP = async (wagmiConfig, {
   sushiLP,
   currentCycleIndex,
@@ -5234,32 +6753,32 @@ var getUserSushiLP = async (wagmiConfig, {
   cycleRolloverBlockNumber,
   chainId
 }) => {
-  const { tSushiLP, sushiPool } = (0, import_config6.getMainnetConfig)();
+  const { tSushiLP, sushiPool } = config.getMainnetConfig();
   try {
     if (address && currentCycleIndex && sushiLP) {
       const [
         { result: sushiLPBalance },
         { result: tSushiLPBalance },
         { result: tSushiLPRequested }
-      ] = await (0, import_core6.readContracts)(wagmiConfig, {
+      ] = await core.readContracts(wagmiConfig, {
         contracts: [
           {
             address: sushiPool,
-            abi: import_abis6.sushiPoolAbi,
+            abi: abis.sushiPoolAbi,
             functionName: "balanceOf",
             args: [address],
             chainId
           },
           {
             address: tSushiLP,
-            abi: import_abis6.poolV1Abi,
+            abi: abis.poolV1Abi,
             functionName: "balanceOf",
             args: [address],
             chainId
           },
           {
             address: tSushiLP,
-            abi: import_abis6.poolV1Abi,
+            abi: abis.poolV1Abi,
             functionName: "requestedWithdrawals",
             args: [address],
             chainId
@@ -5269,18 +6788,18 @@ var getUserSushiLP = async (wagmiConfig, {
       const [
         { result: startTSushiLPBalance },
         { result: startTSushiLPRequested }
-      ] = await (0, import_core6.readContracts)(wagmiConfig, {
+      ] = await core.readContracts(wagmiConfig, {
         contracts: [
           {
             address: tSushiLP,
-            abi: import_abis6.poolV1Abi,
+            abi: abis.poolV1Abi,
             functionName: "balanceOf",
             args: [address],
             chainId
           },
           {
             address: tSushiLP,
-            abi: import_abis6.poolV1Abi,
+            abi: abis.poolV1Abi,
             functionName: "requestedWithdrawals",
             args: [address],
             chainId
@@ -5321,31 +6840,26 @@ var getUserSushiLP = async (wagmiConfig, {
     console.log(e);
   }
 };
-
-// functions/getUserCurveLP.ts
-var import_core7 = require("@wagmi/core");
-var import_abis7 = require("@tokemak/abis");
-var import_config7 = require("@tokemak/config");
 var getUserCurveLP = async (wagmiConfig, {
   curveLP,
   address,
   chainId
 }) => {
   try {
-    const { curvePool, convexRewarder } = (0, import_config7.getMainnetConfig)();
+    const { curvePool, convexRewarder } = config.getMainnetConfig();
     if (address && curveLP && curvePool && convexRewarder) {
-      const [{ result: userCurveLPBalance }, { result: userConvexLPBalance }] = await (0, import_core7.readContracts)(wagmiConfig, {
+      const [{ result: userCurveLPBalance }, { result: userConvexLPBalance }] = await core.readContracts(wagmiConfig, {
         contracts: [
           {
             address: curvePool,
-            abi: import_abis7.poolV1Abi,
+            abi: abis.poolV1Abi,
             functionName: "balanceOf",
             args: [address],
             chainId
           },
           {
             address: convexRewarder,
-            abi: import_abis7.poolV1Abi,
+            abi: abis.poolV1Abi,
             functionName: "balanceOf",
             args: [address],
             chainId
@@ -5369,26 +6883,17 @@ var getUserCurveLP = async (wagmiConfig, {
     console.log(e);
   }
 };
-
-// functions/getMultipleAutopoolRebalances.ts
-var import_graph_cli8 = require("@tokemak/graph-cli");
 var getMutlipleAutopoolRebalances = async (ids, chainId = 1) => {
-  const { GetMutlipleAutopoolRebalances } = (0, import_graph_cli8.getSdkByChainId)(chainId);
+  const { GetMutlipleAutopoolRebalances } = graphCli.getSdkByChainId(chainId);
   const { autopools } = await GetMutlipleAutopoolRebalances({
     addresses: ids
   });
   const rebalances = autopools.map(({ rebalances: rebalances2 }) => rebalances2);
   return rebalances.flat().sort((a, b) => b.timestamp - a.timestamp);
 };
-
-// functions/getAutopoolDayData.ts
-var import_viem7 = require("viem");
-var import_utils16 = require("@tokemak/utils");
-var import_constants7 = require("@tokemak/constants");
-var import_graph_cli9 = require("@tokemak/graph-cli");
-var getAutopoolDayData = async (address, chainId = 1, startTimestamp = import_constants7.TOKEMAK_LAUNCH_TIMESTAMP) => {
+var getAutopoolDayData = async (address, chainId = 1, startTimestamp = constants.TOKEMAK_LAUNCH_TIMESTAMP) => {
   try {
-    const { GetAutopoolDayData } = (0, import_graph_cli9.getSdkByChainId)(chainId);
+    const { GetAutopoolDayData } = graphCli.getSdkByChainId(chainId);
     const { autopoolDayDatas } = await GetAutopoolDayData({
       address,
       timestamp: startTimestamp
@@ -5397,10 +6902,10 @@ var getAutopoolDayData = async (address, chainId = 1, startTimestamp = import_co
       const navPerShare = autoPoolDayData.nav / autoPoolDayData.totalSupply;
       let baseApy = autoPoolDayData.autopoolApy;
       let rewarderApy = 0;
-      const formattedRewarder7DayMAApy = (0, import_utils16.formatEtherNum)(
+      const formattedRewarder7DayMAApy = utils.formatEtherNum(
         BigInt(Number(autoPoolDayData.rewarderDay7MAApy) || 0)
       );
-      const formattedRewarder30DayMAApy = (0, import_utils16.formatEtherNum)(
+      const formattedRewarder30DayMAApy = utils.formatEtherNum(
         BigInt(Number(autoPoolDayData.rewarderDay30MAApy) || 0)
       );
       if (formattedRewarder7DayMAApy) {
@@ -5413,7 +6918,7 @@ var getAutopoolDayData = async (address, chainId = 1, startTimestamp = import_co
         baseApy = 0;
       } else {
         baseApy = Number(
-          (0, import_viem7.formatUnits)(BigInt(baseApy), autoPoolDayData.baseAsset.decimals)
+          viem.formatUnits(BigInt(baseApy), autoPoolDayData.baseAsset.decimals)
         );
       }
       if (baseApy < 0) {
@@ -5436,10 +6941,6 @@ var getAutopoolDayData = async (address, chainId = 1, startTimestamp = import_co
     return [];
   }
 };
-
-// functions/getSystemConfig.ts
-var import_core8 = require("@wagmi/core");
-var import_abis8 = require("@tokemak/abis");
 var systemRegistryFunctionNames = [
   "asyncSwapperRegistry",
   "autoPoolRouter",
@@ -5450,7 +6951,7 @@ var systemRegistryFunctionNames = [
 var getSystemConfig = async (wagmiConfig, { systemRegistry }) => {
   const systemRegistryContract = {
     address: systemRegistry,
-    abi: import_abis8.systemRegistryAbi
+    abi: abis.systemRegistryAbi
   };
   const systemRegistryCalls = systemRegistryFunctionNames.map(
     (functionName) => ({
@@ -5464,7 +6965,7 @@ var getSystemConfig = async (wagmiConfig, { systemRegistry }) => {
       { result: autopoolRouter },
       { result: autopoolRegistry },
       { result: swapRouter }
-    ] = await (0, import_core8.readContracts)(wagmiConfig, {
+    ] = await core.readContracts(wagmiConfig, {
       contracts: systemRegistryCalls
     });
     return {
@@ -5477,14 +6978,11 @@ var getSystemConfig = async (wagmiConfig, { systemRegistry }) => {
     console.log(e);
   }
 };
-
-// functions/getChainUserAutopools.tsx
-var import_graph_cli10 = require("@tokemak/graph-cli");
 var getChainUserAutopools = async ({
   address,
   chainId = 1
 }) => {
-  const { GetUserVaultInfo } = (0, import_graph_cli10.getSdkByChainId)(chainId);
+  const { GetUserVaultInfo } = graphCli.getSdkByChainId(chainId);
   try {
     if (address) {
       const { userInfo } = await GetUserVaultInfo({
@@ -5498,16 +6996,6 @@ var getChainUserAutopools = async ({
     return [];
   }
 };
-
-// functions/getUserAutopools.ts
-var import_utils18 = require("@tokemak/utils");
-var import_tokenlist6 = require("@tokemak/tokenlist");
-
-// functions/getUserAutopool.tsx
-var import_viem8 = require("viem");
-var import_core9 = require("@wagmi/core");
-var import_utils17 = require("@tokemak/utils");
-var import_abis9 = require("@tokemak/abis");
 var getUserAutopool = async (wagmiConfig, {
   address,
   autopool
@@ -5516,14 +7004,14 @@ var getUserAutopool = async (wagmiConfig, {
     if (autopool && address) {
       const autopoolContract = {
         address: autopool?.poolAddress,
-        abi: import_abis9.autopoolEthAbi,
+        abi: abis.autopoolEthAbi,
         chainId: autopool?.chain?.chainId
       };
       const [
         { result: autopoolRewarderContract },
         { result: pastRewarders },
         { result: unstakedPoolShares, error: unstakedPoolSharesError }
-      ] = await (0, import_core9.readContracts)(wagmiConfig, {
+      ] = await core.readContracts(wagmiConfig, {
         contracts: [
           {
             ...autopoolContract,
@@ -5548,17 +7036,17 @@ var getUserAutopool = async (wagmiConfig, {
       if (unstakedPoolSharesError) {
         throw new Error("Error fetching unstaked pool shares");
       }
-      const stakedPoolShares = await (0, import_core9.readContract)(wagmiConfig, {
+      const stakedPoolShares = await core.readContract(wagmiConfig, {
         address: autopoolRewarderContract,
-        abi: import_viem8.erc20Abi,
+        abi: viem.erc20Abi,
         functionName: "balanceOf",
         args: [address],
         chainId: autopool?.chain?.chainId
       });
-      const stakedShares = (0, import_utils17.formatEtherNum)(stakedPoolShares);
+      const stakedShares = utils.formatEtherNum(stakedPoolShares);
       const stakedNav = stakedShares * (autopool?.navPerShare.baseAsset || 0);
       const stakedNavUsd = stakedShares * (autopool?.navPerShare.USD || 0);
-      const unstakedShares = (0, import_utils17.formatEtherNum)(unstakedPoolShares || 0n);
+      const unstakedShares = utils.formatEtherNum(unstakedPoolShares || 0n);
       const unstakedNav = unstakedShares * (autopool?.navPerShare.USD || 0);
       const unstakedNavUsd = unstakedShares * (autopool?.navPerShare.USD || 0);
       const totalShares = unstakedShares + stakedShares;
@@ -5569,17 +7057,17 @@ var getUserAutopool = async (wagmiConfig, {
       if (pastRewarders && pastRewarders?.length > 0) {
         const pastRewardBalances = pastRewarders.map((rewarder) => ({
           address: rewarder,
-          abi: import_viem8.erc20Abi,
+          abi: viem.erc20Abi,
           functionName: "balanceOf",
           args: [address],
           chainId: autopool?.chain?.chainId
         }));
-        const pastRewards = await (0, import_core9.readContracts)(wagmiConfig, {
+        const pastRewards = await core.readContracts(wagmiConfig, {
           contracts: pastRewardBalances
         });
         pastRewarderBalances = pastRewards.map(({ result }, index) => {
           const balance = result;
-          const shares = (0, import_utils17.formatEtherNum)(result);
+          const shares = utils.formatEtherNum(result);
           const nav = shares * (autopool?.navPerShare.baseAsset || 0);
           const navUsd = shares * (autopool?.navPerShare.USD || 0);
           return {
@@ -5697,14 +7185,14 @@ var getUserAutopools = async ({
         );
         if (autopoolData) {
           const isDOLA = autopoolData.symbol === "autoDOLA" && userAutoDOLA;
-          const userShares = isDOLA ? userAutoDOLA?.totalShares : (0, import_utils18.formatEtherNum)(userAutopool?.totalShares);
-          const totalVaultShares = (0, import_utils18.formatEtherNum)(autopoolData?.totalSupply);
+          const userShares = isDOLA ? userAutoDOLA?.totalShares : utils.formatEtherNum(userAutopool?.totalShares);
+          const totalVaultShares = utils.formatEtherNum(autopoolData?.totalSupply);
           const userShareOfVault = userShares / totalVaultShares;
-          const totalDeposits = (0, import_utils18.formatUnitsNum)(
+          const totalDeposits = utils.formatUnitsNum(
             userActivity?.totals[userAutopool.vaultAddress]?.totalDeposits || 0n,
             autopoolData?.baseAsset.decimals
           );
-          const totalWithdrawals = (0, import_utils18.formatUnitsNum)(
+          const totalWithdrawals = utils.formatUnitsNum(
             userActivity?.totals[userAutopool.vaultAddress]?.totalWithdrawals || 0n,
             autopoolData?.baseAsset.decimals
           );
@@ -5713,7 +7201,7 @@ var getUserAutopools = async ({
           );
           let lastDeposit;
           if (poolEvents && poolEvents?.length > 0) {
-            lastDeposit = (0, import_utils18.convertTimestampToDate)(
+            lastDeposit = utils.convertTimestampToDate(
               poolEvents[poolEvents.length - 1].timestamp
             ).toLocaleDateString("en-US", {
               day: "2-digit",
@@ -5813,7 +7301,7 @@ var getUserAutopools = async ({
             totalWithdrawals: prev.totalWithdrawals + totalWithdrawals
           };
           const stakedBalance = isDOLA ? userAutoDOLA?.staked.balance : BigInt(userAutopool?.stakedShares);
-          const stakedShares = isDOLA ? userAutoDOLA?.staked.shares : (0, import_utils18.formatEtherNum)(stakedBalance);
+          const stakedShares = isDOLA ? userAutoDOLA?.staked.shares : utils.formatEtherNum(stakedBalance);
           const stakedNav = stakedShares * (autopoolData?.navPerShare.baseAsset || 0);
           const staked = convertBaseAssetToTokenPrices(
             stakedNav,
@@ -5821,7 +7309,7 @@ var getUserAutopools = async ({
             prices
           );
           const unstakedBalance = isDOLA ? userAutoDOLA?.unstaked.balance : BigInt(userAutopool?.walletShares);
-          const unstakedShares = isDOLA ? userAutoDOLA?.unstaked.shares : (0, import_utils18.formatEtherNum)(unstakedBalance);
+          const unstakedShares = isDOLA ? userAutoDOLA?.unstaked.shares : utils.formatEtherNum(unstakedBalance);
           const unstakedNav = unstakedShares * (autopoolData?.navPerShare.baseAsset || 0);
           const unstaked = convertBaseAssetToTokenPrices(
             unstakedNav,
@@ -5866,7 +7354,7 @@ var getUserAutopools = async ({
           };
         }
       });
-      let denominatedToken = import_tokenlist6.ETH_TOKEN;
+      let denominatedToken = tokenlist.ETH_TOKEN;
       const useDenomination = userAutopoolsWithData.filter((autopool) => autopool?.useDenomination).length === 1 && userAutopoolsWithData.length === 1;
       if (useDenomination) {
         const autopoolWithDenomination = userAutopoolsWithData.find(
@@ -6018,17 +7506,13 @@ var getUserAutopools = async ({
     console.log(e);
   }
 };
-
-// functions/getUserTokenBalances.ts
-var import_viem9 = require("viem");
-var import_chains6 = require("viem/chains");
 var networkToAlchemyUrl = (chainId, apiKey) => {
   switch (chainId) {
-    case import_chains6.mainnet.id:
+    case chains.mainnet.id:
       return `https://eth-mainnet.g.alchemy.com/v2/${apiKey}`;
-    case import_chains6.base.id:
+    case chains.base.id:
       return `https://base-mainnet.g.alchemy.com/v2/${apiKey}`;
-    case import_chains6.sonic.id:
+    case chains.sonic.id:
       return `https://sonic-mainnet.g.alchemy.com/v2/${apiKey}`;
     default:
       throw new Error("Unsupported network");
@@ -6064,7 +7548,7 @@ var getUserTokenBalances = async ({
   const tokenBalances = data.result.tokenBalances.reduce(
     (acc, balance) => {
       if (balance.tokenBalance && BigInt(balance.tokenBalance) !== BigInt(0)) {
-        acc[balance.contractAddress] = (0, import_viem9.hexToBigInt)(
+        acc[balance.contractAddress] = viem.hexToBigInt(
           balance.tokenBalance
         );
       }
@@ -6074,12 +7558,9 @@ var getUserTokenBalances = async ({
   );
   return tokenBalances;
 };
-
-// functions/getTokenList.ts
-var import_tokenlist7 = require("@tokemak/tokenlist");
 var getTokenList = async () => {
   try {
-    let url = `${import_tokenlist7.TOKEMAK_LISTS_URL}/swap_enabled.json`;
+    let url = `${tokenlist.TOKEMAK_LISTS_URL}/swap_enabled.json`;
     const listResponse = await fetch(url);
     const { tokens: tokenList } = await listResponse.json();
     return tokenList;
@@ -6088,12 +7569,9 @@ var getTokenList = async () => {
     return [];
   }
 };
-
-// functions/getTopAutopoolHolders.ts
-var import_graph_cli11 = require("@tokemak/graph-cli");
 var getTopAutopoolHolders = async (autopoolAddress, chainId = 1) => {
   try {
-    const { GetTopAutopoolHolders } = (0, import_graph_cli11.getSdkByChainId)(chainId);
+    const { GetTopAutopoolHolders } = graphCli.getSdkByChainId(chainId);
     const { holders } = await GetTopAutopoolHolders({
       address: autopoolAddress
     });
@@ -6103,19 +7581,15 @@ var getTopAutopoolHolders = async (autopoolAddress, chainId = 1) => {
     return [];
   }
 };
-
-// functions/getAllowance.ts
-var import_core10 = require("@wagmi/core");
-var import_viem10 = require("viem");
 var getAllowance = async (wagmiConfig, {
   token,
   address,
   spender
 }) => {
   try {
-    const allowance = await (0, import_core10.readContract)(wagmiConfig, {
+    const allowance = await core.readContract(wagmiConfig, {
       address: token,
-      abi: import_viem10.erc20Abi,
+      abi: viem.erc20Abi,
       functionName: "allowance",
       args: [address || "0x0", spender]
     });
@@ -6154,23 +7628,15 @@ var getUserActivity = async ({
   mergedActivity.events.sort((a, b) => a.timestamp - b.timestamp);
   return mergedActivity;
 };
-
-// functions/getUserAutopoolsRewards.ts
-var import_viem11 = require("viem");
-
-// functions/getChainUserAutopoolsRewards.ts
-var import_config8 = require("@tokemak/config");
-var import_core11 = require("@wagmi/core");
-var import_abis10 = require("@tokemak/abis");
 var getChainUserAutopoolsRewards = async (wagmiConfig, {
   chainId,
   address
 }) => {
   try {
-    const coreConfig = (0, import_config8.getCoreConfig)(chainId);
-    const userRewardsInfo = await (0, import_core11.readContract)(wagmiConfig, {
+    const coreConfig = config.getCoreConfig(chainId);
+    const userRewardsInfo = await core.readContract(wagmiConfig, {
       address: coreConfig.lens,
-      abi: import_abis10.lensAbi,
+      abi: abis.lensAbi,
       functionName: "getUserRewardInfo",
       args: [address],
       chainId: coreConfig.id
@@ -6198,55 +7664,50 @@ var getChainUserAutopoolsRewards = async (wagmiConfig, {
     console.log(e);
   }
 };
-
-// functions/getUserAutopoolsRewards.ts
-var import_utils22 = require("@tokemak/utils");
-var import_tokenlist8 = require("@tokemak/tokenlist");
-var import_chains7 = require("viem/chains");
 var getUserAutopoolsRewards = async (wagmiConfig, {
   address,
   tokenPrices,
   autopools,
   includeTestnet = false
 }) => {
-  const chains = getChainsForEnv({ includeTestnet });
+  const chains$1 = getChainsForEnv({ includeTestnet });
   try {
     if (!autopools)
       throw new Error("No autopools found");
     const userRewards = await Promise.all(
-      chains.map(
+      chains$1.map(
         (chain) => getChainUserAutopoolsRewards(wagmiConfig, {
           chainId: chain.chainId,
           address
         })
       )
     );
-    const rewardsData = chains.map(({ chainId }, index) => {
+    const rewardsData = chains$1.map(({ chainId }, index) => {
       const chainUserRewards = userRewards[index] || {};
       const extraRewardsArray = Object.entries(chainUserRewards).flatMap(
         ([autopoolAddress, rewards]) => {
           const autopool = autopools.find(
-            (autopool2) => (0, import_viem11.getAddress)(autopool2.poolAddress) === (0, import_viem11.getAddress)(autopoolAddress)
+            (autopool2) => viem.getAddress(autopool2.poolAddress) === viem.getAddress(autopoolAddress)
           );
           if (!autopool || !autopool.extraRewarders) {
             return [];
           }
           return autopool.extraRewarders.map((extraRewards2) => {
-            const rewarderToken = (0, import_utils22.getToken)(
+            const rewarderToken = utils.getToken(
               extraRewards2.rewardToken?.id,
               autopool.chain?.chainId
             );
-            const claimableAmount = rewards ? rewards[(0, import_viem11.getAddress)(extraRewards2.rewardToken?.id)] : 0n;
+            const claimableAmount = rewards ? rewards[viem.getAddress(extraRewards2.rewardToken?.id)] : 0n;
             let price = tokenPrices[rewarderToken.symbol] || 0;
             if (rewarderToken.symbol === "XSILO") {
-              price = tokenPrices[import_tokenlist8.SILO_TOKEN.symbol] || 0;
+              price = tokenPrices[tokenlist.SILO_TOKEN.symbol] || 0;
             }
-            const formattedAmount = (0, import_utils22.formatUnitsNum)(
+            const formattedAmount = utils.formatUnitsNum(
               claimableAmount,
               rewarderToken.decimals || 18
             );
             return {
-              address: (0, import_viem11.getAddress)(extraRewards2?.id),
+              address: viem.getAddress(extraRewards2?.id),
               chainId,
               token: rewarderToken,
               amount: claimableAmount,
@@ -6259,7 +7720,7 @@ var getUserAutopoolsRewards = async (wagmiConfig, {
       const tokenRewards = {};
       Object.values(chainUserRewards).forEach((autopoolRewards) => {
         Object.entries(autopoolRewards).forEach(([tokenAddress, amount]) => {
-          const token = (0, import_utils22.getToken)(tokenAddress, chainId);
+          const token = utils.getToken(tokenAddress, chainId);
           const tokenSymbol = token.symbol;
           if (!tokenRewards[tokenSymbol]) {
             tokenRewards[tokenSymbol] = {
@@ -6277,9 +7738,9 @@ var getUserAutopoolsRewards = async (wagmiConfig, {
         ([tokenSymbol, { amount, decimals }]) => {
           let price = tokenPrices[tokenSymbol] || 0;
           if (tokenSymbol === "XSILO") {
-            price = tokenPrices[import_tokenlist8.SILO_TOKEN.symbol] || 0;
+            price = tokenPrices[tokenlist.SILO_TOKEN.symbol] || 0;
           }
-          const formattedAmount = (0, import_utils22.formatUnitsNum)(amount, decimals || 18);
+          const formattedAmount = utils.formatUnitsNum(amount, decimals || 18);
           tokenRewards[tokenSymbol] = {
             amount,
             formattedAmount,
@@ -6288,13 +7749,13 @@ var getUserAutopoolsRewards = async (wagmiConfig, {
           };
         }
       );
-      if (Object.keys(tokenRewards).includes("undefined") && chainId === import_chains7.plasma.id) {
+      if (Object.keys(tokenRewards).includes("undefined") && chainId === chains.plasma.id) {
         const undefinedToken = tokenRewards["undefined"];
         let price = tokenPrices.TOKE || 0;
         tokenRewards["TOKE"] = {
           ...undefinedToken,
           USD: undefinedToken.formattedAmount * price,
-          logoURI: import_tokenlist8.TOKE_TOKEN.logoURI
+          logoURI: tokenlist.TOKE_TOKEN.logoURI
         };
         delete tokenRewards["undefined"];
       }
@@ -6347,26 +7808,14 @@ var getUserAutopoolsRewards = async (wagmiConfig, {
     console.error(e);
   }
 };
-
-// functions/getAmountWithdrawn.ts
-var import_viem13 = require("viem");
-var import_utils24 = require("@tokemak/utils");
-
-// functions/getSwapQuote.ts
-var import_constants8 = require("@tokemak/constants");
-
-// functions/getAddressFromSystemRegistry.ts
-var import_core12 = require("@wagmi/core");
-var import_config9 = require("@tokemak/config");
-var import_abis11 = require("@tokemak/abis");
 var getAddressFromSystemRegistry = async (wagmiConfig, {
   chainId,
   functionName
 }) => {
-  const { systemRegistry } = (0, import_config9.getCoreConfig)(chainId);
-  return await (0, import_core12.readContract)(wagmiConfig, {
+  const { systemRegistry } = config.getCoreConfig(chainId);
+  return await core.readContract(wagmiConfig, {
     address: systemRegistry,
-    abi: import_abis11.systemRegistryAbi,
+    abi: abis.systemRegistryAbi,
     functionName,
     chainId
   });
@@ -6377,28 +7826,23 @@ var getAutopilotRouter = async (wagmiConfig, { chainId }) => await getAddressFro
   chainId,
   functionName: "autoPoolRouter"
 });
-
-// functions/getSwapQuote.ts
-var import_config10 = require("@tokemak/config");
-var import_tokenlist9 = require("@tokemak/tokenlist");
-var import_chains8 = require("viem/chains");
-var getSwapQuote = async (config, { chainId, ...params }) => {
+var getSwapQuote = async (config$1, { chainId, ...params }) => {
   try {
     if (!params.sellToken || !params.buyToken) {
       throw new Error("Sell token and buy token are required");
     }
-    if (params.sellToken === import_tokenlist9.ETH_TOKEN.address) {
-      params.sellToken = (0, import_config10.getCoreConfig)(chainId).weth;
-      if (chainId === import_chains8.sonic.id) {
-        params.sellToken = import_tokenlist9.WS_TOKEN.address;
+    if (params.sellToken === tokenlist.ETH_TOKEN.address) {
+      params.sellToken = config.getCoreConfig(chainId).weth;
+      if (chainId === chains.sonic.id) {
+        params.sellToken = tokenlist.WS_TOKEN.address;
       }
-      if (chainId === import_chains8.plasma.id) {
-        params.sellToken = import_tokenlist9.WXPL_TOKEN.address;
+      if (chainId === chains.plasma.id) {
+        params.sellToken = tokenlist.WXPL_TOKEN.address;
       }
     }
     const sellAmount = params.sellAmount.toString();
-    const taker = await getAutopilotRouter(config, { chainId });
-    const response = await fetch(import_constants8.TOKEMAK_SWAP_QUOTE_URL, {
+    const taker = await getAutopilotRouter(config$1, { chainId });
+    const response = await fetch(constants.TOKEMAK_SWAP_QUOTE_URL, {
       method: "POST",
       headers: {
         "Content-Type": "application/json"
@@ -6422,20 +7866,12 @@ var getSwapQuote = async (config, { chainId, ...params }) => {
     return void 0;
   }
 };
-
-// functions/getDynamicSwap.ts
-var import_core13 = require("@wagmi/core");
-var import_abis12 = require("@tokemak/abis");
-var import_config11 = require("@tokemak/config");
-var import_autopilot_swap_route_calc = require("@tokemak/autopilot-swap-route-calc");
-var import_viem12 = require("viem");
-var import_constants9 = require("@tokemak/constants");
 var placeholderAddress = "0x8b4334d4812c530574bd4f2763fcd22de94a969b";
 var getDynamicSwap = async ({
   address,
   amount,
   chainId,
-  config,
+  config: config$1,
   slippage,
   user
 }) => {
@@ -6443,12 +7879,12 @@ var getDynamicSwap = async ({
   let previewRedeem = 0n;
   let dynamicSwaps;
   let standardPreviewRedeem = false;
-  const client = await (0, import_core13.getPublicClient)(config, { chainId });
+  const client = await core.getPublicClient(config$1, { chainId });
   try {
-    const { systemRegistry } = (0, import_config11.getCoreConfig)(chainId);
+    const { systemRegistry } = config.getCoreConfig(chainId);
     client.transport.retryCount = 0;
     client.transport.transports = [client.transport.transports[0]];
-    const liquidations = await (0, import_autopilot_swap_route_calc.getLiquidations)(
+    const liquidations = await autopilotSwapRouteCalc.getLiquidations(
       chainId,
       systemRegistry,
       client.transport.transports[0].value.url,
@@ -6479,16 +7915,16 @@ var getDynamicSwap = async ({
           sellAllOnlyCompatible: true
         })
       };
-      dynamicSwaps = await (await fetch(import_constants9.TOKEMAK_DYNAMIC_SWAP_ROUTES_URL, requestInit)).json();
+      dynamicSwaps = await (await fetch(constants.TOKEMAK_DYNAMIC_SWAP_ROUTES_URL, requestInit)).json();
       if (dynamicSwaps?.success) {
-        const autopoolRouter = await getAutopilotRouter(config, { chainId });
+        const autopoolRouter = await getAutopilotRouter(config$1, { chainId });
         if (!autopoolRouter) {
           throw new Error("No autopool router found");
         }
         try {
           await client?.simulateContract({
             address: autopoolRouter,
-            abi: import_abis12.autopilotRouterAbi,
+            abi: abis.autopilotRouterAbi,
             functionName: "previewRedeemWithRoutes",
             args: [
               address,
@@ -6503,7 +7939,7 @@ var getDynamicSwap = async ({
             account: user || placeholderAddress
           });
         } catch (e) {
-          if (e instanceof import_viem12.ContractFunctionExecutionError && e.cause instanceof import_viem12.ContractFunctionRevertedError && e.cause.data?.errorName === "PreviewRedeemWithRoutesResult") {
+          if (e instanceof viem.ContractFunctionExecutionError && e.cause instanceof viem.ContractFunctionRevertedError && e.cause.data?.errorName === "PreviewRedeemWithRoutesResult") {
             previewRedeem = e.cause.data?.args?.[0];
           }
         }
@@ -6512,9 +7948,9 @@ var getDynamicSwap = async ({
       console.log(e);
     }
   }
-  const previewRedeemOnChain = await (0, import_core13.readContract)(config, {
+  const previewRedeemOnChain = await core.readContract(config$1, {
     address,
-    abi: import_abis12.autopoolEthAbi,
+    abi: abis.autopoolEthAbi,
     functionName: "previewRedeem",
     args: [amount],
     chainId,
@@ -6530,12 +7966,6 @@ var getDynamicSwap = async ({
     previewRedeem
   };
 };
-
-// functions/getAmountWithdrawn.ts
-var import_tokenlist10 = require("@tokemak/tokenlist");
-var import_config12 = require("@tokemak/config");
-var import_core14 = require("@wagmi/core");
-var import_abis13 = require("@tokemak/abis");
 var getAmountWithdrawn = async ({
   address,
   slippage,
@@ -6545,7 +7975,7 @@ var getAmountWithdrawn = async ({
   decimals = 18,
   buyToken,
   isSwap,
-  config,
+  config: config$1,
   sellToken,
   autopool
 }) => {
@@ -6558,25 +7988,25 @@ var getAmountWithdrawn = async ({
       user,
       amount,
       chainId,
-      config,
+      config: config$1,
       slippage
     });
     let quote;
     let convertedAssets;
     if (!!dynamicSwap?.previewRedeem) {
-      const minAmountWithSlippage = (0, import_utils24.calculateMinAmountWithSlippage)(
+      const minAmountWithSlippage = utils.calculateMinAmountWithSlippage(
         dynamicSwap?.previewRedeem,
         slippage
       );
-      let minAmount = (0, import_viem13.formatUnits)(minAmountWithSlippage, decimals);
+      let minAmount = viem.formatUnits(minAmountWithSlippage, decimals);
       if (isSwap) {
-        if (buyToken === import_tokenlist10.ETH_TOKEN.address) {
-          const weth = (0, import_config12.getCoreConfig)(chainId).weth;
+        if (buyToken === tokenlist.ETH_TOKEN.address) {
+          const weth = config.getCoreConfig(chainId).weth;
           buyToken = weth;
         }
-        convertedAssets = await (0, import_core14.readContract)(config, {
+        convertedAssets = await core.readContract(config$1, {
           address: autopool,
-          abi: import_abis13.autopoolEthAbi,
+          abi: abis.autopoolEthAbi,
           functionName: "convertToAssets",
           args: [amount],
           chainId
@@ -6584,17 +8014,17 @@ var getAmountWithdrawn = async ({
         if (!convertedAssets) {
           throw new Error("No converted assets");
         }
-        quote = await getSwapQuote(config, {
+        quote = await getSwapQuote(config$1, {
           buyToken,
           sellToken,
           sellAmount: dynamicSwap?.previewRedeem,
-          slippageBps: (0, import_utils24.convertNumToBps)(slippage),
+          slippageBps: utils.convertNumToBps(slippage),
           chainId,
           includeSources: "0xV2",
           sellAll: true
         });
         if (quote) {
-          minAmount = (0, import_viem13.formatUnits)(BigInt(quote?.minBuyAmount), decimals);
+          minAmount = viem.formatUnits(BigInt(quote?.minBuyAmount), decimals);
         } else {
           throw new Error("No quote found");
         }
@@ -6612,11 +8042,6 @@ var getAmountWithdrawn = async ({
     };
   }
 };
-
-// functions/getAmountDeposited.ts
-var import_core15 = require("@wagmi/core");
-var import_abis14 = require("@tokemak/abis");
-var import_utils25 = require("@tokemak/utils");
 var getAmountDeposited = async ({
   address,
   chainId,
@@ -6629,21 +8054,21 @@ var getAmountDeposited = async ({
     if (!address || !chainId || !amount || typeof slippage !== "number") {
       throw new Error("Invalid parameters");
     }
-    const previewDeposit = await (0, import_core15.readContract)(config, {
+    const previewDeposit = await core.readContract(config, {
       address,
-      abi: import_abis14.autopoolEthAbi,
+      abi: abis.autopoolEthAbi,
       functionName: "previewDeposit",
       args: [amount],
       chainId
     });
     if (!isSwap) {
-      let minAmountWithSlippage = (0, import_utils25.calculateMinAmountWithSlippage)(
+      let minAmountWithSlippage = utils.calculateMinAmountWithSlippage(
         previewDeposit,
         slippage
       );
-      return (0, import_utils25.formatEtherNum)(minAmountWithSlippage);
+      return utils.formatEtherNum(minAmountWithSlippage);
     } else {
-      return (0, import_utils25.formatEtherNum)(previewDeposit);
+      return utils.formatEtherNum(previewDeposit);
     }
   } catch (e) {
     console.error(e);
@@ -6652,11 +8077,6 @@ var getAmountDeposited = async ({
   }
 };
 
-// functions/getBridgeFee.ts
-var import_core16 = require("@wagmi/core");
-var import_abis15 = require("@tokemak/abis");
-var import_viem14 = require("viem");
-
 // ../../node_modules/@ethersproject/logger/lib.esm/_version.js
 var version = "logger/5.8.0";
 
@@ -6847,9 +8267,6 @@ var Logger = class {
     this.throwArgumentError(message, name, value);
   }
   checkNormalize(message) {
-    if (message == null) {
-      message = "platform missing String.prototype.normalize";
-    }
     if (_normalizeError) {
       this.throwError("platform missing String.prototype.normalize", Logger.errors.UNSUPPORTED_OPERATION, {
         operation: "String.prototype.normalize",
@@ -7380,7 +8797,7 @@ function throwFault(fault, operation, value) {
 var import_bs58 = __toESM(require_bs58(), 1);
 
 // ../../node_modules/tiny-invariant/dist/esm/tiny-invariant.js
-var isProduction = process.env.NODE_ENV === "production";
+process.env.NODE_ENV === "production";
 
 // ../../node_modules/@layerzerolabs/lz-v2-utilities/dist/index.mjs
 function hexZeroPadTo32(addr) {
@@ -7398,7 +8815,7 @@ var solanaAddressRegex = /^([1-9A-HJ-NP-Za-km-z]{32,44})$/;
 function isSolanaAddress(address) {
   return solanaAddressRegex.test(address);
 }
-var MAX_UINT_128 = BigNumber.from("0xffffffffffffffffffffffffffffffff");
+BigNumber.from("0xffffffffffffffffffffffffffffffff");
 
 // functions/getBridgeFee.ts
 var getBridgeFee = async (wagmiConfig, {
@@ -7410,15 +8827,15 @@ var getBridgeFee = async (wagmiConfig, {
   from
 }) => {
   try {
-    const endpoint = await (0, import_core16.readContract)(wagmiConfig, {
+    const endpoint = await core.readContract(wagmiConfig, {
       address: destAddress,
-      abi: import_abis15.oftAdapterAbi,
+      abi: abis.oftAdapterAbi,
       functionName: "endpoint",
       chainId: destChainId
     });
-    const eid = await (0, import_core16.readContract)(wagmiConfig, {
+    const eid = await core.readContract(wagmiConfig, {
       address: endpoint,
-      abi: import_abis15.layerZeroEndpointAbi,
+      abi: abis.layerZeroEndpointAbi,
       functionName: "eid",
       chainId: destChainId
     });
@@ -7427,16 +8844,16 @@ var getBridgeFee = async (wagmiConfig, {
     const minAmountLD = amount / factor * factor;
     const sendParams = {
       dstEid: eid,
-      to: (0, import_viem14.toHex)(addressToBytes32(from)),
+      to: viem.toHex(addressToBytes32(from)),
       amountLD: amount,
       minAmountLD,
       extraOptions: "0x",
       composeMsg: "0x",
       oftCmd: "0x"
     };
-    const feeQuote = await (0, import_core16.readContract)(wagmiConfig, {
+    const feeQuote = await core.readContract(wagmiConfig, {
       address: sourceAddress,
-      abi: import_abis15.oftAdapterAbi,
+      abi: abis.oftAdapterAbi,
       functionName: "quoteSend",
       args: [sendParams, false],
       chainId: sourceChainId
@@ -7501,42 +8918,27 @@ var waitForMessageReceived = async ({
   }
   throw new Error(`Timeout reached after 20 minutes for message: ${txHash}`);
 };
-
-// functions/getChainUserSToke.ts
-var import_abis17 = require("@tokemak/abis");
-var import_config13 = require("@tokemak/config");
-var import_utils26 = require("@tokemak/utils");
-var import_core18 = require("@wagmi/core");
-var import_viem15 = require("viem");
-var import_chains9 = require("viem/chains");
-
-// functions/getCurrentCycleId.ts
-var import_abis16 = require("@tokemak/abis");
-var import_core17 = require("@wagmi/core");
 var getCurrentCycleId = async (wagmiConfig, {
   stoke,
   chainId
 }) => {
-  return (0, import_core17.readContract)(wagmiConfig, {
+  return core.readContract(wagmiConfig, {
     address: stoke,
-    abi: import_abis16.accTokeV1Abi,
+    abi: abis.accTokeV1Abi,
     chainId,
     functionName: "getCurrentCycleID"
   });
 };
-
-// functions/getChainUserSToke.ts
-var import_graph_cli12 = require("@tokemak/graph-cli");
 var getChainUserSToke = async (wagmiConfig, {
   address,
   tokePrice,
   chainId
 }) => {
   try {
-    const { stoke } = (0, import_config13.getCoreConfig)(chainId);
+    const { stoke } = config.getCoreConfig(chainId);
     const cycleIndex = await getCurrentCycleId(wagmiConfig, { chainId, stoke });
     if (address && cycleIndex && stoke && tokePrice) {
-      const { GetUserSTokeBalance } = (0, import_graph_cli12.getSdkByChainId)(
+      const { GetUserSTokeBalance } = graphCli.getSdkByChainId(
         chainId
       );
       const { accountBalanceV1S } = await GetUserSTokeBalance({
@@ -7545,13 +8947,13 @@ var getChainUserSToke = async (wagmiConfig, {
       const cycleStartBalance = accountBalanceV1S[0]?.cycleStartBalance || 0n;
       const stokeContract = {
         address: stoke,
-        abi: import_abis17.accTokeV1Abi
+        abi: abis.accTokeV1Abi
       };
       const [
         { result: balance },
         { result: depositInfoResult },
         { result: withdrawalInfoResult }
-      ] = await (0, import_core18.readContracts)(wagmiConfig, {
+      ] = await core.readContracts(wagmiConfig, {
         contracts: [
           {
             ...stokeContract,
@@ -7581,8 +8983,8 @@ var getChainUserSToke = async (wagmiConfig, {
         if (withdrawalAmount > 0n && cycleIndex >= withdrawalMinCycle) {
           balanceExcludingWithdrawal = balanceExcludingWithdrawal - withdrawalAmount;
         }
-        const withdrawalAmountUsd = (0, import_utils26.formatCurrency)(
-          (0, import_utils26.formatEtherNum)(withdrawalAmount) * tokePrice
+        const withdrawalAmountUsd = utils.formatCurrency(
+          utils.formatEtherNum(withdrawalAmount) * tokePrice
         );
         const lockDuration = Number(depositLockDuration);
         const lockCycle = Number(depositLockCycle);
@@ -7603,27 +9005,27 @@ var getChainUserSToke = async (wagmiConfig, {
         const withdrawAvailable = lockRenew - 1;
         const hasAddedLockedToke = depositAmount > 0n && depositAmount > rolloverDepositAmount;
         const addedLockedToke = depositAmount - rolloverDepositAmount;
-        const balanceUSD = (0, import_utils26.formatCurrency)(
-          Number((0, import_viem15.formatEther)(balanceExcludingWithdrawal)) * tokePrice
+        const balanceUSD = utils.formatCurrency(
+          Number(viem.formatEther(balanceExcludingWithdrawal)) * tokePrice
         );
-        const balanceExcludingWithdrawalUsd = (0, import_utils26.formatCurrency)(
-          (0, import_utils26.formatEtherNum)(balanceExcludingWithdrawal) * tokePrice
+        const balanceExcludingWithdrawalUsd = utils.formatCurrency(
+          utils.formatEtherNum(balanceExcludingWithdrawal) * tokePrice
         );
         const isUnlockRequestAvailable = currentCycle === withdrawAvailable;
         const hasRequestedUnlock = withdrawalAmount > 0n;
-        const unlockRequestPeriodStartUnix = (0, import_utils26.convertChainCycleToUnix)(withdrawAvailable, chainId) - Date.now() / 1e3;
-        const unlockRequestPeriodEndUnix = (0, import_utils26.convertChainCycleToUnix)(lockRenew, chainId) - Date.now() / 1e3;
+        const unlockRequestPeriodStartUnix = utils.convertChainCycleToUnix(withdrawAvailable, chainId) - Date.now() / 1e3;
+        const unlockRequestPeriodEndUnix = utils.convertChainCycleToUnix(lockRenew, chainId) - Date.now() / 1e3;
         const hasBalance = balance > 0n;
         const hasBalanceExcludingWithdrawal = balanceExcludingWithdrawal > 0n;
         const hasUnlockableBalance = withdrawalMinCycle <= currentCycle && withdrawalAmount > 0n;
         let cyclesInAMonth = 4;
         let lockDurationInMonths = lockDuration / cyclesInAMonth;
-        if (chainId === import_chains9.sepolia.id) {
+        if (chainId === chains.sepolia.id) {
           lockDurationInMonths = lockDuration - 1;
         }
         const unlockPeriodDateRangeArray = [
-          new Date((0, import_utils26.convertChainCycleToUnix)(withdrawAvailable, chainId) * 1e3),
-          new Date((0, import_utils26.convertChainCycleToUnix)(lockRenew, chainId) * 1e3)
+          new Date(utils.convertChainCycleToUnix(withdrawAvailable, chainId) * 1e3),
+          new Date(utils.convertChainCycleToUnix(lockRenew, chainId) * 1e3)
         ];
         const {
           unlockPeriodDateRange,
@@ -7633,20 +9035,20 @@ var getChainUserSToke = async (wagmiConfig, {
           unlockRenewalDate
         } = formatDateRange(
           unlockPeriodDateRangeArray,
-          chainId === import_chains9.sepolia.id ? "time" : "date"
+          chainId === chains.sepolia.id ? "time" : "date"
         );
-        const totalActiveUserCredits = (0, import_utils26.formatEtherNum)(balanceExcludingWithdrawal) * lockDurationInMonths;
-        const totalUserCredits = (0, import_utils26.formatEtherNum)(balance) * lockDurationInMonths;
+        const totalActiveUserCredits = utils.formatEtherNum(balanceExcludingWithdrawal) * lockDurationInMonths;
+        const totalUserCredits = utils.formatEtherNum(balance) * lockDurationInMonths;
         return {
           balance,
           balanceUSD,
-          balanceExcludingWithdrawal: hasBalance ? (0, import_viem15.formatEther)(balanceExcludingWithdrawal) : "0.00",
+          balanceExcludingWithdrawal: hasBalance ? viem.formatEther(balanceExcludingWithdrawal) : "0.00",
           balanceExcludingWithdrawalUsd,
           hasBalanceExcludingWithdrawal,
-          timeLeftBeforeUnlockRequestAvailable: (0, import_utils26.convertSecondsToRemainingTime)(
+          timeLeftBeforeUnlockRequestAvailable: utils.convertSecondsToRemainingTime(
             unlockRequestPeriodStartUnix
           ),
-          timeLeftBeforeUnlockRequestUnavailable: (0, import_utils26.convertSecondsToRemainingTime)(
+          timeLeftBeforeUnlockRequestUnavailable: utils.convertSecondsToRemainingTime(
             unlockRequestPeriodEndUnix
           ),
           withdrawalAmount,
@@ -7663,7 +9065,7 @@ var getChainUserSToke = async (wagmiConfig, {
           unlockRenewalDate,
           lockDurationInMonths,
           boost: lockDuration,
-          points: (0, import_utils26.formatEtherNum)(balanceExcludingWithdrawal) * lockDuration,
+          points: utils.formatEtherNum(balanceExcludingWithdrawal) * lockDuration,
           totalActiveCredits: totalActiveUserCredits,
           totalCredits: totalUserCredits
         };
@@ -7673,9 +9075,6 @@ var getChainUserSToke = async (wagmiConfig, {
     console.error(error);
   }
 };
-
-// functions/getUserSToke.ts
-var import_utils28 = require("@tokemak/utils");
 var getUserSToke = async (wagmiConfig, {
   address,
   tokePrice,
@@ -7702,8 +9101,8 @@ var getUserSToke = async (wagmiConfig, {
       }
       return acc;
     }, 0n);
-    const totalBalance = (0, import_utils28.formatEtherNum)(totalBalanceRaw || 0n);
-    const totalBalanceUsd = (0, import_utils28.formatCurrency)(totalBalance * tokePrice);
+    const totalBalance = utils.formatEtherNum(totalBalanceRaw || 0n);
+    const totalBalanceUsd = utils.formatCurrency(totalBalance * tokePrice);
     const hasBalance = totalBalance > 0;
     return {
       chains: { ...userSToke },
@@ -7715,27 +9114,19 @@ var getUserSToke = async (wagmiConfig, {
     console.error(e);
   }
 };
-
-// functions/getChainSToke.ts
-var import_viem16 = require("viem");
-var import_core19 = require("@wagmi/core");
-var import_abis18 = require("@tokemak/abis");
-var import_utils30 = require("@tokemak/utils");
-var import_config14 = require("@tokemak/config");
-var import_utils31 = require("@tokemak/utils");
 var getChainSToke = async (wagmiConfig, {
   tokePrice,
   chainId
 }) => {
   try {
-    const { stoke } = (0, import_config14.getCoreConfig)(chainId);
+    const { stoke } = config.getCoreConfig(chainId);
     const baseConfig = {
       address: stoke,
-      abi: import_abis18.accTokeV1Abi,
+      abi: abis.accTokeV1Abi,
       chainId
     };
     if (stoke && tokePrice) {
-      const [{ result: totalSupply }, { result: currentCycle }] = await (0, import_core19.readContracts)(wagmiConfig, {
+      const [{ result: totalSupply }, { result: currentCycle }] = await core.readContracts(wagmiConfig, {
         contracts: [
           {
             ...baseConfig,
@@ -7747,16 +9138,16 @@ var getChainSToke = async (wagmiConfig, {
           }
         ]
       });
-      const tvl = Number((0, import_viem16.formatEther)(totalSupply || 0n)) * tokePrice;
-      const secondsLeftBeforeNextCycle = (0, import_utils30.convertChainCycleToUnix)(Number(currentCycle) + 1, chainId) - Date.now() / 1e3;
+      const tvl = Number(viem.formatEther(totalSupply || 0n)) * tokePrice;
+      const secondsLeftBeforeNextCycle = utils.convertChainCycleToUnix(Number(currentCycle) + 1, chainId) - Date.now() / 1e3;
       return {
         rawTotalSupply: totalSupply,
-        totalSupply: (0, import_utils30.formatLargeNumber)((0, import_viem16.formatEther)(totalSupply || 0n)),
-        tvl: (0, import_utils30.formatTVL)(tvl),
+        totalSupply: utils.formatLargeNumber(viem.formatEther(totalSupply || 0n)),
+        tvl: utils.formatTVL(tvl),
         rawTVL: tvl,
         currentCycle,
-        chain: (0, import_utils31.getNetwork)(chainId),
-        timeBeforeNextCycle: (0, import_utils30.convertSecondsToRemainingTime)(
+        chain: utils.getNetwork(chainId),
+        timeBeforeNextCycle: utils.convertSecondsToRemainingTime(
           secondsLeftBeforeNextCycle
         )
       };
@@ -7765,10 +9156,6 @@ var getChainSToke = async (wagmiConfig, {
     console.error(error);
   }
 };
-
-// functions/getSToke.ts
-var import_utils32 = require("@tokemak/utils");
-var import_viem17 = require("viem");
 var getSToke = async (wagmiConfig, {
   tokePrice,
   includeTestnet = false
@@ -7787,24 +9174,20 @@ var getSToke = async (wagmiConfig, {
       }
       return acc;
     }, 0n);
-    const totalSupply = (0, import_utils32.formatLargeNumber)((0, import_viem17.formatEther)(totalSupplyBigInt || 0n));
+    const totalSupply = utils.formatLargeNumber(viem.formatEther(totalSupplyBigInt || 0n));
     let tvlNum = Object.values(sToke).reduce((acc, item) => {
       if (item && item.rawTVL) {
         return acc + item.rawTVL;
       }
       return acc;
     }, 0);
-    const tvl = (0, import_utils32.formatTVL)(tvlNum);
+    const tvl = utils.formatTVL(tvlNum);
     return { totalSupply, tvl, rawTVL: tvlNum, chains: { ...sToke } };
   } catch (e) {
     console.error(e);
     throw e;
   }
 };
-
-// functions/getChainCycleRolloverBlockNumber.ts
-var import_abis19 = require("@tokemak/abis");
-var import_core20 = require("@wagmi/core");
 var getChainCycleRolloverBlockNumber = async (wagmiConfig, {
   stoke,
   chainId
@@ -7812,15 +9195,15 @@ var getChainCycleRolloverBlockNumber = async (wagmiConfig, {
   const scanPeriodInDays = 8;
   const blockTime = 12;
   try {
-    const client = (0, import_core20.getPublicClient)(wagmiConfig, { chainId });
+    const client = core.getPublicClient(wagmiConfig, { chainId });
     if (!!client) {
-      const blockNumber = await (0, import_core20.getBlockNumber)(wagmiConfig, {
+      const blockNumber = await core.getBlockNumber(wagmiConfig, {
         chainId
       });
-      const manager = await (0, import_core20.readContract)(wagmiConfig, {
+      const manager = await core.readContract(wagmiConfig, {
         functionName: "manager",
         address: stoke,
-        abi: import_abis19.accTokeV1Abi,
+        abi: abis.accTokeV1Abi,
         chainId
       });
       if (!manager) {
@@ -7833,7 +9216,7 @@ var getChainCycleRolloverBlockNumber = async (wagmiConfig, {
             Number(blockNumber) - 86400 / blockTime * scanPeriodInDays
           )
         ),
-        abi: import_abis19.managerV1Abi,
+        abi: abis.managerV1Abi,
         eventName: "CycleRolloverComplete"
       });
       const rolloverEvents = await client.getFilterLogs({ filter });
@@ -7844,10 +9227,6 @@ var getChainCycleRolloverBlockNumber = async (wagmiConfig, {
     console.error(error);
   }
 };
-
-// functions/getChainUserSTokeVotes.ts
-var import_utils35 = require("@tokemak/utils");
-var import_graph_cli13 = require("@tokemak/graph-cli");
 var getChainUserSTokeVotes = async ({
   address,
   chainId = 1,
@@ -7856,7 +9235,7 @@ var getChainUserSTokeVotes = async ({
 }) => {
   try {
     if (address && stokeVotes) {
-      const { GetUserSTokeVotes, GetUserSTokeBalance } = (0, import_graph_cli13.getSdkByChainId)(chainId);
+      const { GetUserSTokeVotes, GetUserSTokeBalance } = graphCli.getSdkByChainId(chainId);
       const { userVotes } = await GetUserSTokeVotes({
         address: address.toLowerCase()
       });
@@ -7869,10 +9248,10 @@ var getChainUserSTokeVotes = async ({
         subgraphUserVotesData?.pools || [],
         subgraphUserVotesData?.weights || []
       );
-      const stakedToke = (0, import_utils35.formatEtherNum)(
+      const stakedToke = utils.formatEtherNum(
         BigInt(subgraphAccountVotesBalance?.amount || 0n)
       );
-      const totalUserVotes = (0, import_utils35.formatEtherNum)(
+      const totalUserVotes = utils.formatEtherNum(
         BigInt(subgraphAccountVotesBalance?.points || 0n)
       );
       const autopools = {};
@@ -7957,24 +9336,18 @@ var getUserSTokeVotes = async ({
     console.error(e);
   }
 };
-
-// functions/getChainSTokeVotes.ts
-var import_config15 = require("@tokemak/config");
-var import_utils38 = require("@tokemak/utils");
-var import_viem18 = require("viem");
-var import_graph_cli14 = require("@tokemak/graph-cli");
 var getChainSTokeVotes = async ({
   chainId,
   includeTestnet = false
 }) => {
-  const { GetSTokeVotes } = (0, import_graph_cli14.getSdkByChainId)(chainId);
+  const { GetSTokeVotes } = graphCli.getSdkByChainId(chainId);
   const { accTokeVoteWeights, voteStatuses } = await GetSTokeVotes();
   const autopoolRawVotes = voteStatuses[0];
   const globalVotes = accTokeVoteWeights[0];
   const globalVoted = BigInt(globalVotes.voted);
   const globalNotVoted = BigInt(globalVotes.notVoted);
   const whitelistedPools = includeTestnet ? autopoolRawVotes?.pools || [] : (autopoolRawVotes?.pools || []).filter(
-    (pool) => import_config15.AUTOPOOLS_WHITELIST_PROD.includes((0, import_viem18.getAddress)(pool))
+    (pool) => config.AUTOPOOLS_WHITELIST_PROD.includes(viem.getAddress(pool))
   );
   const poolCount = whitelistedPools.length;
   const perPoolNotVoted = !!poolCount ? globalNotVoted / BigInt(poolCount) : 0n;
@@ -7991,13 +9364,13 @@ var getChainSTokeVotes = async ({
     updatedPoints
   );
   const globalSystemVotes = globalVoted + globalNotVoted;
-  const totalSystemVotesNum = (0, import_utils38.formatEtherNum)(globalSystemVotes);
+  const totalSystemVotesNum = utils.formatEtherNum(globalSystemVotes);
   const formattedAutopoolVotes = Object.fromEntries(
     Object.entries(autopoolVotes).filter(
       ([poolAddress]) => includeTestnet ? true : whitelistedPools.includes(poolAddress)
     ).map(([poolAddress, rawVote]) => {
-      const formattedVote = (0, import_utils38.formatLargeNumber)(
-        (0, import_utils38.formatEtherNum)(BigInt(rawVote))
+      const formattedVote = utils.formatLargeNumber(
+        utils.formatEtherNum(BigInt(rawVote))
       );
       return [
         poolAddress,
@@ -8012,7 +9385,7 @@ var getChainSTokeVotes = async ({
       globalSystemVotes
     },
     totalSystemVotesNum,
-    totalSystemVotes: (0, import_utils38.formatLargeNumber)(totalSystemVotesNum),
+    totalSystemVotes: utils.formatLargeNumber(totalSystemVotesNum),
     autopoolVotes: formattedAutopoolVotes
   };
 };
@@ -8034,17 +9407,11 @@ var getSTokeVotes = async ({
     console.error(e);
   }
 };
-
-// functions/getChainSTokeRewards.ts
-var import_config16 = require("@tokemak/config");
-var import_viem19 = require("viem");
-var import_utils40 = require("@tokemak/utils");
-var import_graph_cli15 = require("@tokemak/graph-cli");
 var getChainSTokeRewards = async ({
   chainId
 }) => {
   try {
-    const { GetSTokeRewards } = (0, import_graph_cli15.getSdkByChainId)(chainId);
+    const { GetSTokeRewards } = graphCli.getSdkByChainId(chainId);
     const { poolRewardsBalances } = await GetSTokeRewards();
     const allPoolRewardsBalanceDayDatas = await paginateQuery(
       GetSTokeRewards,
@@ -8056,15 +9423,15 @@ var getChainSTokeRewards = async ({
     let minApr = null;
     let maxApr = null;
     for (const pool of poolRewardsBalances) {
-      const whitelistedPools = import_config16.AUTOPOOLS_WHITELIST_PROD.map(
+      const whitelistedPools = config.AUTOPOOLS_WHITELIST_PROD.map(
         (address) => address.toLowerCase()
       );
       if (!whitelistedPools.includes(pool.id.toLowerCase())) {
         continue;
       }
-      const convertedBalance = (0, import_utils40.formatEtherNum)(pool.balance);
-      const convertedBalanceUSD = Number((0, import_viem19.formatUnits)(pool.balanceUSD, 8));
-      const convertedApr = (0, import_utils40.formatEtherNum)(pool.currentAprPerCredit);
+      const convertedBalance = utils.formatEtherNum(pool.balance);
+      const convertedBalanceUSD = Number(viem.formatUnits(pool.balanceUSD, 8));
+      const convertedApr = utils.formatEtherNum(pool.currentAprPerCredit);
       if (minApr === null || convertedApr < minApr) {
         minApr = convertedApr;
       }
@@ -8134,17 +9501,13 @@ var getSTokeRewards = async ({
     throw e;
   }
 };
-
-// functions/getChainUserSTokeRewards.ts
-var import_config17 = require("@tokemak/config");
-var import_utils43 = require("@tokemak/utils");
 var getChainUserSTokeRewards = async (wagmiConfig, {
   address,
   chainId,
   tokePrice
 }) => {
-  const { rewardsV1Url, stokeRewardsHash, stokeRewards } = (0, import_config17.getMainnetConfig)(1);
-  const { stoke } = (0, import_config17.getCoreConfig)(chainId);
+  const { rewardsV1Url, stokeRewardsHash, stokeRewards } = config.getMainnetConfig(1);
+  const { stoke } = config.getCoreConfig(chainId);
   const currentCycle = await getCurrentCycleId(wagmiConfig, {
     stoke,
     chainId
@@ -8188,14 +9551,14 @@ var getChainUserSTokeRewards = async (wagmiConfig, {
       throw fallbackError;
     }
   }
-  const claimableNum = (0, import_utils43.formatEtherNum)(tokeRewards?.claimable || 0n);
+  const claimableNum = utils.formatEtherNum(tokeRewards?.claimable || 0n);
   const claimableUsd = tokePrice * claimableNum;
   const hasClaimable = claimableNum > 0n;
-  const pendingRewards = (0, import_utils43.formatEtherNum)(
+  const pendingRewards = utils.formatEtherNum(
     tokeRewards?.rewardsPayload.breakdown?.totalRewardAmount || 0n
   );
   const pendingRewardsUsd = tokePrice * pendingRewards;
-  const totalRewardsReceived = (0, import_utils43.formatEtherNum)(
+  const totalRewardsReceived = utils.formatEtherNum(
     tokeRewards.rewardsPayload.payload.amount || 0n
   );
   const totalRewardsReceivedUsd = tokePrice * totalRewardsReceived;
@@ -8210,13 +9573,10 @@ var getChainUserSTokeRewards = async (wagmiConfig, {
     ...tokeRewards
   };
 };
-
-// functions/getChainSubgraphStatus.ts
-var import_graph_cli16 = require("@tokemak/graph-cli");
 var getChainSubgraphStatus = async (chain) => {
   const currentTimestamp = Math.floor(Date.now() / 1e3);
   try {
-    const { GetLatestSubgraphTimestamp } = (0, import_graph_cli16.getSdkByChainId)(
+    const { GetLatestSubgraphTimestamp } = graphCli.getSdkByChainId(
       chain.chainId
     );
     const { _meta } = await GetLatestSubgraphTimestamp();
@@ -8266,17 +9626,9 @@ var getSubgraphStatus = async (includeTestnet = false) => {
   }
   return { isOutOfSync, errorMessage };
 };
-
-// functions/getCycleV1.ts
-var import_core21 = require("@wagmi/core");
-var import_abis20 = require("@tokemak/abis");
-var import_viem20 = require("viem");
-var import_utils45 = require("@tokemak/utils");
-var import_config18 = require("@tokemak/config");
-var import_chains10 = require("viem/chains");
-var publicClient = (0, import_viem20.createPublicClient)({
-  chain: import_chains10.mainnet,
-  transport: (0, import_viem20.http)("https://mainnet.infura.io/v3/2BtQ5D1QEPHvwgZwKwnZC7WQVhr")
+var publicClient = viem.createPublicClient({
+  chain: chains.mainnet,
+  transport: viem.http("https://mainnet.infura.io/v3/2BtQ5D1QEPHvwgZwKwnZC7WQVhr")
 });
 var getCycleV1 = async (wagmiConfig, {
   currentBlockNumber,
@@ -8284,12 +9636,12 @@ var getCycleV1 = async (wagmiConfig, {
 }) => {
   const scanPeriodInDays = 8;
   const blockTime = 12;
-  const { managerV1 } = (0, import_config18.getMainnetConfig)();
+  const { managerV1 } = config.getMainnetConfig();
   try {
     if (currentBlockNumber && managerV1) {
-      const currentCycleIndex = await (0, import_core21.readContract)(wagmiConfig, {
+      const currentCycleIndex = await core.readContract(wagmiConfig, {
         address: managerV1,
-        abi: import_abis20.managerV1Abi,
+        abi: abis.managerV1Abi,
         functionName: "getCurrentCycleIndex",
         chainId
       });
@@ -8300,16 +9652,16 @@ var getCycleV1 = async (wagmiConfig, {
             Number(currentBlockNumber) - 86400 / blockTime * scanPeriodInDays
           )
         ),
-        abi: import_abis20.managerV1Abi,
+        abi: abis.managerV1Abi,
         eventName: "CycleRolloverComplete"
       });
       const rolloverEvents = await publicClient.getFilterLogs({ filter });
       const cycleRolloverBlockNumber = chainId === 1 ? rolloverEvents[rolloverEvents.length - 1]?.blockNumber : rolloverEvents[rolloverEvents.length - 1]?.blockNumber || currentBlockNumber;
-      const secondsLeftBeforeNextCycle = (0, import_utils45.convertChainCycleToUnix)(Number(currentCycleIndex) + 1) - Date.now() / 1e3;
+      const secondsLeftBeforeNextCycle = utils.convertChainCycleToUnix(Number(currentCycleIndex) + 1) - Date.now() / 1e3;
       return {
         currentCycleIndex,
         cycleRolloverBlockNumber,
-        timeBeforeNextCycle: (0, import_utils45.convertSecondsToRemainingTime)(
+        timeBeforeNextCycle: utils.convertSecondsToRemainingTime(
           secondsLeftBeforeNextCycle
         )
       };
@@ -8318,9 +9670,6 @@ var getCycleV1 = async (wagmiConfig, {
     console.error(error);
   }
 };
-
-// functions/getProtocolStats.ts
-var import_utils46 = require("@tokemak/utils");
 var getProtocolStats = async (autopools, stoke, sushiLP) => {
   try {
     if (!autopools || !stoke || !sushiLP) {
@@ -8350,12 +9699,12 @@ var getProtocolStats = async (autopools, stoke, sushiLP) => {
       Object.entries(categories).map(([key, value]) => [
         key,
         {
-          tvl: (0, import_utils46.formatTVL)(value.tvl),
-          supply: (0, import_utils46.formatLargeNumber)(value.supply || 0)
+          tvl: utils.formatTVL(value.tvl),
+          supply: utils.formatLargeNumber(value.supply || 0)
         }
       ])
     );
-    const tvl = (0, import_utils46.formatTVL)(autopoolTVL + stoke.rawTVL + (sushiLP?.tvl || 0));
+    const tvl = utils.formatTVL(autopoolTVL + stoke.rawTVL + (sushiLP?.tvl || 0));
     const vaultAddresses = autopools?.flatMap(
       (pool) => pool.destinations.map((destination) => destination.vaultAddress)
     );
@@ -8363,16 +9712,16 @@ var getProtocolStats = async (autopools, stoke, sushiLP) => {
     const totalDestinations = uniqueVaultAddresses.length;
     return {
       autopools: {
-        tvl: (0, import_utils46.formatTVL)(autopoolTVL),
+        tvl: utils.formatTVL(autopoolTVL),
         tvlNum: autopoolTVL,
         categories: formattedCategories
       },
       stoke: {
-        tvl: (0, import_utils46.formatTVL)(stoke.rawTVL),
+        tvl: utils.formatTVL(stoke.rawTVL),
         totalSupply: `${stoke.totalSupply} TOKE`
       },
       sushiLP: {
-        tvl: (0, import_utils46.formatTVL)(sushiLP?.tvl || 0),
+        tvl: utils.formatTVL(sushiLP?.tvl || 0),
         totalSupply: sushiLP?.totalSupply || 0
       },
       tvl,
@@ -8383,23 +9732,14 @@ var getProtocolStats = async (autopools, stoke, sushiLP) => {
     return null;
   }
 };
-
-// functions/getRebalanceStats.ts
-var import_graph_cli17 = require("@tokemak/graph-cli");
-
-// functions/getEthPriceAtBlock.ts
-var import_config19 = require("@tokemak/config");
-var import_core22 = require("@wagmi/core");
-var import_abis21 = require("@tokemak/abis");
-var import_tokenlist11 = require("@tokemak/tokenlist");
 var getEthPriceAtBlock = async (wagmiConfig, blockNumber, chainId) => {
-  const config = (0, import_config19.getCoreConfig)(chainId);
-  const rootPriceOracle = config.rootPriceOracle;
-  const weth = config.weth;
-  const usdc = import_tokenlist11.USDC_TOKEN.extensions?.bridgeInfo?.[chainId]?.tokenAddress || import_tokenlist11.USDC_TOKEN.address;
-  const priceAtBlock = await (0, import_core22.readContract)(wagmiConfig, {
+  const config$1 = config.getCoreConfig(chainId);
+  const rootPriceOracle = config$1.rootPriceOracle;
+  const weth = config$1.weth;
+  const usdc = tokenlist.USDC_TOKEN.extensions?.bridgeInfo?.[chainId]?.tokenAddress || tokenlist.USDC_TOKEN.address;
+  const priceAtBlock = await core.readContract(wagmiConfig, {
     address: rootPriceOracle,
-    abi: import_abis21.rootPriceOracleAbi,
+    abi: abis.rootPriceOracleAbi,
     functionName: "getPriceInQuote",
     args: [weth, usdc],
     blockNumber,
@@ -8407,14 +9747,9 @@ var getEthPriceAtBlock = async (wagmiConfig, blockNumber, chainId) => {
   });
   return priceAtBlock;
 };
-
-// functions/getRebalanceStats.ts
-var import_utils48 = require("@tokemak/utils");
-var import_tokenlist12 = require("@tokemak/tokenlist");
-var import_chains11 = require("viem/chains");
 var BATCH_SIZE = 500;
 var fetchChainRebalances = async (chainId) => {
-  const { GetAllAutopoolRebalances } = (0, import_graph_cli17.getSdkByChainId)(chainId);
+  const { GetAllAutopoolRebalances } = graphCli.getSdkByChainId(chainId);
   const allRebalances = await paginateQuery(
     GetAllAutopoolRebalances,
     "autopoolRebalances"
@@ -8428,10 +9763,10 @@ function inferBaseAssetDecimals(rebalance, chainId) {
   if (BigInt(rebalance.tokenOutValueBaseAsset) === BigInt(rebalance.tokenOutValueInEth)) {
     return 18;
   }
-  if (chainId === import_chains11.sonic.id) {
+  if (chainId === chains.sonic.id) {
     return rebalance.tokenOut.decimals;
   }
-  return import_tokenlist12.USDC_TOKEN.decimals;
+  return tokenlist.USDC_TOKEN.decimals;
 }
 var getRebalanceValueUsd = async (rebalance, chainId, wagmiConfig) => {
   const ethWei = BigInt(rebalance.tokenOutValueInEth || "0");
@@ -8443,8 +9778,8 @@ var getRebalanceValueUsd = async (rebalance, chainId, wagmiConfig) => {
       BigInt(rebalance.blockNumber),
       chainId
     );
-    const ethUsd = Number((0, import_utils48.formatUnitsNum)(price, import_tokenlist12.USDC_TOKEN.decimals));
-    const ethAmt = Number((0, import_utils48.formatEtherNum)(ethWei));
+    const ethUsd = Number(utils.formatUnitsNum(price, tokenlist.USDC_TOKEN.decimals));
+    const ethAmt = Number(utils.formatEtherNum(ethWei));
     const usd = ethAmt * ethUsd;
     return usd;
   } catch (e) {
@@ -8468,7 +9803,7 @@ var processRebalance = async (rebalance, chainId, wagmiConfig) => {
   }
   const baseDecimals = inferBaseAssetDecimals(rebalance, chainId);
   const baseUsd = Number(
-    (0, import_utils48.formatUnitsNum)(
+    utils.formatUnitsNum(
       BigInt(rebalance.tokenOutValueBaseAsset || "0"),
       baseDecimals
     )
@@ -8556,105 +9891,116 @@ var updateRebalanceStats = async (wagmiConfig, {
   const allRebalances = [...currentRebalances, ...allNewRebalances];
   return calculateRebalanceStats(allRebalances);
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  AutopoolCategory,
-  BASE_ASSETS,
-  BATCH_SIZE,
-  ETH_BASE_ASSETS,
-  EUR_BASE_ASSETS,
-  MessageStatus,
-  PRICED_TOKENS,
-  USD_BASE_ASSETS,
-  aggregateSTokeRewardsDayData,
-  arraysToObject,
-  calculateRebalanceStats,
-  convertBaseAssetToTokenPrices,
-  convertBaseAssetToTokenPricesAndDenom,
-  fetchChainDataMap,
-  fetchChainRebalances,
-  fillMissingDates,
-  findClosestDateEntry,
-  findClosestEntry,
-  findClosestTimestampEntry,
-  formatDateRange,
-  getAddressFromSystemRegistry,
-  getAllowance,
-  getAmountDeposited,
-  getAmountWithdrawn,
-  getAutopilotRouter,
-  getAutopoolCategory,
-  getAutopoolDayData,
-  getAutopoolInfo,
-  getAutopoolRebalances,
-  getAutopools,
-  getAutopoolsHistory,
-  getAutopoolsRebalances,
-  getBridgeFee,
-  getChainAutopools,
-  getChainCycleRolloverBlockNumber,
-  getChainSToke,
-  getChainSTokeRewards,
-  getChainSubgraphStatus,
-  getChainUserActivity,
-  getChainUserAutopools,
-  getChainUserSToke,
-  getChainUserSTokeRewards,
-  getChainUserSTokeVotes,
-  getChainsForEnv,
-  getCurrentCycleId,
-  getCurveLP,
-  getCycleV1,
-  getDefillamaPrice,
-  getDynamicSwap,
-  getEthPrice,
-  getEthPriceAtBlock,
-  getExchangeNames,
-  getGenStratAprs,
-  getLayerzeroStatus,
-  getMutlipleAutopoolRebalances,
-  getPoolStats,
-  getPoolsAndDestinations,
-  getProtocolStats,
-  getRebalanceStats,
-  getRebalanceValueUsd,
-  getRewardsPayloadV1,
-  getSToke,
-  getSTokeChainsForEnv,
-  getSTokeRewards,
-  getSTokeVotes,
-  getSubgraphStatus,
-  getSushiLP,
-  getSwapQuote,
-  getSystemConfig,
-  getTimestampDaysFromStart,
-  getTokePrice,
-  getTokenList,
-  getTokenPrice,
-  getTokenPrices,
-  getTopAutopoolHolders,
-  getUserActivity,
-  getUserAutoEthRewards,
-  getUserAutopool,
-  getUserAutopools,
-  getUserAutopoolsHistory,
-  getUserAutopoolsRewards,
-  getUserCurveLP,
-  getUserRewardsV1,
-  getUserSToke,
-  getUserSTokeVotes,
-  getUserSushiLP,
-  getUserTokenBalances,
-  getUserV1,
-  mergeArrays,
-  mergeArraysWithKey,
-  mergeStringArrays,
-  modifyAutopoolName,
-  nestedArrayToObject,
-  paginateQuery,
-  processRebalance,
-  processRebalancesInBatches,
-  systemRegistryFunctionNames,
-  updateRebalanceStats,
-  waitForMessageReceived
-});
+/*! Bundled license information:
+
+ieee754/index.js:
+  (*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> *)
+
+buffer/index.js:
+  (*!
+   * The buffer module from node.js, for the browser.
+   *
+   * @author   Feross Aboukhadijeh <https://feross.org>
+   * @license  MIT
+   *)
+*/
+
+exports.AutopoolCategory = AutopoolCategory;
+exports.BASE_ASSETS = BASE_ASSETS;
+exports.BATCH_SIZE = BATCH_SIZE;
+exports.ETH_BASE_ASSETS = ETH_BASE_ASSETS;
+exports.EUR_BASE_ASSETS = EUR_BASE_ASSETS;
+exports.MessageStatus = MessageStatus;
+exports.PRICED_TOKENS = PRICED_TOKENS;
+exports.USD_BASE_ASSETS = USD_BASE_ASSETS;
+exports.aggregateSTokeRewardsDayData = aggregateSTokeRewardsDayData;
+exports.arraysToObject = arraysToObject;
+exports.calculateRebalanceStats = calculateRebalanceStats;
+exports.convertBaseAssetToTokenPrices = convertBaseAssetToTokenPrices;
+exports.convertBaseAssetToTokenPricesAndDenom = convertBaseAssetToTokenPricesAndDenom;
+exports.fetchChainDataMap = fetchChainDataMap;
+exports.fetchChainRebalances = fetchChainRebalances;
+exports.fillMissingDates = fillMissingDates;
+exports.findClosestDateEntry = findClosestDateEntry;
+exports.findClosestEntry = findClosestEntry;
+exports.findClosestTimestampEntry = findClosestTimestampEntry;
+exports.formatDateRange = formatDateRange;
+exports.getAddressFromSystemRegistry = getAddressFromSystemRegistry;
+exports.getAllowance = getAllowance;
+exports.getAmountDeposited = getAmountDeposited;
+exports.getAmountWithdrawn = getAmountWithdrawn;
+exports.getAutopilotRouter = getAutopilotRouter;
+exports.getAutopoolCategory = getAutopoolCategory;
+exports.getAutopoolDayData = getAutopoolDayData;
+exports.getAutopoolInfo = getAutopoolInfo;
+exports.getAutopoolRebalances = getAutopoolRebalances;
+exports.getAutopools = getAutopools;
+exports.getAutopoolsHistory = getAutopoolsHistory;
+exports.getAutopoolsRebalances = getAutopoolsRebalances;
+exports.getBridgeFee = getBridgeFee;
+exports.getChainAutopools = getChainAutopools;
+exports.getChainCycleRolloverBlockNumber = getChainCycleRolloverBlockNumber;
+exports.getChainSToke = getChainSToke;
+exports.getChainSTokeRewards = getChainSTokeRewards;
+exports.getChainSubgraphStatus = getChainSubgraphStatus;
+exports.getChainUserActivity = getChainUserActivity;
+exports.getChainUserAutopools = getChainUserAutopools;
+exports.getChainUserSToke = getChainUserSToke;
+exports.getChainUserSTokeRewards = getChainUserSTokeRewards;
+exports.getChainUserSTokeVotes = getChainUserSTokeVotes;
+exports.getChainsForEnv = getChainsForEnv;
+exports.getCurrentCycleId = getCurrentCycleId;
+exports.getCurveLP = getCurveLP;
+exports.getCycleV1 = getCycleV1;
+exports.getDefillamaPrice = getDefillamaPrice;
+exports.getDynamicSwap = getDynamicSwap;
+exports.getEthPrice = getEthPrice;
+exports.getEthPriceAtBlock = getEthPriceAtBlock;
+exports.getExchangeNames = getExchangeNames;
+exports.getGenStratAprs = getGenStratAprs;
+exports.getLayerzeroStatus = getLayerzeroStatus;
+exports.getMutlipleAutopoolRebalances = getMutlipleAutopoolRebalances;
+exports.getPoolStats = getPoolStats;
+exports.getPoolsAndDestinations = getPoolsAndDestinations;
+exports.getProtocolStats = getProtocolStats;
+exports.getRebalanceStats = getRebalanceStats;
+exports.getRebalanceValueUsd = getRebalanceValueUsd;
+exports.getRewardsPayloadV1 = getRewardsPayloadV1;
+exports.getSToke = getSToke;
+exports.getSTokeChainsForEnv = getSTokeChainsForEnv;
+exports.getSTokeRewards = getSTokeRewards;
+exports.getSTokeVotes = getSTokeVotes;
+exports.getSubgraphStatus = getSubgraphStatus;
+exports.getSushiLP = getSushiLP;
+exports.getSwapQuote = getSwapQuote;
+exports.getSystemConfig = getSystemConfig;
+exports.getTimestampDaysFromStart = getTimestampDaysFromStart;
+exports.getTokePrice = getTokePrice;
+exports.getTokenList = getTokenList;
+exports.getTokenPrice = getTokenPrice;
+exports.getTokenPrices = getTokenPrices;
+exports.getTopAutopoolHolders = getTopAutopoolHolders;
+exports.getUserActivity = getUserActivity;
+exports.getUserAutoEthRewards = getUserAutoEthRewards;
+exports.getUserAutopool = getUserAutopool;
+exports.getUserAutopools = getUserAutopools;
+exports.getUserAutopoolsHistory = getUserAutopoolsHistory;
+exports.getUserAutopoolsRewards = getUserAutopoolsRewards;
+exports.getUserCurveLP = getUserCurveLP;
+exports.getUserRewardsV1 = getUserRewardsV1;
+exports.getUserSToke = getUserSToke;
+exports.getUserSTokeVotes = getUserSTokeVotes;
+exports.getUserSushiLP = getUserSushiLP;
+exports.getUserTokenBalances = getUserTokenBalances;
+exports.getUserV1 = getUserV1;
+exports.mergeArrays = mergeArrays;
+exports.mergeArraysWithKey = mergeArraysWithKey;
+exports.mergeStringArrays = mergeStringArrays;
+exports.modifyAutopoolName = modifyAutopoolName;
+exports.nestedArrayToObject = nestedArrayToObject;
+exports.paginateQuery = paginateQuery;
+exports.processRebalance = processRebalance;
+exports.processRebalancesInBatches = processRebalancesInBatches;
+exports.systemRegistryFunctionNames = systemRegistryFunctionNames;
+exports.updateRebalanceStats = updateRebalanceStats;
+exports.waitForMessageReceived = waitForMessageReceived;