@tokemak/queries 0.0.9 → 0.0.11

package/dist/index.js

@@ -1,17 +1,21 @@
+import { mainnet, sepolia, sonic, plasma, base } from 'viem/chains';
+import { TOKEMAK_SWAP_PRICING_URL, SUPPORTED_DEV_CHAINS, SUPPORTED_PROD_CHAINS, SUPPORTED_STOKE_DEV_CHAINS, SUPPORTED_STOKE_PROD_CHAINS, TOKEMAK_GENSTRAT_APRS_API_URL, CURVE_API_URL, TOKE_CURVE_POOL_ID, TOKEMAK_PRICES_STAGING_URL, TOKEMAK_LAUNCH_TIMESTAMP, TOKEMAK_SWAP_QUOTE_URL, TOKEMAK_DYNAMIC_SWAP_ROUTES_URL } from '@tokemak/constants';
+import { ETH_TOKEN, PXETH_TOKEN, USDC_TOKEN, DOLA_TOKEN, S_TOKEN, EURC_TOKEN, USDT_TOKEN, USDT0_TOKEN, TOKE_TOKEN, SILO_TOKEN, XPL_TOKEN, WXPL_TOKEN, WETH_TOKEN, WS_TOKEN, ALL_AUTOPOOLS, BEETS_PROTOCOL, ALL_TOKENS, TOKEMAK_LISTS_URL } from '@tokemak/tokenlist';
+import { createPublicClient, http, formatUnits, getAddress, formatEther, erc20Abi, hexToBigInt, ContractFunctionExecutionError, ContractFunctionRevertedError, toHex as toHex$1 } from 'viem';
+import { convertTimestampToDate, formatDateToReadable, formatEtherNum, getToken, formatUnitsNum, formatPoolName, getProtocol, getNetwork, formatCurrency, calculateMinAmountWithSlippage, convertNumToBps, convertChainCycleToUnix, convertSecondsToRemainingTime, formatLargeNumber, formatTVL } from '@tokemak/utils';
+import { getSdkByChainId } from '@tokemak/graph-cli';
+import { getCoreConfig, AUTOPOOLS_WHITELIST_PROD, getMainnetConfig } from '@tokemak/config';
+import { readContract, readContracts, getPublicClient, getBlockNumber } from '@wagmi/core';
+import { lensAbi, rewardsV1HashAbi, rewardsV1Abi, stakingV1Abi, sushiPoolAbi, poolV1Abi, autopoolEthAbi, systemRegistryAbi, autopilotRouterAbi, oftAdapterAbi, layerZeroEndpointAbi, accTokeV1Abi, managerV1Abi, rootPriceOracleAbi, autoEthRewardsHashAbi } from '@tokemak/abis';
+import { getLiquidations } from '@tokemak/autopilot-swap-route-calc';
+
 var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined")
-    return require.apply(this, arguments);
-  throw new Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
+var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -20,22 +24,1899 @@ var __copyProps = (to, from, except, desc) => {
       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
-));
+  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, module) {
     (function(module2, exports2) {
-      "use strict";
       function assert(val, msg) {
         if (!val)
           throw new Error(msg || "Assertion failed");
@@ -76,7 +1957,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) {
       }
@@ -1594,149 +3475,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);
@@ -1853,8 +3591,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];
@@ -2971,7 +4708,6 @@ var require_bn = __commonJS({
 // ../../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, module) {
-    "use strict";
     function base2(ALPHABET) {
       if (ALPHABET.length >= 255) {
         throw new TypeError("Alphabet too long");
@@ -2993,8 +4729,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);
@@ -3113,12 +4848,6 @@ var require_bs58 = __commonJS({
   }
 });
 
-// functions/getEthPrice.ts
-import { sepolia } from "viem/chains";
-
-// functions/getTokenPrice.ts
-import { TOKEMAK_SWAP_PRICING_URL } from "@tokemak/constants";
-
 // functions/getDefillamaPrice.ts
 var getDefillamaPrice = async (tokenAddress) => {
   const response = await fetch(
@@ -3205,9 +4934,6 @@ var getEthPrice = async () => {
     }
   }
 };
-
-// functions/getTokePrice.ts
-import { TOKE_TOKEN } from "@tokemak/tokenlist";
 var getTokePrice = async () => {
   try {
     return await getTokenPrice({ tokenAddress: TOKE_TOKEN.address });
@@ -3385,12 +5111,6 @@ function mergeStringArrays(keys, values) {
   }
   return result;
 }
-
-// utils/getChainsForEnv.ts
-import {
-  SUPPORTED_DEV_CHAINS,
-  SUPPORTED_PROD_CHAINS
-} from "@tokemak/constants";
 function getChainsForEnv({
   includeTestnet = false
 }) {
@@ -3407,14 +5127,6 @@ async function fetchChainDataMap(chains, fetchFn) {
     return acc;
   }, {});
 }
-
-// utils/aggregateSTokeRewardsDayData.ts
-import { formatUnits } from "viem";
-import {
-  convertTimestampToDate,
-  formatDateToReadable,
-  formatEtherNum
-} from "@tokemak/utils";
 function aggregateSTokeRewardsDayData(dayDatas) {
   const byTs = {};
   for (const item of dayDatas) {
@@ -3449,12 +5161,6 @@ function aggregateSTokeRewardsDayData(dayDatas) {
   const result = Object.values(byTs).filter((day) => day.earned !== 0);
   return result;
 }
-
-// utils/getSTokeChainsForEnv.ts
-import {
-  SUPPORTED_STOKE_DEV_CHAINS,
-  SUPPORTED_STOKE_PROD_CHAINS
-} from "@tokemak/constants";
 function getSTokeChainsForEnv({
   includeTestnet = false
 }) {
@@ -3511,9 +5217,6 @@ var convertBaseAssetToTokenPricesAndDenom = (baseAsset, baseAssetPrice, denomPri
     denom: baseAsset * baseAssetToDenom
   };
 };
-
-// utils/getAutopoolInfo.ts
-import { ALL_AUTOPOOLS } from "@tokemak/tokenlist";
 var getAutopoolInfo = (symbol) => {
   const autopool = ALL_AUTOPOOLS.find((pool) => pool.symbol === symbol);
   return autopool;
@@ -3585,9 +5288,6 @@ async function paginateQuery(queryFn, arrayKey, options = {}) {
   return results;
 }
 
-// functions/getPoolsAndDestinationsBackup.ts
-import { getNetwork } from "@tokemak/utils";
-
 // functions/getBlobData.ts
 var getBlobData = async (blobName) => {
   try {
@@ -3620,17 +5320,6 @@ var getPoolsAndDestinationsBackup = async (chainId) => {
   }
 };
 
-// functions/getChainAutopools.ts
-import {
-  formatEtherNum as formatEtherNum2,
-  formatPoolName,
-  formatUnitsNum,
-  getNetwork as getNetwork3,
-  getProtocol,
-  getToken
-} from "@tokemak/utils";
-import { formatUnits as formatUnits2, getAddress } from "viem";
-
 // constants/tokenOrders.ts
 var UITokenOrder = [
   "ETH",
@@ -3666,9 +5355,6 @@ var protocolOrder = [
   "Morpho",
   "Fluid"
 ];
-
-// functions/getGenStratAprs.ts
-import { TOKEMAK_GENSTRAT_APRS_API_URL } from "@tokemak/constants";
 var getGenStratAprs = async ({
   chainId = 1
 }) => {
@@ -3700,25 +5386,6 @@ var getGenStratAprs = async ({
     return void 0;
   }
 };
-
-// functions/getChainAutopools.ts
-import {
-  ALL_TOKENS,
-  BEETS_PROTOCOL,
-  ETH_TOKEN,
-  S_TOKEN,
-  WETH_TOKEN,
-  WS_TOKEN,
-  WXPL_TOKEN,
-  XPL_TOKEN
-} from "@tokemak/tokenlist";
-import { getSdkByChainId } from "@tokemak/graph-cli";
-import { sonic } from "viem/chains";
-
-// functions/getPoolsAndDestinations.ts
-import { getCoreConfig } from "@tokemak/config";
-import { readContract } from "@wagmi/core";
-import { lensAbi } from "@tokemak/abis";
 var getPoolsAndDestinations = async (wagmiConfig, { chainId }) => {
   try {
     const { lens } = getCoreConfig(chainId);
@@ -3738,12 +5405,9 @@ var getPoolsAndDestinations = async (wagmiConfig, { chainId }) => {
     console.error(`Error on ${chainId} in getPoolsAndDestinations:`, error);
   }
 };
-
-// functions/getBackupApr.ts
-import { getNetwork as getNetwork2 } from "@tokemak/utils";
 var getBackupApr = async (chainId, poolAddress) => {
   try {
-    const networkName = getNetwork2(chainId)?.name.toLowerCase();
+    const networkName = getNetwork(chainId)?.name.toLowerCase();
     const backupData = await getBlobData(
       `${networkName}-getChainAutopools-latest-success.json`
     );
@@ -3858,7 +5522,7 @@ var getChainAutopools = async (wagmiConfig, {
             ...destination,
             debtValueHeldByVaultUsd: debtValueHeldByVaultEth * baseAssetPrice,
             debtValueHeldByVaultEth,
-            compositeReturn: isGenStrat ? genStratAprs?.[autopool.poolAddress]?.[destination.vaultAddress]?.apr || 0 : formatEtherNum2(destination.compositeReturn),
+            compositeReturn: isGenStrat ? genStratAprs?.[autopool.poolAddress]?.[destination.vaultAddress]?.apr || 0 : formatEtherNum(destination.compositeReturn),
             debtValueHeldByVaultAllocation: debtValueHeldByVaultEth / totalAssets,
             underlyingTokens,
             poolName: formatPoolName(destination.lpTokenName),
@@ -3942,10 +5606,10 @@ var getChainAutopools = async (wagmiConfig, {
         let baseApr = aprs?.currentApy;
         let boostedApr = 0;
         let extraApr = 0;
-        const formattedRewarder7DayMAApy = formatEtherNum2(
+        const formattedRewarder7DayMAApy = formatEtherNum(
           BigInt(Number(aprs?.rewarder?.day7MAApy) || 0)
         );
-        const formattedRewarder30DayMAApy = formatEtherNum2(
+        const formattedRewarder30DayMAApy = formatEtherNum(
           BigInt(Number(aprs?.rewarder?.day30MAApy) || 0)
         );
         if (formattedRewarder7DayMAApy > 0) {
@@ -3960,9 +5624,9 @@ var getChainAutopools = async (wagmiConfig, {
           }, 0);
           const periodicFeeBps = autopool.periodicFeeBps || 0n;
           const streamingFeeBps = autopool.streamingFeeBps || 0n;
-          baseApr = (weightedCrNum / (1 - totalIdleAssets / totalAssets) - Number(formatUnits2(periodicFeeBps, 4))) * (1 - Number(formatUnits2(streamingFeeBps, 4)));
+          baseApr = (weightedCrNum / (1 - totalIdleAssets / totalAssets) - Number(formatUnits(periodicFeeBps, 4))) * (1 - Number(formatUnits(streamingFeeBps, 4)));
         } else {
-          baseApr = Number(formatUnits2(BigInt(baseApr), baseAsset.decimals));
+          baseApr = Number(formatUnits(BigInt(baseApr), baseAsset.decimals));
         }
         if (!baseApr) {
           baseApr = 0;
@@ -3988,7 +5652,7 @@ var getChainAutopools = async (wagmiConfig, {
             const token = getToken(reward?.rewardToken?.id, chainId);
             return {
               ...token,
-              apr: formatEtherNum2(BigInt(reward.currentApy || 0))
+              apr: formatEtherNum(BigInt(reward.currentApy || 0))
             };
           });
         }
@@ -4130,7 +5794,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 ${getNetwork3(chainId)?.name}.`;
+          autopoolInfo.description = `Autopool featuring ${UIBaseAsset.symbol} deployed across integrated DEXs and lending protocols on ${getNetwork(chainId)?.name}.`;
         }
         return {
           ...autopool,
@@ -4155,7 +5819,7 @@ var getChainAutopools = async (wagmiConfig, {
           UITokens,
           UIExchanges: finalUIExchanges,
           tokens: uniqueTokens,
-          chain: getNetwork3(chainId),
+          chain: getNetwork(chainId),
           apr: {
             base: baseApr,
             boosted: boostedApr,
@@ -4185,10 +5849,6 @@ var getChainAutopools = async (wagmiConfig, {
     return [];
   }
 };
-
-// functions/getAutopools.ts
-import { AUTOPOOLS_WHITELIST_PROD } from "@tokemak/config";
-import { getAddress as getAddress2 } from "viem";
 var getAutopools = async (wagmiConfig, {
   prices,
   includeTestnet = false
@@ -4210,18 +5870,15 @@ var getAutopools = async (wagmiConfig, {
       return sortedAutopoolsByTimestamp;
     } else {
       return sortedAutopoolsByTimestamp.filter((pool) => {
-        return AUTOPOOLS_WHITELIST_PROD.includes(getAddress2(pool.poolAddress));
+        return AUTOPOOLS_WHITELIST_PROD.includes(getAddress(pool.poolAddress));
       });
     }
   } catch (e) {
     console.error(e);
   }
 };
-
-// functions/getAutopoolRebalances.ts
-import { getSdkByChainId as getSdkByChainId2 } from "@tokemak/graph-cli";
 var getAutopoolRebalances = async (id, chainId = 1, options) => {
-  const { GetAutopoolRebalances } = getSdkByChainId2(chainId);
+  const { GetAutopoolRebalances } = getSdkByChainId(chainId);
   const first = options?.first ?? 1e3;
   const maxPages = options?.maxPages ?? 100;
   const queryFn = ({ first: first2, skip }) => GetAutopoolRebalances({ address: id, first: first2, skip });
@@ -4236,23 +5893,14 @@ var getAutopoolRebalances = async (id, chainId = 1, options) => {
     ix: length - index
   }));
 };
-
-// functions/getAutopoolsRebalances.ts
-import { getSdkByChainId as getSdkByChainId3 } from "@tokemak/graph-cli";
 var getAutopoolsRebalances = async (chainId = 1) => {
-  const { GetAutopoolsRebalances } = getSdkByChainId3(chainId);
+  const { GetAutopoolsRebalances } = 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
-import { getAddress as getAddress3 } from "viem";
-
-// functions/getAutopoolsDayData.ts
-import { getSdkByChainId as getSdkByChainId4 } from "@tokemak/graph-cli";
 var getAutopoolsDayData = async (chainId, timestamp) => {
-  const { GetAutopoolsDayData } = getSdkByChainId4(chainId);
+  const { GetAutopoolsDayData } = getSdkByChainId(chainId);
   const PAGE_SIZE = 1e3;
   let allResults = [];
   let hasMore = true;
@@ -4309,7 +5957,7 @@ var getAutopoolsHistory = async (autopools, days, includeTestnet = false) => {
           ...data,
           date: new Date(data.timestamp * 1e3),
           baseAsset: autopools.find(
-            (pool) => getAddress3(pool.poolAddress) === getAddress3(vaultId)
+            (pool) => getAddress(pool.poolAddress) === getAddress(vaultId)
           )?.baseAsset
         });
       }
@@ -4327,10 +5975,6 @@ var getAutopoolsHistory = async (autopools, days, includeTestnet = false) => {
     console.log(e);
   }
 };
-
-// functions/getCurveLP.ts
-import { getMainnetConfig } from "@tokemak/config";
-import { CURVE_API_URL, TOKE_CURVE_POOL_ID } from "@tokemak/constants";
 var getCurveLP = async () => {
   let curveData;
   const { curveRewardsUrl } = getMainnetConfig();
@@ -4361,15 +6005,8 @@ var getCurveLP = async () => {
   }
   return curveData;
 };
-
-// functions/getSushiLP.ts
-import { sushiPoolAbi } from "@tokemak/abis";
-import { getMainnetConfig as getMainnetConfig2 } from "@tokemak/config";
-import { readContracts } from "@wagmi/core";
-import { formatEther } from "viem";
-import { mainnet } from "viem/chains";
 var getSushiLP = async (wagmiConfig, { ethPrice }) => {
-  const { sushiPool, lpRewardsV1Url } = getMainnetConfig2();
+  const { sushiPool, lpRewardsV1Url } = getMainnetConfig();
   const sushiPoolContract = {
     address: sushiPool,
     abi: sushiPoolAbi
@@ -4415,11 +6052,8 @@ var getSushiLP = async (wagmiConfig, { ethPrice }) => {
     console.log(e);
   }
 };
-
-// functions/getChainUserActivity.ts
-import { getSdkByChainId as getSdkByChainId5 } from "@tokemak/graph-cli";
 var getChainUserActivity = async (address, chainId = 1) => {
-  const { GetUserBalanceChangeHistory } = getSdkByChainId5(chainId);
+  const { GetUserBalanceChangeHistory } = getSdkByChainId(chainId);
   try {
     const { userAutopoolBalanceChanges } = await GetUserBalanceChangeHistory({
       userAddress: address
@@ -4486,11 +6120,6 @@ var getRewardsPayloadV1 = async (cycleHash, account, rewardsV1Url) => {
     return null;
   }
 };
-
-// functions/getUserAutoEthRewards.ts
-import { autoEthRewardsHashAbi } from "@tokemak/abis";
-import { readContract as readContract2 } from "@wagmi/core";
-import { convertChainCycleToUnix, formatCurrency } from "@tokemak/utils";
 var getAutoEthRewards = async (wagmiConfig, {
   account,
   currentCycleIndex,
@@ -4499,14 +6128,14 @@ var getAutoEthRewards = async (wagmiConfig, {
   chainId
 }) => {
   try {
-    const [, drippingHash] = await readContract2(wagmiConfig, {
+    const [, drippingHash] = await readContract(wagmiConfig, {
       address: rewardsHash,
       abi: autoEthRewardsHashAbi,
       functionName: "cycleHashes",
       args: [currentCycleIndex - 306n],
       chainId
     });
-    const [, lastWeekHash] = await readContract2(wagmiConfig, {
+    const [, lastWeekHash] = await readContract(wagmiConfig, {
       address: rewardsHash,
       abi: autoEthRewardsHashAbi,
       functionName: "cycleHashes",
@@ -4554,10 +6183,6 @@ var getUserAutoEthRewards = async (wagmiConfig, rewardsV1Url, rewardsHash, addre
   );
   return { ...autoETHRewards, currentUserRewardsUsd };
 };
-
-// functions/getUserRewardsV1.ts
-import { rewardsV1Abi, rewardsV1HashAbi } from "@tokemak/abis";
-import { readContract as readContract3 } from "@wagmi/core";
 var getUserRewardsV1 = async (wagmiConfig, {
   address,
   rewardsCycleIndex,
@@ -4567,7 +6192,7 @@ var getUserRewardsV1 = async (wagmiConfig, {
   chainId
 }) => {
   try {
-    const [latestClaimableHash, cycleRewardsHash] = await readContract3(
+    const [latestClaimableHash, cycleRewardsHash] = await readContract(
       wagmiConfig,
       {
         address: rewardsV1Hash,
@@ -4591,7 +6216,7 @@ var getUserRewardsV1 = async (wagmiConfig, {
       const {
         payload: { chainId: payloadChainId, cycle, wallet, amount }
       } = latestClaimablePayload;
-      const claimable = await readContract3(wagmiConfig, {
+      const claimable = await readContract(wagmiConfig, {
         address: rewardsV1,
         abi: rewardsV1Abi,
         functionName: "getClaimableAmount",
@@ -4605,12 +6230,6 @@ var getUserRewardsV1 = async (wagmiConfig, {
     console.log(e);
   }
 };
-
-// functions/getUserV1.ts
-import { rewardsV1Abi as rewardsV1Abi2, stakingV1Abi } from "@tokemak/abis";
-import { readContract as readContract4 } from "@wagmi/core";
-import { getMainnetConfig as getMainnetConfig3 } from "@tokemak/config";
-import { mainnet as mainnet2 } from "viem/chains";
 var getUserV1 = async (wagmiConfig, {
   currentCycleIndex,
   address,
@@ -4625,14 +6244,14 @@ var getUserV1 = async (wagmiConfig, {
     autoEthGuardedRewards,
     rewardsV1,
     missedTokeRewards
-  } = getMainnetConfig3(mainnet2.id);
+  } = getMainnetConfig(mainnet.id);
   try {
-    const userStakedTokeV1 = await readContract4(wagmiConfig, {
+    const userStakedTokeV1 = await readContract(wagmiConfig, {
       address: stakingV1,
       abi: stakingV1Abi,
       functionName: "availableForWithdrawal",
       args: [address, 0n],
-      chainId: mainnet2.id
+      chainId: mainnet.id
     });
     const tokeRewards = await getUserRewardsV1(wagmiConfig, {
       address,
@@ -4659,9 +6278,9 @@ var getUserV1 = async (wagmiConfig, {
     const cycle = autoEthGuardedRewardsPayload?.payload?.cycle;
     const wallet = autoEthGuardedRewardsPayload?.payload?.wallet;
     const amount = autoEthGuardedRewardsPayload?.payload?.amount;
-    const claimableAutoEth = await readContract4(wagmiConfig, {
+    const claimableAutoEth = await readContract(wagmiConfig, {
       address: autoEthGuardedRewards,
-      abi: rewardsV1Abi2,
+      abi: rewardsV1Abi,
       functionName: "getClaimableAmount",
       args: [
         {
@@ -4683,9 +6302,9 @@ var getUserV1 = async (wagmiConfig, {
       const {
         payload: { chainId: payloadChainId2, cycle: cycle2, wallet: wallet2, amount: amount2 }
       } = missedTokeRewardsPayload;
-      claimableMissedToke = await readContract4(wagmiConfig, {
+      claimableMissedToke = await readContract(wagmiConfig, {
         address: missedTokeRewards,
-        abi: rewardsV1Abi2,
+        abi: rewardsV1Abi,
         functionName: "getClaimableAmount",
         args: [
           {
@@ -4712,14 +6331,11 @@ var getUserV1 = async (wagmiConfig, {
   } catch (e) {
   }
 };
-
-// functions/getChainUserAutopoolsHistory.tsx
-import { getSdkByChainId as getSdkByChainId6 } from "@tokemak/graph-cli";
 var getChainUserAutopoolsHistory = async ({
   address,
   chainId = 1
 }) => {
-  const { GetUserVaultsDayData } = getSdkByChainId6(chainId);
+  const { GetUserVaultsDayData } = getSdkByChainId(chainId);
   const oneYearAgoTimestamp = Math.floor(Date.now() / 1e3) - 365 * 24 * 60 * 60;
   try {
     if (address) {
@@ -4735,30 +6351,17 @@ var getChainUserAutopoolsHistory = async ({
     return [];
   }
 };
-
-// functions/getUserAutopoolsHistory.ts
-import {
-  formatDateToReadable as formatDateToReadable2,
-  formatEtherNum as formatEtherNum3,
-  formatUnitsNum as formatUnitsNum2
-} from "@tokemak/utils";
-
-// functions/getTokenValueDayDatas.ts
-import { mainnet as mainnet3 } from "viem/chains";
-import { convertTimestampToDate as convertTimestampToDate2 } from "@tokemak/utils";
-import { formatUnits as formatUnits3 } from "viem";
-import { getSdkByChainId as getSdkByChainId7 } from "@tokemak/graph-cli";
-var getTokenValueDayDatas = async (tokenAddress, chainId = mainnet3.id) => {
-  const { GetTokenValueDayDatas } = getSdkByChainId7(chainId);
+var getTokenValueDayDatas = async (tokenAddress, chainId = mainnet.id) => {
+  const { GetTokenValueDayDatas } = getSdkByChainId(chainId);
   try {
     const { tokenValueDayDatas } = await GetTokenValueDayDatas({
       tokenAddress: tokenAddress.toLowerCase()
     });
     const historicalPrice = tokenValueDayDatas.map((tokenValueDayData) => {
-      const date = convertTimestampToDate2(
+      const date = convertTimestampToDate(
         tokenValueDayData.lastSnapshotTimestamp
       );
-      const usdPrice = formatUnits3(tokenValueDayData.priceInUsd, 8);
+      const usdPrice = formatUnits(tokenValueDayData.priceInUsd, 8);
       return {
         timestamp: Number(tokenValueDayData.lastSnapshotTimestamp),
         date,
@@ -4771,25 +6374,6 @@ var getTokenValueDayDatas = async (tokenAddress, chainId = mainnet3.id) => {
   }
 };
 
-// functions/getTokenPrices.ts
-import {
-  ETH_TOKEN as ETH_TOKEN2,
-  PXETH_TOKEN,
-  TOKE_TOKEN as TOKE_TOKEN2,
-  USDC_TOKEN,
-  S_TOKEN as S_TOKEN2,
-  DOLA_TOKEN,
-  WETH_TOKEN as WETH_TOKEN2,
-  WS_TOKEN as WS_TOKEN2,
-  EURC_TOKEN,
-  SILO_TOKEN,
-  WXPL_TOKEN as WXPL_TOKEN2,
-  USDT_TOKEN,
-  XPL_TOKEN as XPL_TOKEN2,
-  USDT0_TOKEN
-} from "@tokemak/tokenlist";
-import { TOKEMAK_PRICES_STAGING_URL } from "@tokemak/constants";
-
 // functions/getBackupTokenPrices.ts
 var getBackupTokenPrices = async () => {
   try {
@@ -4806,26 +6390,26 @@ var getBackupTokenPrices = async () => {
 
 // functions/getTokenPrices.ts
 var BASE_ASSETS = [
-  { ...ETH_TOKEN2, symbol: "ETH", coinGeckoId: "ethereum" },
+  { ...ETH_TOKEN, symbol: "ETH", coinGeckoId: "ethereum" },
   { ...PXETH_TOKEN, symbol: "PXETH", coinGeckoId: "dinero-staked-eth" },
   { ...USDC_TOKEN, symbol: "USDC", coinGeckoId: "usd-coin" },
   { ...DOLA_TOKEN, symbol: "DOLA", coinGeckoId: "dola-usd" },
-  { ...S_TOKEN2, symbol: "S" },
+  { ...S_TOKEN, symbol: "S" },
   { ...EURC_TOKEN, symbol: "EURC", coinGeckoId: "euro-coin" },
   { ...USDT_TOKEN, symbol: "USDT", coinGeckoId: "tether" },
   { ...USDT0_TOKEN, symbol: "USDT0", coinGeckoId: "tether" }
 ];
 var PRICED_TOKENS = [
   ...BASE_ASSETS,
-  { ...TOKE_TOKEN2, symbol: "TOKE" },
+  { ...TOKE_TOKEN, symbol: "TOKE" },
   { ...SILO_TOKEN, symbol: "SILO" },
-  { ...XPL_TOKEN2, address: WXPL_TOKEN2.address, symbol: "XPL" },
+  { ...XPL_TOKEN, address: WXPL_TOKEN.address, symbol: "XPL" },
   { ...USDT0_TOKEN, symbol: "USDT0" }
 ];
-var WRAPPED_TOKENS = [
-  { ...WETH_TOKEN2, symbol: "WETH" },
-  { ...WS_TOKEN2, symbol: "WS" },
-  { ...WXPL_TOKEN2, symbol: "WXPL" }
+[
+  { ...WETH_TOKEN, symbol: "WETH" },
+  { ...WS_TOKEN, symbol: "WS" },
+  { ...WXPL_TOKEN, symbol: "WXPL" }
 ];
 var isStale = (timestamp) => {
   return timestamp - Math.floor(Date.now() / 1e3) > 5 * 60;
@@ -4890,9 +6474,6 @@ var getTokenPrices = async (isCronJob = false) => {
     }
   }
 };
-
-// functions/getHistoricalTokenPrices.ts
-import { ETH_TOKEN as ETH_TOKEN3 } from "@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`;
@@ -4910,7 +6491,7 @@ var getHistoricalTokenPrices = async () => {
   const historicalBaseAssetPrices = await Promise.all(
     BASE_ASSETS.map(async (baseAsset) => {
       if (!hasCoinGeckoId(baseAsset)) {
-        const address = baseAsset.address === ETH_TOKEN3.address ? ETH_ADDRESS_IN_SUBGRAPH : baseAsset.address;
+        const address = baseAsset.address === ETH_TOKEN.address ? ETH_ADDRESS_IN_SUBGRAPH : baseAsset.address;
         const prices2 = await getTokenValueDayDatas(
           address,
           baseAsset.chainId
@@ -5038,7 +6619,7 @@ var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeT
               Math.floor(sharesRatio * Number(SCALE))
             );
             const navBigInt = sharesRatioBigInt * BigInt(dayData.nav) / SCALE;
-            const navNum = formatUnitsNum2(
+            const navNum = formatUnitsNum(
               navBigInt,
               dayData.baseAsset.decimals
             );
@@ -5109,7 +6690,7 @@ var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeT
   let finalAggregatedHistoryArray = Object.keys(aggregatedHistoryArray).map(
     (dateKey) => ({
       date: aggregatedHistoryArray[dateKey].date,
-      formattedDate: formatDateToReadable2(aggregatedHistoryArray[dateKey].date),
+      formattedDate: formatDateToReadable(aggregatedHistoryArray[dateKey].date),
       nav: {
         ETH: aggregatedHistoryArray[dateKey].nav.ETH,
         USD: aggregatedHistoryArray[dateKey].nav.USD,
@@ -5144,7 +6725,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 + formatEtherNum3(BigInt(event?.assetChange || 0n)),
+        (sum, event) => sum + formatEtherNum(BigInt(event?.assetChange || 0n)),
         0
       );
       return {
@@ -5163,11 +6744,6 @@ var getUserAutopoolsHistory = async (address, autopoolsHistory, events, includeT
   }
   return result;
 };
-
-// functions/getUserSushiLP.ts
-import { readContracts as readContracts2 } from "@wagmi/core";
-import { poolV1Abi, sushiPoolAbi as sushiPoolAbi2 } from "@tokemak/abis";
-import { getMainnetConfig as getMainnetConfig4 } from "@tokemak/config";
 var getUserSushiLP = async (wagmiConfig, {
   sushiLP,
   currentCycleIndex,
@@ -5175,18 +6751,18 @@ var getUserSushiLP = async (wagmiConfig, {
   cycleRolloverBlockNumber,
   chainId
 }) => {
-  const { tSushiLP, sushiPool } = getMainnetConfig4();
+  const { tSushiLP, sushiPool } = getMainnetConfig();
   try {
     if (address && currentCycleIndex && sushiLP) {
       const [
         { result: sushiLPBalance },
         { result: tSushiLPBalance },
         { result: tSushiLPRequested }
-      ] = await readContracts2(wagmiConfig, {
+      ] = await readContracts(wagmiConfig, {
         contracts: [
           {
             address: sushiPool,
-            abi: sushiPoolAbi2,
+            abi: sushiPoolAbi,
             functionName: "balanceOf",
             args: [address],
             chainId
@@ -5210,7 +6786,7 @@ var getUserSushiLP = async (wagmiConfig, {
       const [
         { result: startTSushiLPBalance },
         { result: startTSushiLPRequested }
-      ] = await readContracts2(wagmiConfig, {
+      ] = await readContracts(wagmiConfig, {
         contracts: [
           {
             address: tSushiLP,
@@ -5262,31 +6838,26 @@ var getUserSushiLP = async (wagmiConfig, {
     console.log(e);
   }
 };
-
-// functions/getUserCurveLP.ts
-import { readContracts as readContracts3 } from "@wagmi/core";
-import { poolV1Abi as poolV1Abi2 } from "@tokemak/abis";
-import { getMainnetConfig as getMainnetConfig5 } from "@tokemak/config";
 var getUserCurveLP = async (wagmiConfig, {
   curveLP,
   address,
   chainId
 }) => {
   try {
-    const { curvePool, convexRewarder } = getMainnetConfig5();
+    const { curvePool, convexRewarder } = getMainnetConfig();
     if (address && curveLP && curvePool && convexRewarder) {
-      const [{ result: userCurveLPBalance }, { result: userConvexLPBalance }] = await readContracts3(wagmiConfig, {
+      const [{ result: userCurveLPBalance }, { result: userConvexLPBalance }] = await readContracts(wagmiConfig, {
         contracts: [
           {
             address: curvePool,
-            abi: poolV1Abi2,
+            abi: poolV1Abi,
             functionName: "balanceOf",
             args: [address],
             chainId
           },
           {
             address: convexRewarder,
-            abi: poolV1Abi2,
+            abi: poolV1Abi,
             functionName: "balanceOf",
             args: [address],
             chainId
@@ -5310,26 +6881,17 @@ var getUserCurveLP = async (wagmiConfig, {
     console.log(e);
   }
 };
-
-// functions/getMultipleAutopoolRebalances.ts
-import { getSdkByChainId as getSdkByChainId8 } from "@tokemak/graph-cli";
 var getMutlipleAutopoolRebalances = async (ids, chainId = 1) => {
-  const { GetMutlipleAutopoolRebalances } = getSdkByChainId8(chainId);
+  const { GetMutlipleAutopoolRebalances } = 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
-import { formatUnits as formatUnits4 } from "viem";
-import { formatEtherNum as formatEtherNum4 } from "@tokemak/utils";
-import { TOKEMAK_LAUNCH_TIMESTAMP } from "@tokemak/constants";
-import { getSdkByChainId as getSdkByChainId9 } from "@tokemak/graph-cli";
 var getAutopoolDayData = async (address, chainId = 1, startTimestamp = TOKEMAK_LAUNCH_TIMESTAMP) => {
   try {
-    const { GetAutopoolDayData } = getSdkByChainId9(chainId);
+    const { GetAutopoolDayData } = getSdkByChainId(chainId);
     const { autopoolDayDatas } = await GetAutopoolDayData({
       address,
       timestamp: startTimestamp
@@ -5338,10 +6900,10 @@ var getAutopoolDayData = async (address, chainId = 1, startTimestamp = TOKEMAK_L
       const navPerShare = autoPoolDayData.nav / autoPoolDayData.totalSupply;
       let baseApy = autoPoolDayData.autopoolApy;
       let rewarderApy = 0;
-      const formattedRewarder7DayMAApy = formatEtherNum4(
+      const formattedRewarder7DayMAApy = formatEtherNum(
         BigInt(Number(autoPoolDayData.rewarderDay7MAApy) || 0)
       );
-      const formattedRewarder30DayMAApy = formatEtherNum4(
+      const formattedRewarder30DayMAApy = formatEtherNum(
         BigInt(Number(autoPoolDayData.rewarderDay30MAApy) || 0)
       );
       if (formattedRewarder7DayMAApy) {
@@ -5354,7 +6916,7 @@ var getAutopoolDayData = async (address, chainId = 1, startTimestamp = TOKEMAK_L
         baseApy = 0;
       } else {
         baseApy = Number(
-          formatUnits4(BigInt(baseApy), autoPoolDayData.baseAsset.decimals)
+          formatUnits(BigInt(baseApy), autoPoolDayData.baseAsset.decimals)
         );
       }
       if (baseApy < 0) {
@@ -5377,10 +6939,6 @@ var getAutopoolDayData = async (address, chainId = 1, startTimestamp = TOKEMAK_L
     return [];
   }
 };
-
-// functions/getSystemConfig.ts
-import { readContracts as readContracts4 } from "@wagmi/core";
-import { systemRegistryAbi } from "@tokemak/abis";
 var systemRegistryFunctionNames = [
   "asyncSwapperRegistry",
   "autoPoolRouter",
@@ -5405,7 +6963,7 @@ var getSystemConfig = async (wagmiConfig, { systemRegistry }) => {
       { result: autopoolRouter },
       { result: autopoolRegistry },
       { result: swapRouter }
-    ] = await readContracts4(wagmiConfig, {
+    ] = await readContracts(wagmiConfig, {
       contracts: systemRegistryCalls
     });
     return {
@@ -5418,14 +6976,11 @@ var getSystemConfig = async (wagmiConfig, { systemRegistry }) => {
     console.log(e);
   }
 };
-
-// functions/getChainUserAutopools.tsx
-import { getSdkByChainId as getSdkByChainId10 } from "@tokemak/graph-cli";
 var getChainUserAutopools = async ({
   address,
   chainId = 1
 }) => {
-  const { GetUserVaultInfo } = getSdkByChainId10(chainId);
+  const { GetUserVaultInfo } = getSdkByChainId(chainId);
   try {
     if (address) {
       const { userInfo } = await GetUserVaultInfo({
@@ -5439,20 +6994,6 @@ var getChainUserAutopools = async ({
     return [];
   }
 };
-
-// functions/getUserAutopools.ts
-import {
-  convertTimestampToDate as convertTimestampToDate3,
-  formatEtherNum as formatEtherNum6,
-  formatUnitsNum as formatUnitsNum3
-} from "@tokemak/utils";
-import { ETH_TOKEN as ETH_TOKEN4 } from "@tokemak/tokenlist";
-
-// functions/getUserAutopool.tsx
-import { erc20Abi } from "viem";
-import { readContract as readContract5, readContracts as readContracts5 } from "@wagmi/core";
-import { formatEtherNum as formatEtherNum5 } from "@tokemak/utils";
-import { autopoolEthAbi } from "@tokemak/abis";
 var getUserAutopool = async (wagmiConfig, {
   address,
   autopool
@@ -5468,7 +7009,7 @@ var getUserAutopool = async (wagmiConfig, {
         { result: autopoolRewarderContract },
         { result: pastRewarders },
         { result: unstakedPoolShares, error: unstakedPoolSharesError }
-      ] = await readContracts5(wagmiConfig, {
+      ] = await readContracts(wagmiConfig, {
         contracts: [
           {
             ...autopoolContract,
@@ -5493,17 +7034,17 @@ var getUserAutopool = async (wagmiConfig, {
       if (unstakedPoolSharesError) {
         throw new Error("Error fetching unstaked pool shares");
       }
-      const stakedPoolShares = await readContract5(wagmiConfig, {
+      const stakedPoolShares = await readContract(wagmiConfig, {
         address: autopoolRewarderContract,
         abi: erc20Abi,
         functionName: "balanceOf",
         args: [address],
         chainId: autopool?.chain?.chainId
       });
-      const stakedShares = formatEtherNum5(stakedPoolShares);
+      const stakedShares = formatEtherNum(stakedPoolShares);
       const stakedNav = stakedShares * (autopool?.navPerShare.baseAsset || 0);
       const stakedNavUsd = stakedShares * (autopool?.navPerShare.USD || 0);
-      const unstakedShares = formatEtherNum5(unstakedPoolShares || 0n);
+      const unstakedShares = formatEtherNum(unstakedPoolShares || 0n);
       const unstakedNav = unstakedShares * (autopool?.navPerShare.USD || 0);
       const unstakedNavUsd = unstakedShares * (autopool?.navPerShare.USD || 0);
       const totalShares = unstakedShares + stakedShares;
@@ -5519,12 +7060,12 @@ var getUserAutopool = async (wagmiConfig, {
           args: [address],
           chainId: autopool?.chain?.chainId
         }));
-        const pastRewards = await readContracts5(wagmiConfig, {
+        const pastRewards = await readContracts(wagmiConfig, {
           contracts: pastRewardBalances
         });
         pastRewarderBalances = pastRewards.map(({ result }, index) => {
           const balance = result;
-          const shares = formatEtherNum5(result);
+          const shares = formatEtherNum(result);
           const nav = shares * (autopool?.navPerShare.baseAsset || 0);
           const navUsd = shares * (autopool?.navPerShare.USD || 0);
           return {
@@ -5642,14 +7183,14 @@ var getUserAutopools = async ({
         );
         if (autopoolData) {
           const isDOLA = autopoolData.symbol === "autoDOLA" && userAutoDOLA;
-          const userShares = isDOLA ? userAutoDOLA?.totalShares : formatEtherNum6(userAutopool?.totalShares);
-          const totalVaultShares = formatEtherNum6(autopoolData?.totalSupply);
+          const userShares = isDOLA ? userAutoDOLA?.totalShares : formatEtherNum(userAutopool?.totalShares);
+          const totalVaultShares = formatEtherNum(autopoolData?.totalSupply);
           const userShareOfVault = userShares / totalVaultShares;
-          const totalDeposits = formatUnitsNum3(
+          const totalDeposits = formatUnitsNum(
             userActivity?.totals[userAutopool.vaultAddress]?.totalDeposits || 0n,
             autopoolData?.baseAsset.decimals
           );
-          const totalWithdrawals = formatUnitsNum3(
+          const totalWithdrawals = formatUnitsNum(
             userActivity?.totals[userAutopool.vaultAddress]?.totalWithdrawals || 0n,
             autopoolData?.baseAsset.decimals
           );
@@ -5658,7 +7199,7 @@ var getUserAutopools = async ({
           );
           let lastDeposit;
           if (poolEvents && poolEvents?.length > 0) {
-            lastDeposit = convertTimestampToDate3(
+            lastDeposit = convertTimestampToDate(
               poolEvents[poolEvents.length - 1].timestamp
             ).toLocaleDateString("en-US", {
               day: "2-digit",
@@ -5758,7 +7299,7 @@ var getUserAutopools = async ({
             totalWithdrawals: prev.totalWithdrawals + totalWithdrawals
           };
           const stakedBalance = isDOLA ? userAutoDOLA?.staked.balance : BigInt(userAutopool?.stakedShares);
-          const stakedShares = isDOLA ? userAutoDOLA?.staked.shares : formatEtherNum6(stakedBalance);
+          const stakedShares = isDOLA ? userAutoDOLA?.staked.shares : formatEtherNum(stakedBalance);
           const stakedNav = stakedShares * (autopoolData?.navPerShare.baseAsset || 0);
           const staked = convertBaseAssetToTokenPrices(
             stakedNav,
@@ -5766,7 +7307,7 @@ var getUserAutopools = async ({
             prices
           );
           const unstakedBalance = isDOLA ? userAutoDOLA?.unstaked.balance : BigInt(userAutopool?.walletShares);
-          const unstakedShares = isDOLA ? userAutoDOLA?.unstaked.shares : formatEtherNum6(unstakedBalance);
+          const unstakedShares = isDOLA ? userAutoDOLA?.unstaked.shares : formatEtherNum(unstakedBalance);
           const unstakedNav = unstakedShares * (autopoolData?.navPerShare.baseAsset || 0);
           const unstaked = convertBaseAssetToTokenPrices(
             unstakedNav,
@@ -5811,7 +7352,7 @@ var getUserAutopools = async ({
           };
         }
       });
-      let denominatedToken = ETH_TOKEN4;
+      let denominatedToken = ETH_TOKEN;
       const useDenomination = userAutopoolsWithData.filter((autopool) => autopool?.useDenomination).length === 1 && userAutopoolsWithData.length === 1;
       if (useDenomination) {
         const autopoolWithDenomination = userAutopoolsWithData.find(
@@ -5963,17 +7504,13 @@ var getUserAutopools = async ({
     console.log(e);
   }
 };
-
-// functions/getUserTokenBalances.ts
-import { hexToBigInt } from "viem";
-import { base, mainnet as mainnet4, sonic as sonic2 } from "viem/chains";
 var networkToAlchemyUrl = (chainId, apiKey) => {
   switch (chainId) {
-    case mainnet4.id:
+    case mainnet.id:
       return `https://eth-mainnet.g.alchemy.com/v2/${apiKey}`;
     case base.id:
       return `https://base-mainnet.g.alchemy.com/v2/${apiKey}`;
-    case sonic2.id:
+    case sonic.id:
       return `https://sonic-mainnet.g.alchemy.com/v2/${apiKey}`;
     default:
       throw new Error("Unsupported network");
@@ -6019,9 +7556,6 @@ var getUserTokenBalances = async ({
   );
   return tokenBalances;
 };
-
-// functions/getTokenList.ts
-import { TOKEMAK_LISTS_URL } from "@tokemak/tokenlist";
 var getTokenList = async () => {
   try {
     let url = `${TOKEMAK_LISTS_URL}/swap_enabled.json`;
@@ -6033,12 +7567,9 @@ var getTokenList = async () => {
     return [];
   }
 };
-
-// functions/getTopAutopoolHolders.ts
-import { getSdkByChainId as getSdkByChainId11 } from "@tokemak/graph-cli";
 var getTopAutopoolHolders = async (autopoolAddress, chainId = 1) => {
   try {
-    const { GetTopAutopoolHolders } = getSdkByChainId11(chainId);
+    const { GetTopAutopoolHolders } = getSdkByChainId(chainId);
     const { holders } = await GetTopAutopoolHolders({
       address: autopoolAddress
     });
@@ -6048,19 +7579,15 @@ var getTopAutopoolHolders = async (autopoolAddress, chainId = 1) => {
     return [];
   }
 };
-
-// functions/getAllowance.ts
-import { readContract as readContract6 } from "@wagmi/core";
-import { erc20Abi as erc20Abi2 } from "viem";
 var getAllowance = async (wagmiConfig, {
   token,
   address,
   spender
 }) => {
   try {
-    const allowance = await readContract6(wagmiConfig, {
+    const allowance = await readContract(wagmiConfig, {
       address: token,
-      abi: erc20Abi2,
+      abi: erc20Abi,
       functionName: "allowance",
       args: [address || "0x0", spender]
     });
@@ -6099,23 +7626,15 @@ var getUserActivity = async ({
   mergedActivity.events.sort((a, b) => a.timestamp - b.timestamp);
   return mergedActivity;
 };
-
-// functions/getUserAutopoolsRewards.ts
-import { getAddress as getAddress4 } from "viem";
-
-// functions/getChainUserAutopoolsRewards.ts
-import { getCoreConfig as getCoreConfig2 } from "@tokemak/config";
-import { readContract as readContract7 } from "@wagmi/core";
-import { lensAbi as lensAbi2 } from "@tokemak/abis";
 var getChainUserAutopoolsRewards = async (wagmiConfig, {
   chainId,
   address
 }) => {
   try {
-    const coreConfig = getCoreConfig2(chainId);
-    const userRewardsInfo = await readContract7(wagmiConfig, {
+    const coreConfig = getCoreConfig(chainId);
+    const userRewardsInfo = await readContract(wagmiConfig, {
       address: coreConfig.lens,
-      abi: lensAbi2,
+      abi: lensAbi,
       functionName: "getUserRewardInfo",
       args: [address],
       chainId: coreConfig.id
@@ -6143,11 +7662,6 @@ var getChainUserAutopoolsRewards = async (wagmiConfig, {
     console.log(e);
   }
 };
-
-// functions/getUserAutopoolsRewards.ts
-import { formatUnitsNum as formatUnitsNum4, getToken as getToken2 } from "@tokemak/utils";
-import { SILO_TOKEN as SILO_TOKEN2, TOKE_TOKEN as TOKE_TOKEN3 } from "@tokemak/tokenlist";
-import { plasma } from "viem/chains";
 var getUserAutopoolsRewards = async (wagmiConfig, {
   address,
   tokenPrices,
@@ -6171,27 +7685,27 @@ var getUserAutopoolsRewards = async (wagmiConfig, {
       const extraRewardsArray = Object.entries(chainUserRewards).flatMap(
         ([autopoolAddress, rewards]) => {
           const autopool = autopools.find(
-            (autopool2) => getAddress4(autopool2.poolAddress) === getAddress4(autopoolAddress)
+            (autopool2) => getAddress(autopool2.poolAddress) === getAddress(autopoolAddress)
           );
           if (!autopool || !autopool.extraRewarders) {
             return [];
           }
           return autopool.extraRewarders.map((extraRewards2) => {
-            const rewarderToken = getToken2(
+            const rewarderToken = getToken(
               extraRewards2.rewardToken?.id,
               autopool.chain?.chainId
             );
-            const claimableAmount = rewards ? rewards[getAddress4(extraRewards2.rewardToken?.id)] : 0n;
+            const claimableAmount = rewards ? rewards[getAddress(extraRewards2.rewardToken?.id)] : 0n;
             let price = tokenPrices[rewarderToken.symbol] || 0;
             if (rewarderToken.symbol === "XSILO") {
-              price = tokenPrices[SILO_TOKEN2.symbol] || 0;
+              price = tokenPrices[SILO_TOKEN.symbol] || 0;
             }
-            const formattedAmount = formatUnitsNum4(
+            const formattedAmount = formatUnitsNum(
               claimableAmount,
               rewarderToken.decimals || 18
             );
             return {
-              address: getAddress4(extraRewards2?.id),
+              address: getAddress(extraRewards2?.id),
               chainId,
               token: rewarderToken,
               amount: claimableAmount,
@@ -6204,7 +7718,7 @@ var getUserAutopoolsRewards = async (wagmiConfig, {
       const tokenRewards = {};
       Object.values(chainUserRewards).forEach((autopoolRewards) => {
         Object.entries(autopoolRewards).forEach(([tokenAddress, amount]) => {
-          const token = getToken2(tokenAddress, chainId);
+          const token = getToken(tokenAddress, chainId);
           const tokenSymbol = token.symbol;
           if (!tokenRewards[tokenSymbol]) {
             tokenRewards[tokenSymbol] = {
@@ -6222,9 +7736,9 @@ var getUserAutopoolsRewards = async (wagmiConfig, {
         ([tokenSymbol, { amount, decimals }]) => {
           let price = tokenPrices[tokenSymbol] || 0;
           if (tokenSymbol === "XSILO") {
-            price = tokenPrices[SILO_TOKEN2.symbol] || 0;
+            price = tokenPrices[SILO_TOKEN.symbol] || 0;
           }
-          const formattedAmount = formatUnitsNum4(amount, decimals || 18);
+          const formattedAmount = formatUnitsNum(amount, decimals || 18);
           tokenRewards[tokenSymbol] = {
             amount,
             formattedAmount,
@@ -6239,7 +7753,7 @@ var getUserAutopoolsRewards = async (wagmiConfig, {
         tokenRewards["TOKE"] = {
           ...undefinedToken,
           USD: undefinedToken.formattedAmount * price,
-          logoURI: TOKE_TOKEN3.logoURI
+          logoURI: TOKE_TOKEN.logoURI
         };
         delete tokenRewards["undefined"];
       }
@@ -6292,29 +7806,14 @@ var getUserAutopoolsRewards = async (wagmiConfig, {
     console.error(e);
   }
 };
-
-// functions/getAmountWithdrawn.ts
-import { formatUnits as formatUnits5 } from "viem";
-import {
-  calculateMinAmountWithSlippage,
-  convertNumToBps
-} from "@tokemak/utils";
-
-// functions/getSwapQuote.ts
-import { TOKEMAK_SWAP_QUOTE_URL } from "@tokemak/constants";
-
-// functions/getAddressFromSystemRegistry.ts
-import { readContract as readContract8 } from "@wagmi/core";
-import { getCoreConfig as getCoreConfig3 } from "@tokemak/config";
-import { systemRegistryAbi as systemRegistryAbi2 } from "@tokemak/abis";
 var getAddressFromSystemRegistry = async (wagmiConfig, {
   chainId,
   functionName
 }) => {
-  const { systemRegistry } = getCoreConfig3(chainId);
-  return await readContract8(wagmiConfig, {
+  const { systemRegistry } = getCoreConfig(chainId);
+  return await readContract(wagmiConfig, {
     address: systemRegistry,
-    abi: systemRegistryAbi2,
+    abi: systemRegistryAbi,
     functionName,
     chainId
   });
@@ -6325,23 +7824,18 @@ var getAutopilotRouter = async (wagmiConfig, { chainId }) => await getAddressFro
   chainId,
   functionName: "autoPoolRouter"
 });
-
-// functions/getSwapQuote.ts
-import { getCoreConfig as getCoreConfig4 } from "@tokemak/config";
-import { ETH_TOKEN as ETH_TOKEN5, WS_TOKEN as WS_TOKEN3, WXPL_TOKEN as WXPL_TOKEN3 } from "@tokemak/tokenlist";
-import { plasma as plasma2, sonic as sonic3 } from "viem/chains";
 var getSwapQuote = async (config, { chainId, ...params }) => {
   try {
     if (!params.sellToken || !params.buyToken) {
       throw new Error("Sell token and buy token are required");
     }
-    if (params.sellToken === ETH_TOKEN5.address) {
-      params.sellToken = getCoreConfig4(chainId).weth;
-      if (chainId === sonic3.id) {
-        params.sellToken = WS_TOKEN3.address;
+    if (params.sellToken === ETH_TOKEN.address) {
+      params.sellToken = getCoreConfig(chainId).weth;
+      if (chainId === sonic.id) {
+        params.sellToken = WS_TOKEN.address;
       }
-      if (chainId === plasma2.id) {
-        params.sellToken = WXPL_TOKEN3.address;
+      if (chainId === plasma.id) {
+        params.sellToken = WXPL_TOKEN.address;
       }
     }
     const sellAmount = params.sellAmount.toString();
@@ -6370,17 +7864,6 @@ var getSwapQuote = async (config, { chainId, ...params }) => {
     return void 0;
   }
 };
-
-// functions/getDynamicSwap.ts
-import { getPublicClient, readContract as readContract9 } from "@wagmi/core";
-import { autopilotRouterAbi, autopoolEthAbi as autopoolEthAbi2 } from "@tokemak/abis";
-import { getCoreConfig as getCoreConfig5 } from "@tokemak/config";
-import { getLiquidations } from "@tokemak/autopilot-swap-route-calc";
-import {
-  ContractFunctionExecutionError,
-  ContractFunctionRevertedError
-} from "viem";
-import { TOKEMAK_DYNAMIC_SWAP_ROUTES_URL } from "@tokemak/constants";
 var placeholderAddress = "0x8b4334d4812c530574bd4f2763fcd22de94a969b";
 var getDynamicSwap = async ({
   address,
@@ -6396,7 +7879,7 @@ var getDynamicSwap = async ({
   let standardPreviewRedeem = false;
   const client = await getPublicClient(config, { chainId });
   try {
-    const { systemRegistry } = getCoreConfig5(chainId);
+    const { systemRegistry } = getCoreConfig(chainId);
     client.transport.retryCount = 0;
     client.transport.transports = [client.transport.transports[0]];
     const liquidations = await getLiquidations(
@@ -6463,9 +7946,9 @@ var getDynamicSwap = async ({
       console.log(e);
     }
   }
-  const previewRedeemOnChain = await readContract9(config, {
+  const previewRedeemOnChain = await readContract(config, {
     address,
-    abi: autopoolEthAbi2,
+    abi: autopoolEthAbi,
     functionName: "previewRedeem",
     args: [amount],
     chainId,
@@ -6481,12 +7964,6 @@ var getDynamicSwap = async ({
     previewRedeem
   };
 };
-
-// functions/getAmountWithdrawn.ts
-import { ETH_TOKEN as ETH_TOKEN6 } from "@tokemak/tokenlist";
-import { getCoreConfig as getCoreConfig6 } from "@tokemak/config";
-import { readContract as readContract10 } from "@wagmi/core";
-import { autopoolEthAbi as autopoolEthAbi3 } from "@tokemak/abis";
 var getAmountWithdrawn = async ({
   address,
   slippage,
@@ -6519,15 +7996,15 @@ var getAmountWithdrawn = async ({
         dynamicSwap?.previewRedeem,
         slippage
       );
-      let minAmount = formatUnits5(minAmountWithSlippage, decimals);
+      let minAmount = formatUnits(minAmountWithSlippage, decimals);
       if (isSwap) {
-        if (buyToken === ETH_TOKEN6.address) {
-          const weth = getCoreConfig6(chainId).weth;
+        if (buyToken === ETH_TOKEN.address) {
+          const weth = getCoreConfig(chainId).weth;
           buyToken = weth;
         }
-        convertedAssets = await readContract10(config, {
+        convertedAssets = await readContract(config, {
           address: autopool,
-          abi: autopoolEthAbi3,
+          abi: autopoolEthAbi,
           functionName: "convertToAssets",
           args: [amount],
           chainId
@@ -6545,7 +8022,7 @@ var getAmountWithdrawn = async ({
           sellAll: true
         });
         if (quote) {
-          minAmount = formatUnits5(BigInt(quote?.minBuyAmount), decimals);
+          minAmount = formatUnits(BigInt(quote?.minBuyAmount), decimals);
         } else {
           throw new Error("No quote found");
         }
@@ -6563,11 +8040,6 @@ var getAmountWithdrawn = async ({
     };
   }
 };
-
-// functions/getAmountDeposited.ts
-import { readContract as readContract11 } from "@wagmi/core";
-import { autopoolEthAbi as autopoolEthAbi4 } from "@tokemak/abis";
-import { calculateMinAmountWithSlippage as calculateMinAmountWithSlippage2, formatEtherNum as formatEtherNum7 } from "@tokemak/utils";
 var getAmountDeposited = async ({
   address,
   chainId,
@@ -6580,21 +8052,21 @@ var getAmountDeposited = async ({
     if (!address || !chainId || !amount || typeof slippage !== "number") {
       throw new Error("Invalid parameters");
     }
-    const previewDeposit = await readContract11(config, {
+    const previewDeposit = await readContract(config, {
       address,
-      abi: autopoolEthAbi4,
+      abi: autopoolEthAbi,
       functionName: "previewDeposit",
       args: [amount],
       chainId
     });
     if (!isSwap) {
-      let minAmountWithSlippage = calculateMinAmountWithSlippage2(
+      let minAmountWithSlippage = calculateMinAmountWithSlippage(
         previewDeposit,
         slippage
       );
-      return formatEtherNum7(minAmountWithSlippage);
+      return formatEtherNum(minAmountWithSlippage);
     } else {
-      return formatEtherNum7(previewDeposit);
+      return formatEtherNum(previewDeposit);
     }
   } catch (e) {
     console.error(e);
@@ -6603,11 +8075,6 @@ var getAmountDeposited = async ({
   }
 };
 
-// functions/getBridgeFee.ts
-import { readContract as readContract12 } from "@wagmi/core";
-import { layerZeroEndpointAbi, oftAdapterAbi } from "@tokemak/abis";
-import { toHex as toHex2 } from "viem";
-
 // ../../node_modules/@ethersproject/logger/lib.esm/_version.js
 var version = "logger/5.8.0";
 
@@ -6798,9 +8265,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",
@@ -7331,7 +8795,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) {
@@ -7349,7 +8813,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, {
@@ -7361,13 +8825,13 @@ var getBridgeFee = async (wagmiConfig, {
   from
 }) => {
   try {
-    const endpoint = await readContract12(wagmiConfig, {
+    const endpoint = await readContract(wagmiConfig, {
       address: destAddress,
       abi: oftAdapterAbi,
       functionName: "endpoint",
       chainId: destChainId
     });
-    const eid = await readContract12(wagmiConfig, {
+    const eid = await readContract(wagmiConfig, {
       address: endpoint,
       abi: layerZeroEndpointAbi,
       functionName: "eid",
@@ -7378,14 +8842,14 @@ var getBridgeFee = async (wagmiConfig, {
     const minAmountLD = amount / factor * factor;
     const sendParams = {
       dstEid: eid,
-      to: toHex2(addressToBytes32(from)),
+      to: toHex$1(addressToBytes32(from)),
       amountLD: amount,
       minAmountLD,
       extraOptions: "0x",
       composeMsg: "0x",
       oftCmd: "0x"
     };
-    const feeQuote = await readContract12(wagmiConfig, {
+    const feeQuote = await readContract(wagmiConfig, {
       address: sourceAddress,
       abi: oftAdapterAbi,
       functionName: "quoteSend",
@@ -7452,47 +8916,27 @@ var waitForMessageReceived = async ({
   }
   throw new Error(`Timeout reached after 20 minutes for message: ${txHash}`);
 };
-
-// functions/getChainUserSToke.ts
-import { accTokeV1Abi as accTokeV1Abi2 } from "@tokemak/abis";
-import { getCoreConfig as getCoreConfig7 } from "@tokemak/config";
-import {
-  convertChainCycleToUnix as convertChainCycleToUnix2,
-  convertSecondsToRemainingTime,
-  formatCurrency as formatCurrency2,
-  formatEtherNum as formatEtherNum8
-} from "@tokemak/utils";
-import { readContracts as readContracts6 } from "@wagmi/core";
-import { formatEther as formatEther2 } from "viem";
-import { sepolia as sepolia2 } from "viem/chains";
-
-// functions/getCurrentCycleId.ts
-import { accTokeV1Abi } from "@tokemak/abis";
-import { readContract as readContract13 } from "@wagmi/core";
 var getCurrentCycleId = async (wagmiConfig, {
   stoke,
   chainId
 }) => {
-  return readContract13(wagmiConfig, {
+  return readContract(wagmiConfig, {
     address: stoke,
     abi: accTokeV1Abi,
     chainId,
     functionName: "getCurrentCycleID"
   });
 };
-
-// functions/getChainUserSToke.ts
-import { getSdkByChainId as getSdkByChainId12 } from "@tokemak/graph-cli";
 var getChainUserSToke = async (wagmiConfig, {
   address,
   tokePrice,
   chainId
 }) => {
   try {
-    const { stoke } = getCoreConfig7(chainId);
+    const { stoke } = getCoreConfig(chainId);
     const cycleIndex = await getCurrentCycleId(wagmiConfig, { chainId, stoke });
     if (address && cycleIndex && stoke && tokePrice) {
-      const { GetUserSTokeBalance } = getSdkByChainId12(
+      const { GetUserSTokeBalance } = getSdkByChainId(
         chainId
       );
       const { accountBalanceV1S } = await GetUserSTokeBalance({
@@ -7501,13 +8945,13 @@ var getChainUserSToke = async (wagmiConfig, {
       const cycleStartBalance = accountBalanceV1S[0]?.cycleStartBalance || 0n;
       const stokeContract = {
         address: stoke,
-        abi: accTokeV1Abi2
+        abi: accTokeV1Abi
       };
       const [
         { result: balance },
         { result: depositInfoResult },
         { result: withdrawalInfoResult }
-      ] = await readContracts6(wagmiConfig, {
+      ] = await readContracts(wagmiConfig, {
         contracts: [
           {
             ...stokeContract,
@@ -7537,8 +8981,8 @@ var getChainUserSToke = async (wagmiConfig, {
         if (withdrawalAmount > 0n && cycleIndex >= withdrawalMinCycle) {
           balanceExcludingWithdrawal = balanceExcludingWithdrawal - withdrawalAmount;
         }
-        const withdrawalAmountUsd = formatCurrency2(
-          formatEtherNum8(withdrawalAmount) * tokePrice
+        const withdrawalAmountUsd = formatCurrency(
+          formatEtherNum(withdrawalAmount) * tokePrice
         );
         const lockDuration = Number(depositLockDuration);
         const lockCycle = Number(depositLockCycle);
@@ -7559,27 +9003,27 @@ var getChainUserSToke = async (wagmiConfig, {
         const withdrawAvailable = lockRenew - 1;
         const hasAddedLockedToke = depositAmount > 0n && depositAmount > rolloverDepositAmount;
         const addedLockedToke = depositAmount - rolloverDepositAmount;
-        const balanceUSD = formatCurrency2(
-          Number(formatEther2(balanceExcludingWithdrawal)) * tokePrice
+        const balanceUSD = formatCurrency(
+          Number(formatEther(balanceExcludingWithdrawal)) * tokePrice
         );
-        const balanceExcludingWithdrawalUsd = formatCurrency2(
-          formatEtherNum8(balanceExcludingWithdrawal) * tokePrice
+        const balanceExcludingWithdrawalUsd = formatCurrency(
+          formatEtherNum(balanceExcludingWithdrawal) * tokePrice
         );
         const isUnlockRequestAvailable = currentCycle === withdrawAvailable;
         const hasRequestedUnlock = withdrawalAmount > 0n;
-        const unlockRequestPeriodStartUnix = convertChainCycleToUnix2(withdrawAvailable, chainId) - Date.now() / 1e3;
-        const unlockRequestPeriodEndUnix = convertChainCycleToUnix2(lockRenew, chainId) - Date.now() / 1e3;
+        const unlockRequestPeriodStartUnix = convertChainCycleToUnix(withdrawAvailable, chainId) - Date.now() / 1e3;
+        const unlockRequestPeriodEndUnix = 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 === sepolia2.id) {
+        if (chainId === sepolia.id) {
           lockDurationInMonths = lockDuration - 1;
         }
         const unlockPeriodDateRangeArray = [
-          new Date(convertChainCycleToUnix2(withdrawAvailable, chainId) * 1e3),
-          new Date(convertChainCycleToUnix2(lockRenew, chainId) * 1e3)
+          new Date(convertChainCycleToUnix(withdrawAvailable, chainId) * 1e3),
+          new Date(convertChainCycleToUnix(lockRenew, chainId) * 1e3)
         ];
         const {
           unlockPeriodDateRange,
@@ -7589,14 +9033,14 @@ var getChainUserSToke = async (wagmiConfig, {
           unlockRenewalDate
         } = formatDateRange(
           unlockPeriodDateRangeArray,
-          chainId === sepolia2.id ? "time" : "date"
+          chainId === sepolia.id ? "time" : "date"
         );
-        const totalActiveUserCredits = formatEtherNum8(balanceExcludingWithdrawal) * lockDurationInMonths;
-        const totalUserCredits = formatEtherNum8(balance) * lockDurationInMonths;
+        const totalActiveUserCredits = formatEtherNum(balanceExcludingWithdrawal) * lockDurationInMonths;
+        const totalUserCredits = formatEtherNum(balance) * lockDurationInMonths;
         return {
           balance,
           balanceUSD,
-          balanceExcludingWithdrawal: hasBalance ? formatEther2(balanceExcludingWithdrawal) : "0.00",
+          balanceExcludingWithdrawal: hasBalance ? formatEther(balanceExcludingWithdrawal) : "0.00",
           balanceExcludingWithdrawalUsd,
           hasBalanceExcludingWithdrawal,
           timeLeftBeforeUnlockRequestAvailable: convertSecondsToRemainingTime(
@@ -7619,7 +9063,7 @@ var getChainUserSToke = async (wagmiConfig, {
           unlockRenewalDate,
           lockDurationInMonths,
           boost: lockDuration,
-          points: formatEtherNum8(balanceExcludingWithdrawal) * lockDuration,
+          points: formatEtherNum(balanceExcludingWithdrawal) * lockDuration,
           totalActiveCredits: totalActiveUserCredits,
           totalCredits: totalUserCredits
         };
@@ -7629,9 +9073,6 @@ var getChainUserSToke = async (wagmiConfig, {
     console.error(error);
   }
 };
-
-// functions/getUserSToke.ts
-import { formatCurrency as formatCurrency3, formatEtherNum as formatEtherNum9 } from "@tokemak/utils";
 var getUserSToke = async (wagmiConfig, {
   address,
   tokePrice,
@@ -7658,8 +9099,8 @@ var getUserSToke = async (wagmiConfig, {
       }
       return acc;
     }, 0n);
-    const totalBalance = formatEtherNum9(totalBalanceRaw || 0n);
-    const totalBalanceUsd = formatCurrency3(totalBalance * tokePrice);
+    const totalBalance = formatEtherNum(totalBalanceRaw || 0n);
+    const totalBalanceUsd = formatCurrency(totalBalance * tokePrice);
     const hasBalance = totalBalance > 0;
     return {
       chains: { ...userSToke },
@@ -7671,32 +9112,19 @@ var getUserSToke = async (wagmiConfig, {
     console.error(e);
   }
 };
-
-// functions/getChainSToke.ts
-import { formatEther as formatEther3 } from "viem";
-import { readContracts as readContracts7 } from "@wagmi/core";
-import { accTokeV1Abi as accTokeV1Abi3 } from "@tokemak/abis";
-import {
-  convertChainCycleToUnix as convertChainCycleToUnix3,
-  convertSecondsToRemainingTime as convertSecondsToRemainingTime2,
-  formatLargeNumber,
-  formatTVL
-} from "@tokemak/utils";
-import { getCoreConfig as getCoreConfig8 } from "@tokemak/config";
-import { getNetwork as getNetwork4 } from "@tokemak/utils";
 var getChainSToke = async (wagmiConfig, {
   tokePrice,
   chainId
 }) => {
   try {
-    const { stoke } = getCoreConfig8(chainId);
+    const { stoke } = getCoreConfig(chainId);
     const baseConfig = {
       address: stoke,
-      abi: accTokeV1Abi3,
+      abi: accTokeV1Abi,
       chainId
     };
     if (stoke && tokePrice) {
-      const [{ result: totalSupply }, { result: currentCycle }] = await readContracts7(wagmiConfig, {
+      const [{ result: totalSupply }, { result: currentCycle }] = await readContracts(wagmiConfig, {
         contracts: [
           {
             ...baseConfig,
@@ -7708,16 +9136,16 @@ var getChainSToke = async (wagmiConfig, {
           }
         ]
       });
-      const tvl = Number(formatEther3(totalSupply || 0n)) * tokePrice;
-      const secondsLeftBeforeNextCycle = convertChainCycleToUnix3(Number(currentCycle) + 1, chainId) - Date.now() / 1e3;
+      const tvl = Number(formatEther(totalSupply || 0n)) * tokePrice;
+      const secondsLeftBeforeNextCycle = convertChainCycleToUnix(Number(currentCycle) + 1, chainId) - Date.now() / 1e3;
       return {
         rawTotalSupply: totalSupply,
-        totalSupply: formatLargeNumber(formatEther3(totalSupply || 0n)),
+        totalSupply: formatLargeNumber(formatEther(totalSupply || 0n)),
         tvl: formatTVL(tvl),
         rawTVL: tvl,
         currentCycle,
-        chain: getNetwork4(chainId),
-        timeBeforeNextCycle: convertSecondsToRemainingTime2(
+        chain: getNetwork(chainId),
+        timeBeforeNextCycle: convertSecondsToRemainingTime(
           secondsLeftBeforeNextCycle
         )
       };
@@ -7726,10 +9154,6 @@ var getChainSToke = async (wagmiConfig, {
     console.error(error);
   }
 };
-
-// functions/getSToke.ts
-import { formatLargeNumber as formatLargeNumber2, formatTVL as formatTVL2 } from "@tokemak/utils";
-import { formatEther as formatEther4 } from "viem";
 var getSToke = async (wagmiConfig, {
   tokePrice,
   includeTestnet = false
@@ -7748,28 +9172,20 @@ var getSToke = async (wagmiConfig, {
       }
       return acc;
     }, 0n);
-    const totalSupply = formatLargeNumber2(formatEther4(totalSupplyBigInt || 0n));
+    const totalSupply = formatLargeNumber(formatEther(totalSupplyBigInt || 0n));
     let tvlNum = Object.values(sToke).reduce((acc, item) => {
       if (item && item.rawTVL) {
         return acc + item.rawTVL;
       }
       return acc;
     }, 0);
-    const tvl = formatTVL2(tvlNum);
+    const tvl = formatTVL(tvlNum);
     return { totalSupply, tvl, rawTVL: tvlNum, chains: { ...sToke } };
   } catch (e) {
     console.error(e);
     throw e;
   }
 };
-
-// functions/getChainCycleRolloverBlockNumber.ts
-import { accTokeV1Abi as accTokeV1Abi4, managerV1Abi } from "@tokemak/abis";
-import {
-  getBlockNumber,
-  getPublicClient as getPublicClient2,
-  readContract as readContract14
-} from "@wagmi/core";
 var getChainCycleRolloverBlockNumber = async (wagmiConfig, {
   stoke,
   chainId
@@ -7777,15 +9193,15 @@ var getChainCycleRolloverBlockNumber = async (wagmiConfig, {
   const scanPeriodInDays = 8;
   const blockTime = 12;
   try {
-    const client = getPublicClient2(wagmiConfig, { chainId });
+    const client = getPublicClient(wagmiConfig, { chainId });
     if (!!client) {
       const blockNumber = await getBlockNumber(wagmiConfig, {
         chainId
       });
-      const manager = await readContract14(wagmiConfig, {
+      const manager = await readContract(wagmiConfig, {
         functionName: "manager",
         address: stoke,
-        abi: accTokeV1Abi4,
+        abi: accTokeV1Abi,
         chainId
       });
       if (!manager) {
@@ -7809,10 +9225,6 @@ var getChainCycleRolloverBlockNumber = async (wagmiConfig, {
     console.error(error);
   }
 };
-
-// functions/getChainUserSTokeVotes.ts
-import { formatEtherNum as formatEtherNum10 } from "@tokemak/utils";
-import { getSdkByChainId as getSdkByChainId13 } from "@tokemak/graph-cli";
 var getChainUserSTokeVotes = async ({
   address,
   chainId = 1,
@@ -7821,7 +9233,7 @@ var getChainUserSTokeVotes = async ({
 }) => {
   try {
     if (address && stokeVotes) {
-      const { GetUserSTokeVotes, GetUserSTokeBalance } = getSdkByChainId13(chainId);
+      const { GetUserSTokeVotes, GetUserSTokeBalance } = getSdkByChainId(chainId);
       const { userVotes } = await GetUserSTokeVotes({
         address: address.toLowerCase()
       });
@@ -7834,10 +9246,10 @@ var getChainUserSTokeVotes = async ({
         subgraphUserVotesData?.pools || [],
         subgraphUserVotesData?.weights || []
       );
-      const stakedToke = formatEtherNum10(
+      const stakedToke = formatEtherNum(
         BigInt(subgraphAccountVotesBalance?.amount || 0n)
       );
-      const totalUserVotes = formatEtherNum10(
+      const totalUserVotes = formatEtherNum(
         BigInt(subgraphAccountVotesBalance?.points || 0n)
       );
       const autopools = {};
@@ -7922,24 +9334,18 @@ var getUserSTokeVotes = async ({
     console.error(e);
   }
 };
-
-// functions/getChainSTokeVotes.ts
-import { AUTOPOOLS_WHITELIST_PROD as AUTOPOOLS_WHITELIST_PROD2 } from "@tokemak/config";
-import { formatEtherNum as formatEtherNum11, formatLargeNumber as formatLargeNumber3 } from "@tokemak/utils";
-import { getAddress as getAddress5 } from "viem";
-import { getSdkByChainId as getSdkByChainId14 } from "@tokemak/graph-cli";
 var getChainSTokeVotes = async ({
   chainId,
   includeTestnet = false
 }) => {
-  const { GetSTokeVotes } = getSdkByChainId14(chainId);
+  const { GetSTokeVotes } = 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) => AUTOPOOLS_WHITELIST_PROD2.includes(getAddress5(pool))
+    (pool) => AUTOPOOLS_WHITELIST_PROD.includes(getAddress(pool))
   );
   const poolCount = whitelistedPools.length;
   const perPoolNotVoted = !!poolCount ? globalNotVoted / BigInt(poolCount) : 0n;
@@ -7956,13 +9362,13 @@ var getChainSTokeVotes = async ({
     updatedPoints
   );
   const globalSystemVotes = globalVoted + globalNotVoted;
-  const totalSystemVotesNum = formatEtherNum11(globalSystemVotes);
+  const totalSystemVotesNum = formatEtherNum(globalSystemVotes);
   const formattedAutopoolVotes = Object.fromEntries(
     Object.entries(autopoolVotes).filter(
       ([poolAddress]) => includeTestnet ? true : whitelistedPools.includes(poolAddress)
     ).map(([poolAddress, rawVote]) => {
-      const formattedVote = formatLargeNumber3(
-        formatEtherNum11(BigInt(rawVote))
+      const formattedVote = formatLargeNumber(
+        formatEtherNum(BigInt(rawVote))
       );
       return [
         poolAddress,
@@ -7977,7 +9383,7 @@ var getChainSTokeVotes = async ({
       globalSystemVotes
     },
     totalSystemVotesNum,
-    totalSystemVotes: formatLargeNumber3(totalSystemVotesNum),
+    totalSystemVotes: formatLargeNumber(totalSystemVotesNum),
     autopoolVotes: formattedAutopoolVotes
   };
 };
@@ -7999,17 +9405,11 @@ var getSTokeVotes = async ({
     console.error(e);
   }
 };
-
-// functions/getChainSTokeRewards.ts
-import { AUTOPOOLS_WHITELIST_PROD as AUTOPOOLS_WHITELIST_PROD3 } from "@tokemak/config";
-import { formatUnits as formatUnits6 } from "viem";
-import { formatEtherNum as formatEtherNum12 } from "@tokemak/utils";
-import { getSdkByChainId as getSdkByChainId15 } from "@tokemak/graph-cli";
 var getChainSTokeRewards = async ({
   chainId
 }) => {
   try {
-    const { GetSTokeRewards } = getSdkByChainId15(chainId);
+    const { GetSTokeRewards } = getSdkByChainId(chainId);
     const { poolRewardsBalances } = await GetSTokeRewards();
     const allPoolRewardsBalanceDayDatas = await paginateQuery(
       GetSTokeRewards,
@@ -8021,15 +9421,15 @@ var getChainSTokeRewards = async ({
     let minApr = null;
     let maxApr = null;
     for (const pool of poolRewardsBalances) {
-      const whitelistedPools = AUTOPOOLS_WHITELIST_PROD3.map(
+      const whitelistedPools = AUTOPOOLS_WHITELIST_PROD.map(
         (address) => address.toLowerCase()
       );
       if (!whitelistedPools.includes(pool.id.toLowerCase())) {
         continue;
       }
-      const convertedBalance = formatEtherNum12(pool.balance);
-      const convertedBalanceUSD = Number(formatUnits6(pool.balanceUSD, 8));
-      const convertedApr = formatEtherNum12(pool.currentAprPerCredit);
+      const convertedBalance = formatEtherNum(pool.balance);
+      const convertedBalanceUSD = Number(formatUnits(pool.balanceUSD, 8));
+      const convertedApr = formatEtherNum(pool.currentAprPerCredit);
       if (minApr === null || convertedApr < minApr) {
         minApr = convertedApr;
       }
@@ -8099,20 +9499,13 @@ var getSTokeRewards = async ({
     throw e;
   }
 };
-
-// functions/getChainUserSTokeRewards.ts
-import {
-  getCoreConfig as getCoreConfig9,
-  getMainnetConfig as getMainnetConfig6
-} from "@tokemak/config";
-import { formatEtherNum as formatEtherNum13 } from "@tokemak/utils";
 var getChainUserSTokeRewards = async (wagmiConfig, {
   address,
   chainId,
   tokePrice
 }) => {
-  const { rewardsV1Url, stokeRewardsHash, stokeRewards } = getMainnetConfig6(1);
-  const { stoke } = getCoreConfig9(chainId);
+  const { rewardsV1Url, stokeRewardsHash, stokeRewards } = getMainnetConfig(1);
+  const { stoke } = getCoreConfig(chainId);
   const currentCycle = await getCurrentCycleId(wagmiConfig, {
     stoke,
     chainId
@@ -8156,14 +9549,14 @@ var getChainUserSTokeRewards = async (wagmiConfig, {
       throw fallbackError;
     }
   }
-  const claimableNum = formatEtherNum13(tokeRewards?.claimable || 0n);
+  const claimableNum = formatEtherNum(tokeRewards?.claimable || 0n);
   const claimableUsd = tokePrice * claimableNum;
   const hasClaimable = claimableNum > 0n;
-  const pendingRewards = formatEtherNum13(
+  const pendingRewards = formatEtherNum(
     tokeRewards?.rewardsPayload.breakdown?.totalRewardAmount || 0n
   );
   const pendingRewardsUsd = tokePrice * pendingRewards;
-  const totalRewardsReceived = formatEtherNum13(
+  const totalRewardsReceived = formatEtherNum(
     tokeRewards.rewardsPayload.payload.amount || 0n
   );
   const totalRewardsReceivedUsd = tokePrice * totalRewardsReceived;
@@ -8178,13 +9571,10 @@ var getChainUserSTokeRewards = async (wagmiConfig, {
     ...tokeRewards
   };
 };
-
-// functions/getChainSubgraphStatus.ts
-import { getSdkByChainId as getSdkByChainId16 } from "@tokemak/graph-cli";
 var getChainSubgraphStatus = async (chain) => {
   const currentTimestamp = Math.floor(Date.now() / 1e3);
   try {
-    const { GetLatestSubgraphTimestamp } = getSdkByChainId16(
+    const { GetLatestSubgraphTimestamp } = getSdkByChainId(
       chain.chainId
     );
     const { _meta } = await GetLatestSubgraphTimestamp();
@@ -8234,19 +9624,8 @@ var getSubgraphStatus = async (includeTestnet = false) => {
   }
   return { isOutOfSync, errorMessage };
 };
-
-// functions/getCycleV1.ts
-import { readContract as readContract15 } from "@wagmi/core";
-import { managerV1Abi as managerV1Abi2 } from "@tokemak/abis";
-import { createPublicClient, http } from "viem";
-import {
-  convertChainCycleToUnix as convertChainCycleToUnix4,
-  convertSecondsToRemainingTime as convertSecondsToRemainingTime3
-} from "@tokemak/utils";
-import { getMainnetConfig as getMainnetConfig7 } from "@tokemak/config";
-import { mainnet as mainnet5 } from "viem/chains";
 var publicClient = createPublicClient({
-  chain: mainnet5,
+  chain: mainnet,
   transport: http("https://mainnet.infura.io/v3/2BtQ5D1QEPHvwgZwKwnZC7WQVhr")
 });
 var getCycleV1 = async (wagmiConfig, {
@@ -8255,12 +9634,12 @@ var getCycleV1 = async (wagmiConfig, {
 }) => {
   const scanPeriodInDays = 8;
   const blockTime = 12;
-  const { managerV1 } = getMainnetConfig7();
+  const { managerV1 } = getMainnetConfig();
   try {
     if (currentBlockNumber && managerV1) {
-      const currentCycleIndex = await readContract15(wagmiConfig, {
+      const currentCycleIndex = await readContract(wagmiConfig, {
         address: managerV1,
-        abi: managerV1Abi2,
+        abi: managerV1Abi,
         functionName: "getCurrentCycleIndex",
         chainId
       });
@@ -8271,16 +9650,16 @@ var getCycleV1 = async (wagmiConfig, {
             Number(currentBlockNumber) - 86400 / blockTime * scanPeriodInDays
           )
         ),
-        abi: managerV1Abi2,
+        abi: 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 = convertChainCycleToUnix4(Number(currentCycleIndex) + 1) - Date.now() / 1e3;
+      const secondsLeftBeforeNextCycle = convertChainCycleToUnix(Number(currentCycleIndex) + 1) - Date.now() / 1e3;
       return {
         currentCycleIndex,
         cycleRolloverBlockNumber,
-        timeBeforeNextCycle: convertSecondsToRemainingTime3(
+        timeBeforeNextCycle: convertSecondsToRemainingTime(
           secondsLeftBeforeNextCycle
         )
       };
@@ -8289,9 +9668,6 @@ var getCycleV1 = async (wagmiConfig, {
     console.error(error);
   }
 };
-
-// functions/getProtocolStats.ts
-import { formatLargeNumber as formatLargeNumber4, formatTVL as formatTVL3 } from "@tokemak/utils";
 var getProtocolStats = async (autopools, stoke, sushiLP) => {
   try {
     if (!autopools || !stoke || !sushiLP) {
@@ -8321,12 +9697,12 @@ var getProtocolStats = async (autopools, stoke, sushiLP) => {
       Object.entries(categories).map(([key, value]) => [
         key,
         {
-          tvl: formatTVL3(value.tvl),
-          supply: formatLargeNumber4(value.supply || 0)
+          tvl: formatTVL(value.tvl),
+          supply: formatLargeNumber(value.supply || 0)
         }
       ])
     );
-    const tvl = formatTVL3(autopoolTVL + stoke.rawTVL + (sushiLP?.tvl || 0));
+    const tvl = formatTVL(autopoolTVL + stoke.rawTVL + (sushiLP?.tvl || 0));
     const vaultAddresses = autopools?.flatMap(
       (pool) => pool.destinations.map((destination) => destination.vaultAddress)
     );
@@ -8334,16 +9710,16 @@ var getProtocolStats = async (autopools, stoke, sushiLP) => {
     const totalDestinations = uniqueVaultAddresses.length;
     return {
       autopools: {
-        tvl: formatTVL3(autopoolTVL),
+        tvl: formatTVL(autopoolTVL),
         tvlNum: autopoolTVL,
         categories: formattedCategories
       },
       stoke: {
-        tvl: formatTVL3(stoke.rawTVL),
+        tvl: formatTVL(stoke.rawTVL),
         totalSupply: `${stoke.totalSupply} TOKE`
       },
       sushiLP: {
-        tvl: formatTVL3(sushiLP?.tvl || 0),
+        tvl: formatTVL(sushiLP?.tvl || 0),
         totalSupply: sushiLP?.totalSupply || 0
       },
       tvl,
@@ -8354,21 +9730,12 @@ var getProtocolStats = async (autopools, stoke, sushiLP) => {
     return null;
   }
 };
-
-// functions/getRebalanceStats.ts
-import { getSdkByChainId as getSdkByChainId17 } from "@tokemak/graph-cli";
-
-// functions/getEthPriceAtBlock.ts
-import { getCoreConfig as getCoreConfig10 } from "@tokemak/config";
-import { readContract as readContract16 } from "@wagmi/core";
-import { rootPriceOracleAbi } from "@tokemak/abis";
-import { USDC_TOKEN as USDC_TOKEN2 } from "@tokemak/tokenlist";
 var getEthPriceAtBlock = async (wagmiConfig, blockNumber, chainId) => {
-  const config = getCoreConfig10(chainId);
+  const config = getCoreConfig(chainId);
   const rootPriceOracle = config.rootPriceOracle;
   const weth = config.weth;
-  const usdc = USDC_TOKEN2.extensions?.bridgeInfo?.[chainId]?.tokenAddress || USDC_TOKEN2.address;
-  const priceAtBlock = await readContract16(wagmiConfig, {
+  const usdc = USDC_TOKEN.extensions?.bridgeInfo?.[chainId]?.tokenAddress || USDC_TOKEN.address;
+  const priceAtBlock = await readContract(wagmiConfig, {
     address: rootPriceOracle,
     abi: rootPriceOracleAbi,
     functionName: "getPriceInQuote",
@@ -8378,14 +9745,9 @@ var getEthPriceAtBlock = async (wagmiConfig, blockNumber, chainId) => {
   });
   return priceAtBlock;
 };
-
-// functions/getRebalanceStats.ts
-import { formatEtherNum as formatEtherNum14, formatUnitsNum as formatUnitsNum5 } from "@tokemak/utils";
-import { USDC_TOKEN as USDC_TOKEN3 } from "@tokemak/tokenlist";
-import { sonic as sonic4 } from "viem/chains";
 var BATCH_SIZE = 500;
 var fetchChainRebalances = async (chainId) => {
-  const { GetAllAutopoolRebalances } = getSdkByChainId17(chainId);
+  const { GetAllAutopoolRebalances } = getSdkByChainId(chainId);
   const allRebalances = await paginateQuery(
     GetAllAutopoolRebalances,
     "autopoolRebalances"
@@ -8399,10 +9761,10 @@ function inferBaseAssetDecimals(rebalance, chainId) {
   if (BigInt(rebalance.tokenOutValueBaseAsset) === BigInt(rebalance.tokenOutValueInEth)) {
     return 18;
   }
-  if (chainId === sonic4.id) {
+  if (chainId === sonic.id) {
     return rebalance.tokenOut.decimals;
   }
-  return USDC_TOKEN3.decimals;
+  return USDC_TOKEN.decimals;
 }
 var getRebalanceValueUsd = async (rebalance, chainId, wagmiConfig) => {
   const ethWei = BigInt(rebalance.tokenOutValueInEth || "0");
@@ -8414,8 +9776,8 @@ var getRebalanceValueUsd = async (rebalance, chainId, wagmiConfig) => {
       BigInt(rebalance.blockNumber),
       chainId
     );
-    const ethUsd = Number(formatUnitsNum5(price, USDC_TOKEN3.decimals));
-    const ethAmt = Number(formatEtherNum14(ethWei));
+    const ethUsd = Number(formatUnitsNum(price, USDC_TOKEN.decimals));
+    const ethAmt = Number(formatEtherNum(ethWei));
     const usd = ethAmt * ethUsd;
     return usd;
   } catch (e) {
@@ -8439,7 +9801,7 @@ var processRebalance = async (rebalance, chainId, wagmiConfig) => {
   }
   const baseDecimals = inferBaseAssetDecimals(rebalance, chainId);
   const baseUsd = Number(
-    formatUnitsNum5(
+    formatUnitsNum(
       BigInt(rebalance.tokenOutValueBaseAsset || "0"),
       baseDecimals
     )
@@ -8527,104 +9889,18 @@ var updateRebalanceStats = async (wagmiConfig, {
   const allRebalances = [...currentRebalances, ...allNewRebalances];
   return calculateRebalanceStats(allRebalances);
 };
-export {
-  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
+   *)
+*/
+
+export { 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 };