@gearbox-protocol/sdk 3.0.0-vfour.147 → 3.0.0-vfour.148

package/dist/cjs/sdk/index.cjs

@@ -14,7 +14,6 @@ var util = require('util');
 var zlib = require('zlib');
 var stream3 = require('stream');
 var events = require('events');
-var decimal_jsLight = require('decimal.js-light');
 
 function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
@@ -9420,7 +9419,7 @@ var require_form_data = __commonJS({
       });
     };
     FormData3.prototype.submit = function(params, cb) {
-      var request, options, defaults2 = { method: "post" };
+      var request, options, defaults3 = { method: "post" };
       if (typeof params == "string") {
         params = parseUrl(params);
         options = populate({
@@ -9428,9 +9427,9 @@ var require_form_data = __commonJS({
           path: params.pathname,
           host: params.hostname,
           protocol: params.protocol
-        }, defaults2);
+        }, defaults3);
       } else {
-        options = populate(params, defaults2);
+        options = populate(params, defaults3);
         if (!options.port) {
           options.port = options.protocol == "https:" ? 443 : 80;
         }
@@ -79088,7 +79087,7 @@ var utils_default = {
 };
 
 // node_modules/axios/lib/core/AxiosError.js
-function AxiosError(message, code, config, request, response) {
+function AxiosError(message, code, config2, request, response) {
   Error.call(this);
   if (Error.captureStackTrace) {
     Error.captureStackTrace(this, this.constructor);
@@ -79098,7 +79097,7 @@ function AxiosError(message, code, config, request, response) {
   this.message = message;
   this.name = "AxiosError";
   code && (this.code = code);
-  config && (this.config = config);
+  config2 && (this.config = config2);
   request && (this.request = request);
   if (response) {
     this.response = response;
@@ -79147,14 +79146,14 @@ var descriptors = {};
 });
 Object.defineProperties(AxiosError, descriptors);
 Object.defineProperty(prototype, "isAxiosError", { value: true });
-AxiosError.from = (error, code, config, request, response, customProps) => {
+AxiosError.from = (error, code, config2, request, response, customProps) => {
   const axiosError = Object.create(prototype);
   utils_default.toFlatObject(error, axiosError, function filter2(obj) {
     return obj !== Error.prototype;
   }, (prop) => {
     return prop !== "isAxiosError";
   });
-  AxiosError.call(axiosError, error.message, code, config, request, response);
+  AxiosError.call(axiosError, error.message, code, config2, request, response);
   axiosError.cause = error;
   axiosError.name = error.name;
   customProps && Object.assign(axiosError, customProps);
@@ -79892,12 +79891,12 @@ var AxiosHeaders_default = AxiosHeaders;
 
 // node_modules/axios/lib/core/transformData.js
 function transformData(fns, response) {
-  const config = this || defaults_default;
-  const context = response || config;
+  const config2 = this || defaults_default;
+  const context = response || config2;
   const headers = AxiosHeaders_default.from(context.headers);
   let data = context.data;
   utils_default.forEach(fns, function transform(fn) {
-    data = fn.call(config, data, headers.normalize(), response ? response.status : void 0);
+    data = fn.call(config2, data, headers.normalize(), response ? response.status : void 0);
   });
   headers.normalize();
   return data;
@@ -79909,8 +79908,8 @@ function isCancel(value) {
 }
 
 // node_modules/axios/lib/cancel/CanceledError.js
-function CanceledError(message, config, request) {
-  AxiosError_default.call(this, message == null ? "canceled" : message, AxiosError_default.ERR_CANCELED, config, request);
+function CanceledError(message, config2, request) {
+  AxiosError_default.call(this, message == null ? "canceled" : message, AxiosError_default.ERR_CANCELED, config2, request);
   this.name = "CanceledError";
 }
 utils_default.inherits(CanceledError, AxiosError_default, {
@@ -80431,11 +80430,11 @@ var resolveFamily = ({ address, family }) => {
   };
 };
 var buildAddressEntry = (address, family) => resolveFamily(utils_default.isObject(address) ? address : { address, family });
-var http_default = isHttpAdapterSupported && function httpAdapter(config) {
+var http_default = isHttpAdapterSupported && function httpAdapter(config2) {
   return wrapAsync(async function dispatchHttpRequest(resolve, reject, onDone) {
-    let { data, lookup, family } = config;
-    const { responseType, responseEncoding } = config;
-    const method = config.method.toUpperCase();
+    let { data, lookup, family } = config2;
+    const { responseType, responseEncoding } = config2;
+    const method = config2.method.toUpperCase();
     let isDone;
     let rejected = false;
     let req;
@@ -80453,11 +80452,11 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
     }
     const emitter = new events.EventEmitter();
     const onFinished = () => {
-      if (config.cancelToken) {
-        config.cancelToken.unsubscribe(abort);
+      if (config2.cancelToken) {
+        config2.cancelToken.unsubscribe(abort);
       }
-      if (config.signal) {
-        config.signal.removeEventListener("abort", abort);
+      if (config2.signal) {
+        config2.signal.removeEventListener("abort", abort);
       }
       emitter.removeAllListeners();
     };
@@ -80469,16 +80468,16 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       }
     });
     function abort(reason) {
-      emitter.emit("abort", !reason || reason.type ? new CanceledError_default(null, config, req) : reason);
+      emitter.emit("abort", !reason || reason.type ? new CanceledError_default(null, config2, req) : reason);
     }
     emitter.once("abort", reject);
-    if (config.cancelToken || config.signal) {
-      config.cancelToken && config.cancelToken.subscribe(abort);
-      if (config.signal) {
-        config.signal.aborted ? abort() : config.signal.addEventListener("abort", abort);
+    if (config2.cancelToken || config2.signal) {
+      config2.cancelToken && config2.cancelToken.subscribe(abort);
+      if (config2.signal) {
+        config2.signal.aborted ? abort() : config2.signal.addEventListener("abort", abort);
       }
     }
-    const fullPath = buildFullPath(config.baseURL, config.url);
+    const fullPath = buildFullPath(config2.baseURL, config2.url);
     const parsed = new URL(fullPath, platform_default.hasBrowserEnv ? platform_default.origin : void 0);
     const protocol = parsed.protocol || supportedProtocols[0];
     if (protocol === "data:") {
@@ -80488,15 +80487,15 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
           status: 405,
           statusText: "method not allowed",
           headers: {},
-          config
+          config: config2
         });
       }
       try {
-        convertedData = fromDataURI(config.url, responseType === "blob", {
-          Blob: config.env && config.env.Blob
+        convertedData = fromDataURI(config2.url, responseType === "blob", {
+          Blob: config2.env && config2.env.Blob
         });
       } catch (err) {
-        throw AxiosError_default.from(err, AxiosError_default.ERR_BAD_REQUEST, config);
+        throw AxiosError_default.from(err, AxiosError_default.ERR_BAD_REQUEST, config2);
       }
       if (responseType === "text") {
         convertedData = convertedData.toString(responseEncoding);
@@ -80511,20 +80510,20 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
         status: 200,
         statusText: "OK",
         headers: new AxiosHeaders_default(),
-        config
+        config: config2
       });
     }
     if (supportedProtocols.indexOf(protocol) === -1) {
       return reject(new AxiosError_default(
         "Unsupported protocol " + protocol,
         AxiosError_default.ERR_BAD_REQUEST,
-        config
+        config2
       ));
     }
-    const headers = AxiosHeaders_default.from(config.headers).normalize();
+    const headers = AxiosHeaders_default.from(config2.headers).normalize();
     headers.set("User-Agent", "axios/" + VERSION, false);
-    const { onUploadProgress, onDownloadProgress } = config;
-    const maxRate = config.maxRate;
+    const { onUploadProgress, onDownloadProgress } = config2;
+    const maxRate = config2.maxRate;
     let maxUploadRate = void 0;
     let maxDownloadRate = void 0;
     if (utils_default.isSpecCompliantForm(data)) {
@@ -80557,15 +80556,15 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
         return reject(new AxiosError_default(
           "Data after transformation must be a string, an ArrayBuffer, a Buffer, or a Stream",
           AxiosError_default.ERR_BAD_REQUEST,
-          config
+          config2
         ));
       }
       headers.setContentLength(data.length, false);
-      if (config.maxBodyLength > -1 && data.length > config.maxBodyLength) {
+      if (config2.maxBodyLength > -1 && data.length > config2.maxBodyLength) {
         return reject(new AxiosError_default(
           "Request body larger than maxBodyLength limit",
           AxiosError_default.ERR_BAD_REQUEST,
-          config
+          config2
         ));
       }
     }
@@ -80592,9 +80591,9 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       ));
     }
     let auth = void 0;
-    if (config.auth) {
-      const username = config.auth.username || "";
-      const password = config.auth.password || "";
+    if (config2.auth) {
+      const username = config2.auth.username || "";
+      const password = config2.auth.password || "";
       auth = username + ":" + password;
     }
     if (!auth && parsed.username) {
@@ -80607,13 +80606,13 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
     try {
       path = buildURL(
         parsed.pathname + parsed.search,
-        config.params,
-        config.paramsSerializer
+        config2.params,
+        config2.paramsSerializer
       ).replace(/^\?/, "");
     } catch (err) {
       const customErr = new Error(err.message);
-      customErr.config = config;
-      customErr.url = config.url;
+      customErr.config = config2;
+      customErr.url = config2.url;
       customErr.exists = true;
       return reject(customErr);
     }
@@ -80626,7 +80625,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       path,
       method,
       headers: headers.toJSON(),
-      agents: { http: config.httpAgent, https: config.httpsAgent },
+      agents: { http: config2.httpAgent, https: config2.httpsAgent },
       auth,
       protocol,
       family,
@@ -80634,36 +80633,36 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       beforeRedirects: {}
     };
     !utils_default.isUndefined(lookup) && (options.lookup = lookup);
-    if (config.socketPath) {
-      options.socketPath = config.socketPath;
+    if (config2.socketPath) {
+      options.socketPath = config2.socketPath;
     } else {
       options.hostname = parsed.hostname.startsWith("[") ? parsed.hostname.slice(1, -1) : parsed.hostname;
       options.port = parsed.port;
-      setProxy(options, config.proxy, protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path);
+      setProxy(options, config2.proxy, protocol + "//" + parsed.hostname + (parsed.port ? ":" + parsed.port : "") + options.path);
     }
     let transport;
     const isHttpsRequest = isHttps.test(options.protocol);
-    options.agent = isHttpsRequest ? config.httpsAgent : config.httpAgent;
-    if (config.transport) {
-      transport = config.transport;
-    } else if (config.maxRedirects === 0) {
+    options.agent = isHttpsRequest ? config2.httpsAgent : config2.httpAgent;
+    if (config2.transport) {
+      transport = config2.transport;
+    } else if (config2.maxRedirects === 0) {
       transport = isHttpsRequest ? https__default.default : http3__default.default;
     } else {
-      if (config.maxRedirects) {
-        options.maxRedirects = config.maxRedirects;
+      if (config2.maxRedirects) {
+        options.maxRedirects = config2.maxRedirects;
       }
-      if (config.beforeRedirect) {
-        options.beforeRedirects.config = config.beforeRedirect;
+      if (config2.beforeRedirect) {
+        options.beforeRedirects.config = config2.beforeRedirect;
       }
       transport = isHttpsRequest ? httpsFollow : httpFollow;
     }
-    if (config.maxBodyLength > -1) {
-      options.maxBodyLength = config.maxBodyLength;
+    if (config2.maxBodyLength > -1) {
+      options.maxBodyLength = config2.maxBodyLength;
     } else {
       options.maxBodyLength = Infinity;
     }
-    if (config.insecureHTTPParser) {
-      options.insecureHTTPParser = config.insecureHTTPParser;
+    if (config2.insecureHTTPParser) {
+      options.insecureHTTPParser = config2.insecureHTTPParser;
     }
     req = transport.request(options, function handleResponse(res) {
       if (req.destroyed) return;
@@ -80684,7 +80683,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       }
       let responseStream = res;
       const lastRequest = res.req || req;
-      if (config.decompress !== false && res.headers["content-encoding"]) {
+      if (config2.decompress !== false && res.headers["content-encoding"]) {
         if (method === "HEAD" || res.statusCode === 204) {
           delete res.headers["content-encoding"];
         }
@@ -80718,7 +80717,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
         status: res.statusCode,
         statusText: res.statusMessage,
         headers: new AxiosHeaders_default(res.headers),
-        config,
+        config: config2,
         request: lastRequest
       };
       if (responseType === "stream") {
@@ -80730,13 +80729,13 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
         responseStream.on("data", function handleStreamData(chunk) {
           responseBuffer.push(chunk);
           totalResponseBytes += chunk.length;
-          if (config.maxContentLength > -1 && totalResponseBytes > config.maxContentLength) {
+          if (config2.maxContentLength > -1 && totalResponseBytes > config2.maxContentLength) {
             rejected = true;
             responseStream.destroy();
             reject(new AxiosError_default(
-              "maxContentLength size of " + config.maxContentLength + " exceeded",
+              "maxContentLength size of " + config2.maxContentLength + " exceeded",
               AxiosError_default.ERR_BAD_RESPONSE,
-              config,
+              config2,
               lastRequest
             ));
           }
@@ -80748,7 +80747,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
           const err = new AxiosError_default(
             "stream has been aborted",
             AxiosError_default.ERR_BAD_RESPONSE,
-            config,
+            config2,
             lastRequest
           );
           responseStream.destroy(err);
@@ -80756,7 +80755,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
         });
         responseStream.on("error", function handleStreamError(err) {
           if (req.destroyed) return;
-          reject(AxiosError_default.from(err, null, config, lastRequest));
+          reject(AxiosError_default.from(err, null, config2, lastRequest));
         });
         responseStream.on("end", function handleStreamEnd() {
           try {
@@ -80769,7 +80768,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
             }
             response.data = responseData;
           } catch (err) {
-            return reject(AxiosError_default.from(err, null, config, response.request, response));
+            return reject(AxiosError_default.from(err, null, config2, response.request, response));
           }
           settle(resolve, reject, response);
         });
@@ -80786,33 +80785,33 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       req.destroy(err);
     });
     req.on("error", function handleRequestError(err) {
-      reject(AxiosError_default.from(err, null, config, req));
+      reject(AxiosError_default.from(err, null, config2, req));
     });
     req.on("socket", function handleRequestSocket(socket) {
       socket.setKeepAlive(true, 1e3 * 60);
     });
-    if (config.timeout) {
-      const timeout = parseInt(config.timeout, 10);
+    if (config2.timeout) {
+      const timeout = parseInt(config2.timeout, 10);
       if (Number.isNaN(timeout)) {
         reject(new AxiosError_default(
           "error trying to parse `config.timeout` to int",
           AxiosError_default.ERR_BAD_OPTION_VALUE,
-          config,
+          config2,
           req
         ));
         return;
       }
       req.setTimeout(timeout, function handleRequestTimeout() {
         if (isDone) return;
-        let timeoutErrorMessage = config.timeout ? "timeout of " + config.timeout + "ms exceeded" : "timeout exceeded";
-        const transitional2 = config.transitional || transitional_default;
-        if (config.timeoutErrorMessage) {
-          timeoutErrorMessage = config.timeoutErrorMessage;
+        let timeoutErrorMessage = config2.timeout ? "timeout of " + config2.timeout + "ms exceeded" : "timeout exceeded";
+        const transitional2 = config2.transitional || transitional_default;
+        if (config2.timeoutErrorMessage) {
+          timeoutErrorMessage = config2.timeoutErrorMessage;
         }
         reject(new AxiosError_default(
           timeoutErrorMessage,
           transitional2.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED,
-          config,
+          config2,
           req
         ));
         abort();
@@ -80830,7 +80829,7 @@ var http_default = isHttpAdapterSupported && function httpAdapter(config) {
       });
       data.on("close", () => {
         if (!ended && !errored) {
-          abort(new CanceledError_default("Request stream has been aborted", config, req));
+          abort(new CanceledError_default("Request stream has been aborted", config2, req));
         }
       });
       data.pipe(req);
@@ -80886,7 +80885,7 @@ var cookies_default = platform_default.hasStandardBrowserEnv ? (
 var headersToObject = (thing) => thing instanceof AxiosHeaders_default ? { ...thing } : thing;
 function mergeConfig(config1, config2) {
   config2 = config2 || {};
-  const config = {};
+  const config3 = {};
   function getMergedValue(target, source, prop, caseless) {
     if (utils_default.isPlainObject(target) && utils_default.isPlainObject(source)) {
       return utils_default.merge.call({ caseless }, target, source);
@@ -80957,17 +80956,17 @@ function mergeConfig(config1, config2) {
   utils_default.forEach(Object.keys(Object.assign({}, config1, config2)), function computeConfigValue(prop) {
     const merge2 = mergeMap[prop] || mergeDeepProperties;
     const configValue = merge2(config1[prop], config2[prop], prop);
-    utils_default.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config[prop] = configValue);
+    utils_default.isUndefined(configValue) && merge2 !== mergeDirectKeys || (config3[prop] = configValue);
   });
-  return config;
+  return config3;
 }
 
 // node_modules/axios/lib/helpers/resolveConfig.js
-var resolveConfig_default = (config) => {
-  const newConfig = mergeConfig({}, config);
+var resolveConfig_default = (config2) => {
+  const newConfig = mergeConfig({}, config2);
   let { data, withXSRFToken, xsrfHeaderName, xsrfCookieName, headers, auth } = newConfig;
   newConfig.headers = headers = AxiosHeaders_default.from(headers);
-  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url), config.params, config.paramsSerializer);
+  newConfig.url = buildURL(buildFullPath(newConfig.baseURL, newConfig.url), config2.params, config2.paramsSerializer);
   if (auth) {
     headers.set(
       "Authorization",
@@ -80997,9 +80996,9 @@ var resolveConfig_default = (config) => {
 
 // node_modules/axios/lib/adapters/xhr.js
 var isXHRAdapterSupported = typeof XMLHttpRequest !== "undefined";
-var xhr_default = isXHRAdapterSupported && function(config) {
+var xhr_default = isXHRAdapterSupported && function(config2) {
   return new Promise(function dispatchXhrRequest(resolve, reject) {
-    const _config = resolveConfig_default(config);
+    const _config = resolveConfig_default(config2);
     let requestData = _config.data;
     const requestHeaders = AxiosHeaders_default.from(_config.headers).normalize();
     let { responseType, onUploadProgress, onDownloadProgress } = _config;
@@ -81028,7 +81027,7 @@ var xhr_default = isXHRAdapterSupported && function(config) {
         status: request.status,
         statusText: request.statusText,
         headers: responseHeaders,
-        config,
+        config: config2,
         request
       };
       settle(function _resolve(value) {
@@ -81057,11 +81056,11 @@ var xhr_default = isXHRAdapterSupported && function(config) {
       if (!request) {
         return;
       }
-      reject(new AxiosError_default("Request aborted", AxiosError_default.ECONNABORTED, config, request));
+      reject(new AxiosError_default("Request aborted", AxiosError_default.ECONNABORTED, config2, request));
       request = null;
     };
     request.onerror = function handleError() {
-      reject(new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config, request));
+      reject(new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config2, request));
       request = null;
     };
     request.ontimeout = function handleTimeout() {
@@ -81073,7 +81072,7 @@ var xhr_default = isXHRAdapterSupported && function(config) {
       reject(new AxiosError_default(
         timeoutErrorMessage,
         transitional2.clarifyTimeoutError ? AxiosError_default.ETIMEDOUT : AxiosError_default.ECONNABORTED,
-        config,
+        config2,
         request
       ));
       request = null;
@@ -81104,7 +81103,7 @@ var xhr_default = isXHRAdapterSupported && function(config) {
         if (!request) {
           return;
         }
-        reject(!cancel || cancel.type ? new CanceledError_default(null, config, request) : cancel);
+        reject(!cancel || cancel.type ? new CanceledError_default(null, config2, request) : cancel);
         request.abort();
         request = null;
       };
@@ -81115,7 +81114,7 @@ var xhr_default = isXHRAdapterSupported && function(config) {
     }
     const protocol = parseProtocol(_config.url);
     if (protocol && platform_default.protocols.indexOf(protocol) === -1) {
-      reject(new AxiosError_default("Unsupported protocol " + protocol + ":", AxiosError_default.ERR_BAD_REQUEST, config));
+      reject(new AxiosError_default("Unsupported protocol " + protocol + ":", AxiosError_default.ERR_BAD_REQUEST, config2));
       return;
     }
     request.send(requestData || null);
@@ -81265,8 +81264,8 @@ var resolvers = {
 };
 isFetchSupported && ((res) => {
   ["text", "arrayBuffer", "blob", "formData", "stream"].forEach((type) => {
-    !resolvers[type] && (resolvers[type] = utils_default.isFunction(res[type]) ? (res2) => res2[type]() : (_, config) => {
-      throw new AxiosError_default(`Response type '${type}' is not supported`, AxiosError_default.ERR_NOT_SUPPORT, config);
+    !resolvers[type] && (resolvers[type] = utils_default.isFunction(res[type]) ? (res2) => res2[type]() : (_, config2) => {
+      throw new AxiosError_default(`Response type '${type}' is not supported`, AxiosError_default.ERR_NOT_SUPPORT, config2);
     });
   });
 })(new Response());
@@ -81298,7 +81297,7 @@ var resolveBodyLength = async (headers, body) => {
   const length = utils_default.toFiniteNumber(headers.getContentLength());
   return length == null ? getBodyLength(body) : length;
 };
-var fetch_default = isFetchSupported && (async (config) => {
+var fetch_default = isFetchSupported && (async (config2) => {
   let {
     url: url2,
     method,
@@ -81312,7 +81311,7 @@ var fetch_default = isFetchSupported && (async (config) => {
     headers,
     withCredentials = "same-origin",
     fetchOptions
-  } = resolveConfig_default(config);
+  } = resolveConfig_default(config2);
   responseType = responseType ? (responseType + "").toLowerCase() : "text";
   let composedSignal = composeSignals_default([signal, cancelToken && cancelToken.toAbortSignal()], timeout);
   let request;
@@ -81373,7 +81372,7 @@ var fetch_default = isFetchSupported && (async (config) => {
       );
     }
     responseType = responseType || "text";
-    let responseData = await resolvers[utils_default.findKey(resolvers, responseType) || "text"](response, config);
+    let responseData = await resolvers[utils_default.findKey(resolvers, responseType) || "text"](response, config2);
     !isStreamResponse && unsubscribe && unsubscribe();
     return await new Promise((resolve, reject) => {
       settle(resolve, reject, {
@@ -81381,7 +81380,7 @@ var fetch_default = isFetchSupported && (async (config) => {
         headers: AxiosHeaders_default.from(response.headers),
         status: response.status,
         statusText: response.statusText,
-        config,
+        config: config2,
         request
       });
     });
@@ -81389,13 +81388,13 @@ var fetch_default = isFetchSupported && (async (config) => {
     unsubscribe && unsubscribe();
     if (err && err.name === "TypeError" && /fetch/i.test(err.message)) {
       throw Object.assign(
-        new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config, request),
+        new AxiosError_default("Network Error", AxiosError_default.ERR_NETWORK, config2, request),
         {
           cause: err.cause || err
         }
       );
     }
-    throw AxiosError_default.from(err, err && err.code, config, request);
+    throw AxiosError_default.from(err, err && err.code, config2, request);
   }
 });
 
@@ -81454,41 +81453,41 @@ var adapters_default = {
 };
 
 // node_modules/axios/lib/core/dispatchRequest.js
-function throwIfCancellationRequested(config) {
-  if (config.cancelToken) {
-    config.cancelToken.throwIfRequested();
+function throwIfCancellationRequested(config2) {
+  if (config2.cancelToken) {
+    config2.cancelToken.throwIfRequested();
   }
-  if (config.signal && config.signal.aborted) {
-    throw new CanceledError_default(null, config);
+  if (config2.signal && config2.signal.aborted) {
+    throw new CanceledError_default(null, config2);
   }
 }
-function dispatchRequest(config) {
-  throwIfCancellationRequested(config);
-  config.headers = AxiosHeaders_default.from(config.headers);
-  config.data = transformData.call(
-    config,
-    config.transformRequest
+function dispatchRequest(config2) {
+  throwIfCancellationRequested(config2);
+  config2.headers = AxiosHeaders_default.from(config2.headers);
+  config2.data = transformData.call(
+    config2,
+    config2.transformRequest
   );
-  if (["post", "put", "patch"].indexOf(config.method) !== -1) {
-    config.headers.setContentType("application/x-www-form-urlencoded", false);
+  if (["post", "put", "patch"].indexOf(config2.method) !== -1) {
+    config2.headers.setContentType("application/x-www-form-urlencoded", false);
   }
-  const adapter = adapters_default.getAdapter(config.adapter || defaults_default.adapter);
-  return adapter(config).then(function onAdapterResolution(response) {
-    throwIfCancellationRequested(config);
+  const adapter = adapters_default.getAdapter(config2.adapter || defaults_default.adapter);
+  return adapter(config2).then(function onAdapterResolution(response) {
+    throwIfCancellationRequested(config2);
     response.data = transformData.call(
-      config,
-      config.transformResponse,
+      config2,
+      config2.transformResponse,
       response
     );
     response.headers = AxiosHeaders_default.from(response.headers);
     return response;
   }, function onAdapterRejection(reason) {
     if (!isCancel(reason)) {
-      throwIfCancellationRequested(config);
+      throwIfCancellationRequested(config2);
       if (reason && reason.response) {
         reason.response.data = transformData.call(
-          config,
-          config.transformResponse,
+          config2,
+          config2.transformResponse,
           reason.response
         );
         reason.response.headers = AxiosHeaders_default.from(reason.response.headers);
@@ -81580,9 +81579,9 @@ var Axios = class {
    *
    * @returns {Promise} The Promise to be fulfilled
    */
-  async request(configOrUrl, config) {
+  async request(configOrUrl, config2) {
     try {
-      return await this._request(configOrUrl, config);
+      return await this._request(configOrUrl, config2);
     } catch (err) {
       if (err instanceof Error) {
         let dummy = {};
@@ -81600,15 +81599,15 @@ var Axios = class {
       throw err;
     }
   }
-  _request(configOrUrl, config) {
+  _request(configOrUrl, config2) {
     if (typeof configOrUrl === "string") {
-      config = config || {};
-      config.url = configOrUrl;
+      config2 = config2 || {};
+      config2.url = configOrUrl;
     } else {
-      config = configOrUrl || {};
+      config2 = configOrUrl || {};
     }
-    config = mergeConfig(this.defaults, config);
-    const { transitional: transitional2, paramsSerializer, headers } = config;
+    config2 = mergeConfig(this.defaults, config2);
+    const { transitional: transitional2, paramsSerializer, headers } = config2;
     if (transitional2 !== void 0) {
       validator_default.assertOptions(transitional2, {
         silentJSONParsing: validators2.transitional(validators2.boolean),
@@ -81618,7 +81617,7 @@ var Axios = class {
     }
     if (paramsSerializer != null) {
       if (utils_default.isFunction(paramsSerializer)) {
-        config.paramsSerializer = {
+        config2.paramsSerializer = {
           serialize: paramsSerializer
         };
       } else {
@@ -81628,14 +81627,14 @@ var Axios = class {
         }, true);
       }
     }
-    validator_default.assertOptions(config, {
+    validator_default.assertOptions(config2, {
       baseUrl: validators2.spelling("baseURL"),
       withXsrfToken: validators2.spelling("withXSRFToken")
     }, true);
-    config.method = (config.method || this.defaults.method || "get").toLowerCase();
+    config2.method = (config2.method || this.defaults.method || "get").toLowerCase();
     let contextHeaders = headers && utils_default.merge(
       headers.common,
-      headers[config.method]
+      headers[config2.method]
     );
     headers && utils_default.forEach(
       ["delete", "get", "head", "post", "put", "patch", "common"],
@@ -81643,11 +81642,11 @@ var Axios = class {
         delete headers[method];
       }
     );
-    config.headers = AxiosHeaders_default.concat(contextHeaders, headers);
+    config2.headers = AxiosHeaders_default.concat(contextHeaders, headers);
     const requestInterceptorChain = [];
     let synchronousRequestInterceptors = true;
     this.interceptors.request.forEach(function unshiftRequestInterceptors(interceptor) {
-      if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config) === false) {
+      if (typeof interceptor.runWhen === "function" && interceptor.runWhen(config2) === false) {
         return;
       }
       synchronousRequestInterceptors = synchronousRequestInterceptors && interceptor.synchronous;
@@ -81665,14 +81664,14 @@ var Axios = class {
       chain.unshift.apply(chain, requestInterceptorChain);
       chain.push.apply(chain, responseInterceptorChain);
       len = chain.length;
-      promise = Promise.resolve(config);
+      promise = Promise.resolve(config2);
       while (i < len) {
         promise = promise.then(chain[i++], chain[i++]);
       }
       return promise;
     }
     len = requestInterceptorChain.length;
-    let newConfig = config;
+    let newConfig = config2;
     i = 0;
     while (i < len) {
       const onFulfilled = requestInterceptorChain[i++];
@@ -81696,25 +81695,25 @@ var Axios = class {
     }
     return promise;
   }
-  getUri(config) {
-    config = mergeConfig(this.defaults, config);
-    const fullPath = buildFullPath(config.baseURL, config.url);
-    return buildURL(fullPath, config.params, config.paramsSerializer);
+  getUri(config2) {
+    config2 = mergeConfig(this.defaults, config2);
+    const fullPath = buildFullPath(config2.baseURL, config2.url);
+    return buildURL(fullPath, config2.params, config2.paramsSerializer);
   }
 };
 utils_default.forEach(["delete", "get", "head", "options"], function forEachMethodNoData(method) {
-  Axios.prototype[method] = function(url2, config) {
-    return this.request(mergeConfig(config || {}, {
+  Axios.prototype[method] = function(url2, config2) {
+    return this.request(mergeConfig(config2 || {}, {
       method,
       url: url2,
-      data: (config || {}).data
+      data: (config2 || {}).data
     }));
   };
 });
 utils_default.forEach(["post", "put", "patch"], function forEachMethodWithData(method) {
   function generateHTTPMethod(isForm) {
-    return function httpMethod(url2, data, config) {
-      return this.request(mergeConfig(config || {}, {
+    return function httpMethod(url2, data, config2) {
+      return this.request(mergeConfig(config2 || {}, {
         method,
         headers: isForm ? {
           "Content-Type": "multipart/form-data"
@@ -81759,11 +81758,11 @@ var CancelToken = class _CancelToken {
       };
       return promise;
     };
-    executor(function cancel(message, config, request) {
+    executor(function cancel(message, config2, request) {
       if (token.reason) {
         return;
       }
-      token.reason = new CanceledError_default(message, config, request);
+      token.reason = new CanceledError_default(message, config2, request);
       resolvePromise(token.reason);
     });
   }
@@ -82431,19 +82430,1002 @@ var PriceUtils = class {
     return totalMoney * 10n ** BigInt(targetDecimals) * PRICE_DECIMALS / targetPrice / WAD;
   }
 };
+
+// node_modules/decimal.js-light/decimal.mjs
+var MAX_DIGITS = 1e9;
+var defaults2 = {
+  // These values must be integers within the stated ranges (inclusive).
+  // Most of these values can be changed during run-time using `Decimal.config`.
+  // The maximum number of significant digits of the result of a calculation or base conversion.
+  // E.g. `Decimal.config({ precision: 20 });`
+  precision: 20,
+  // 1 to MAX_DIGITS
+  // The rounding mode used by default by `toInteger`, `toDecimalPlaces`, `toExponential`,
+  // `toFixed`, `toPrecision` and `toSignificantDigits`.
+  //
+  // ROUND_UP         0 Away from zero.
+  // ROUND_DOWN       1 Towards zero.
+  // ROUND_CEIL       2 Towards +Infinity.
+  // ROUND_FLOOR      3 Towards -Infinity.
+  // ROUND_HALF_UP    4 Towards nearest neighbour. If equidistant, up.
+  // ROUND_HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.
+  // ROUND_HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.
+  // ROUND_HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.
+  // ROUND_HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.
+  //
+  // E.g.
+  // `Decimal.rounding = 4;`
+  // `Decimal.rounding = Decimal.ROUND_HALF_UP;`
+  rounding: 4,
+  // 0 to 8
+  // The exponent value at and beneath which `toString` returns exponential notation.
+  // JavaScript numbers: -7
+  toExpNeg: -7,
+  // 0 to -MAX_E
+  // The exponent value at and above which `toString` returns exponential notation.
+  // JavaScript numbers: 21
+  toExpPos: 21,
+  // 0 to MAX_E
+  // The natural logarithm of 10.
+  // 115 digits
+  LN10: "2.302585092994045684017991454684364207601101488628772976033327900967572609677352480235997205089598298341967784042286"
+};
+var Decimal;
+var external = true;
+var decimalError = "[DecimalError] ";
+var invalidArgument = decimalError + "Invalid argument: ";
+var exponentOutOfRange = decimalError + "Exponent out of range: ";
+var mathfloor = Math.floor;
+var mathpow = Math.pow;
+var isDecimal = /^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
+var ONE;
+var BASE = 1e7;
+var LOG_BASE = 7;
+var MAX_SAFE_INTEGER = 9007199254740991;
+var MAX_E = mathfloor(MAX_SAFE_INTEGER / LOG_BASE);
+var P = {};
+P.absoluteValue = P.abs = function() {
+  var x = new this.constructor(this);
+  if (x.s) x.s = 1;
+  return x;
+};
+P.comparedTo = P.cmp = function(y) {
+  var i, j, xdL, ydL, x = this;
+  y = new x.constructor(y);
+  if (x.s !== y.s) return x.s || -y.s;
+  if (x.e !== y.e) return x.e > y.e ^ x.s < 0 ? 1 : -1;
+  xdL = x.d.length;
+  ydL = y.d.length;
+  for (i = 0, j = xdL < ydL ? xdL : ydL; i < j; ++i) {
+    if (x.d[i] !== y.d[i]) return x.d[i] > y.d[i] ^ x.s < 0 ? 1 : -1;
+  }
+  return xdL === ydL ? 0 : xdL > ydL ^ x.s < 0 ? 1 : -1;
+};
+P.decimalPlaces = P.dp = function() {
+  var x = this, w = x.d.length - 1, dp = (w - x.e) * LOG_BASE;
+  w = x.d[w];
+  if (w) for (; w % 10 == 0; w /= 10) dp--;
+  return dp < 0 ? 0 : dp;
+};
+P.dividedBy = P.div = function(y) {
+  return divide(this, new this.constructor(y));
+};
+P.dividedToIntegerBy = P.idiv = function(y) {
+  var x = this, Ctor = x.constructor;
+  return round(divide(x, new Ctor(y), 0, 1), Ctor.precision);
+};
+P.equals = P.eq = function(y) {
+  return !this.cmp(y);
+};
+P.exponent = function() {
+  return getBase10Exponent(this);
+};
+P.greaterThan = P.gt = function(y) {
+  return this.cmp(y) > 0;
+};
+P.greaterThanOrEqualTo = P.gte = function(y) {
+  return this.cmp(y) >= 0;
+};
+P.isInteger = P.isint = function() {
+  return this.e > this.d.length - 2;
+};
+P.isNegative = P.isneg = function() {
+  return this.s < 0;
+};
+P.isPositive = P.ispos = function() {
+  return this.s > 0;
+};
+P.isZero = function() {
+  return this.s === 0;
+};
+P.lessThan = P.lt = function(y) {
+  return this.cmp(y) < 0;
+};
+P.lessThanOrEqualTo = P.lte = function(y) {
+  return this.cmp(y) < 1;
+};
+P.logarithm = P.log = function(base2) {
+  var r, x = this, Ctor = x.constructor, pr = Ctor.precision, wpr = pr + 5;
+  if (base2 === void 0) {
+    base2 = new Ctor(10);
+  } else {
+    base2 = new Ctor(base2);
+    if (base2.s < 1 || base2.eq(ONE)) throw Error(decimalError + "NaN");
+  }
+  if (x.s < 1) throw Error(decimalError + (x.s ? "NaN" : "-Infinity"));
+  if (x.eq(ONE)) return new Ctor(0);
+  external = false;
+  r = divide(ln(x, wpr), ln(base2, wpr), wpr);
+  external = true;
+  return round(r, pr);
+};
+P.minus = P.sub = function(y) {
+  var x = this;
+  y = new x.constructor(y);
+  return x.s == y.s ? subtract(x, y) : add(x, (y.s = -y.s, y));
+};
+P.modulo = P.mod = function(y) {
+  var q, x = this, Ctor = x.constructor, pr = Ctor.precision;
+  y = new Ctor(y);
+  if (!y.s) throw Error(decimalError + "NaN");
+  if (!x.s) return round(new Ctor(x), pr);
+  external = false;
+  q = divide(x, y, 0, 1).times(y);
+  external = true;
+  return x.minus(q);
+};
+P.naturalExponential = P.exp = function() {
+  return exp(this);
+};
+P.naturalLogarithm = P.ln = function() {
+  return ln(this);
+};
+P.negated = P.neg = function() {
+  var x = new this.constructor(this);
+  x.s = -x.s || 0;
+  return x;
+};
+P.plus = P.add = function(y) {
+  var x = this;
+  y = new x.constructor(y);
+  return x.s == y.s ? add(x, y) : subtract(x, (y.s = -y.s, y));
+};
+P.precision = P.sd = function(z) {
+  var e, sd, w, x = this;
+  if (z !== void 0 && z !== !!z && z !== 1 && z !== 0) throw Error(invalidArgument + z);
+  e = getBase10Exponent(x) + 1;
+  w = x.d.length - 1;
+  sd = w * LOG_BASE + 1;
+  w = x.d[w];
+  if (w) {
+    for (; w % 10 == 0; w /= 10) sd--;
+    for (w = x.d[0]; w >= 10; w /= 10) sd++;
+  }
+  return z && e > sd ? e : sd;
+};
+P.squareRoot = P.sqrt = function() {
+  var e, n, pr, r, s, t, wpr, x = this, Ctor = x.constructor;
+  if (x.s < 1) {
+    if (!x.s) return new Ctor(0);
+    throw Error(decimalError + "NaN");
+  }
+  e = getBase10Exponent(x);
+  external = false;
+  s = Math.sqrt(+x);
+  if (s == 0 || s == 1 / 0) {
+    n = digitsToString(x.d);
+    if ((n.length + e) % 2 == 0) n += "0";
+    s = Math.sqrt(n);
+    e = mathfloor((e + 1) / 2) - (e < 0 || e % 2);
+    if (s == 1 / 0) {
+      n = "5e" + e;
+    } else {
+      n = s.toExponential();
+      n = n.slice(0, n.indexOf("e") + 1) + e;
+    }
+    r = new Ctor(n);
+  } else {
+    r = new Ctor(s.toString());
+  }
+  pr = Ctor.precision;
+  s = wpr = pr + 3;
+  for (; ; ) {
+    t = r;
+    r = t.plus(divide(x, t, wpr + 2)).times(0.5);
+    if (digitsToString(t.d).slice(0, wpr) === (n = digitsToString(r.d)).slice(0, wpr)) {
+      n = n.slice(wpr - 3, wpr + 1);
+      if (s == wpr && n == "4999") {
+        round(t, pr + 1, 0);
+        if (t.times(t).eq(x)) {
+          r = t;
+          break;
+        }
+      } else if (n != "9999") {
+        break;
+      }
+      wpr += 4;
+    }
+  }
+  external = true;
+  return round(r, pr);
+};
+P.times = P.mul = function(y) {
+  var carry, e, i, k, r, rL, t, xdL, ydL, x = this, Ctor = x.constructor, xd = x.d, yd = (y = new Ctor(y)).d;
+  if (!x.s || !y.s) return new Ctor(0);
+  y.s *= x.s;
+  e = x.e + y.e;
+  xdL = xd.length;
+  ydL = yd.length;
+  if (xdL < ydL) {
+    r = xd;
+    xd = yd;
+    yd = r;
+    rL = xdL;
+    xdL = ydL;
+    ydL = rL;
+  }
+  r = [];
+  rL = xdL + ydL;
+  for (i = rL; i--; ) r.push(0);
+  for (i = ydL; --i >= 0; ) {
+    carry = 0;
+    for (k = xdL + i; k > i; ) {
+      t = r[k] + yd[i] * xd[k - i - 1] + carry;
+      r[k--] = t % BASE | 0;
+      carry = t / BASE | 0;
+    }
+    r[k] = (r[k] + carry) % BASE | 0;
+  }
+  for (; !r[--rL]; ) r.pop();
+  if (carry) ++e;
+  else r.shift();
+  y.d = r;
+  y.e = e;
+  return external ? round(y, Ctor.precision) : y;
+};
+P.toDecimalPlaces = P.todp = function(dp, rm) {
+  var x = this, Ctor = x.constructor;
+  x = new Ctor(x);
+  if (dp === void 0) return x;
+  checkInt32(dp, 0, MAX_DIGITS);
+  if (rm === void 0) rm = Ctor.rounding;
+  else checkInt32(rm, 0, 8);
+  return round(x, dp + getBase10Exponent(x) + 1, rm);
+};
+P.toExponential = function(dp, rm) {
+  var str, x = this, Ctor = x.constructor;
+  if (dp === void 0) {
+    str = toString3(x, true);
+  } else {
+    checkInt32(dp, 0, MAX_DIGITS);
+    if (rm === void 0) rm = Ctor.rounding;
+    else checkInt32(rm, 0, 8);
+    x = round(new Ctor(x), dp + 1, rm);
+    str = toString3(x, true, dp + 1);
+  }
+  return str;
+};
+P.toFixed = function(dp, rm) {
+  var str, y, x = this, Ctor = x.constructor;
+  if (dp === void 0) return toString3(x);
+  checkInt32(dp, 0, MAX_DIGITS);
+  if (rm === void 0) rm = Ctor.rounding;
+  else checkInt32(rm, 0, 8);
+  y = round(new Ctor(x), dp + getBase10Exponent(x) + 1, rm);
+  str = toString3(y.abs(), false, dp + getBase10Exponent(y) + 1);
+  return x.isneg() && !x.isZero() ? "-" + str : str;
+};
+P.toInteger = P.toint = function() {
+  var x = this, Ctor = x.constructor;
+  return round(new Ctor(x), getBase10Exponent(x) + 1, Ctor.rounding);
+};
+P.toNumber = function() {
+  return +this;
+};
+P.toPower = P.pow = function(y) {
+  var e, k, pr, r, sign, yIsInt, x = this, Ctor = x.constructor, guard = 12, yn = +(y = new Ctor(y));
+  if (!y.s) return new Ctor(ONE);
+  x = new Ctor(x);
+  if (!x.s) {
+    if (y.s < 1) throw Error(decimalError + "Infinity");
+    return x;
+  }
+  if (x.eq(ONE)) return x;
+  pr = Ctor.precision;
+  if (y.eq(ONE)) return round(x, pr);
+  e = y.e;
+  k = y.d.length - 1;
+  yIsInt = e >= k;
+  sign = x.s;
+  if (!yIsInt) {
+    if (sign < 0) throw Error(decimalError + "NaN");
+  } else if ((k = yn < 0 ? -yn : yn) <= MAX_SAFE_INTEGER) {
+    r = new Ctor(ONE);
+    e = Math.ceil(pr / LOG_BASE + 4);
+    external = false;
+    for (; ; ) {
+      if (k % 2) {
+        r = r.times(x);
+        truncate(r.d, e);
+      }
+      k = mathfloor(k / 2);
+      if (k === 0) break;
+      x = x.times(x);
+      truncate(x.d, e);
+    }
+    external = true;
+    return y.s < 0 ? new Ctor(ONE).div(r) : round(r, pr);
+  }
+  sign = sign < 0 && y.d[Math.max(e, k)] & 1 ? -1 : 1;
+  x.s = 1;
+  external = false;
+  r = y.times(ln(x, pr + guard));
+  external = true;
+  r = exp(r);
+  r.s = sign;
+  return r;
+};
+P.toPrecision = function(sd, rm) {
+  var e, str, x = this, Ctor = x.constructor;
+  if (sd === void 0) {
+    e = getBase10Exponent(x);
+    str = toString3(x, e <= Ctor.toExpNeg || e >= Ctor.toExpPos);
+  } else {
+    checkInt32(sd, 1, MAX_DIGITS);
+    if (rm === void 0) rm = Ctor.rounding;
+    else checkInt32(rm, 0, 8);
+    x = round(new Ctor(x), sd, rm);
+    e = getBase10Exponent(x);
+    str = toString3(x, sd <= e || e <= Ctor.toExpNeg, sd);
+  }
+  return str;
+};
+P.toSignificantDigits = P.tosd = function(sd, rm) {
+  var x = this, Ctor = x.constructor;
+  if (sd === void 0) {
+    sd = Ctor.precision;
+    rm = Ctor.rounding;
+  } else {
+    checkInt32(sd, 1, MAX_DIGITS);
+    if (rm === void 0) rm = Ctor.rounding;
+    else checkInt32(rm, 0, 8);
+  }
+  return round(new Ctor(x), sd, rm);
+};
+P.toString = P.valueOf = P.val = P.toJSON = P[Symbol.for("nodejs.util.inspect.custom")] = function() {
+  var x = this, e = getBase10Exponent(x), Ctor = x.constructor;
+  return toString3(x, e <= Ctor.toExpNeg || e >= Ctor.toExpPos);
+};
+function add(x, y) {
+  var carry, d, e, i, k, len, xd, yd, Ctor = x.constructor, pr = Ctor.precision;
+  if (!x.s || !y.s) {
+    if (!y.s) y = new Ctor(x);
+    return external ? round(y, pr) : y;
+  }
+  xd = x.d;
+  yd = y.d;
+  k = x.e;
+  e = y.e;
+  xd = xd.slice();
+  i = k - e;
+  if (i) {
+    if (i < 0) {
+      d = xd;
+      i = -i;
+      len = yd.length;
+    } else {
+      d = yd;
+      e = k;
+      len = xd.length;
+    }
+    k = Math.ceil(pr / LOG_BASE);
+    len = k > len ? k + 1 : len + 1;
+    if (i > len) {
+      i = len;
+      d.length = 1;
+    }
+    d.reverse();
+    for (; i--; ) d.push(0);
+    d.reverse();
+  }
+  len = xd.length;
+  i = yd.length;
+  if (len - i < 0) {
+    i = len;
+    d = yd;
+    yd = xd;
+    xd = d;
+  }
+  for (carry = 0; i; ) {
+    carry = (xd[--i] = xd[i] + yd[i] + carry) / BASE | 0;
+    xd[i] %= BASE;
+  }
+  if (carry) {
+    xd.unshift(carry);
+    ++e;
+  }
+  for (len = xd.length; xd[--len] == 0; ) xd.pop();
+  y.d = xd;
+  y.e = e;
+  return external ? round(y, pr) : y;
+}
+function checkInt32(i, min, max) {
+  if (i !== ~~i || i < min || i > max) {
+    throw Error(invalidArgument + i);
+  }
+}
+function digitsToString(d) {
+  var i, k, ws, indexOfLastWord = d.length - 1, str = "", w = d[0];
+  if (indexOfLastWord > 0) {
+    str += w;
+    for (i = 1; i < indexOfLastWord; i++) {
+      ws = d[i] + "";
+      k = LOG_BASE - ws.length;
+      if (k) str += getZeroString(k);
+      str += ws;
+    }
+    w = d[i];
+    ws = w + "";
+    k = LOG_BASE - ws.length;
+    if (k) str += getZeroString(k);
+  } else if (w === 0) {
+    return "0";
+  }
+  for (; w % 10 === 0; ) w /= 10;
+  return str + w;
+}
+var divide = /* @__PURE__ */ function() {
+  function multiplyInteger(x, k) {
+    var temp, carry = 0, i = x.length;
+    for (x = x.slice(); i--; ) {
+      temp = x[i] * k + carry;
+      x[i] = temp % BASE | 0;
+      carry = temp / BASE | 0;
+    }
+    if (carry) x.unshift(carry);
+    return x;
+  }
+  function compare(a, b, aL, bL) {
+    var i, r;
+    if (aL != bL) {
+      r = aL > bL ? 1 : -1;
+    } else {
+      for (i = r = 0; i < aL; i++) {
+        if (a[i] != b[i]) {
+          r = a[i] > b[i] ? 1 : -1;
+          break;
+        }
+      }
+    }
+    return r;
+  }
+  function subtract2(a, b, aL) {
+    var i = 0;
+    for (; aL--; ) {
+      a[aL] -= i;
+      i = a[aL] < b[aL] ? 1 : 0;
+      a[aL] = i * BASE + a[aL] - b[aL];
+    }
+    for (; !a[0] && a.length > 1; ) a.shift();
+  }
+  return function(x, y, pr, dp) {
+    var cmp, e, i, k, prod, prodL, q, qd, rem, remL, rem0, sd, t, xi, xL, yd0, yL, yz, Ctor = x.constructor, sign = x.s == y.s ? 1 : -1, xd = x.d, yd = y.d;
+    if (!x.s) return new Ctor(x);
+    if (!y.s) throw Error(decimalError + "Division by zero");
+    e = x.e - y.e;
+    yL = yd.length;
+    xL = xd.length;
+    q = new Ctor(sign);
+    qd = q.d = [];
+    for (i = 0; yd[i] == (xd[i] || 0); ) ++i;
+    if (yd[i] > (xd[i] || 0)) --e;
+    if (pr == null) {
+      sd = pr = Ctor.precision;
+    } else if (dp) {
+      sd = pr + (getBase10Exponent(x) - getBase10Exponent(y)) + 1;
+    } else {
+      sd = pr;
+    }
+    if (sd < 0) return new Ctor(0);
+    sd = sd / LOG_BASE + 2 | 0;
+    i = 0;
+    if (yL == 1) {
+      k = 0;
+      yd = yd[0];
+      sd++;
+      for (; (i < xL || k) && sd--; i++) {
+        t = k * BASE + (xd[i] || 0);
+        qd[i] = t / yd | 0;
+        k = t % yd | 0;
+      }
+    } else {
+      k = BASE / (yd[0] + 1) | 0;
+      if (k > 1) {
+        yd = multiplyInteger(yd, k);
+        xd = multiplyInteger(xd, k);
+        yL = yd.length;
+        xL = xd.length;
+      }
+      xi = yL;
+      rem = xd.slice(0, yL);
+      remL = rem.length;
+      for (; remL < yL; ) rem[remL++] = 0;
+      yz = yd.slice();
+      yz.unshift(0);
+      yd0 = yd[0];
+      if (yd[1] >= BASE / 2) ++yd0;
+      do {
+        k = 0;
+        cmp = compare(yd, rem, yL, remL);
+        if (cmp < 0) {
+          rem0 = rem[0];
+          if (yL != remL) rem0 = rem0 * BASE + (rem[1] || 0);
+          k = rem0 / yd0 | 0;
+          if (k > 1) {
+            if (k >= BASE) k = BASE - 1;
+            prod = multiplyInteger(yd, k);
+            prodL = prod.length;
+            remL = rem.length;
+            cmp = compare(prod, rem, prodL, remL);
+            if (cmp == 1) {
+              k--;
+              subtract2(prod, yL < prodL ? yz : yd, prodL);
+            }
+          } else {
+            if (k == 0) cmp = k = 1;
+            prod = yd.slice();
+          }
+          prodL = prod.length;
+          if (prodL < remL) prod.unshift(0);
+          subtract2(rem, prod, remL);
+          if (cmp == -1) {
+            remL = rem.length;
+            cmp = compare(yd, rem, yL, remL);
+            if (cmp < 1) {
+              k++;
+              subtract2(rem, yL < remL ? yz : yd, remL);
+            }
+          }
+          remL = rem.length;
+        } else if (cmp === 0) {
+          k++;
+          rem = [0];
+        }
+        qd[i++] = k;
+        if (cmp && rem[0]) {
+          rem[remL++] = xd[xi] || 0;
+        } else {
+          rem = [xd[xi]];
+          remL = 1;
+        }
+      } while ((xi++ < xL || rem[0] !== void 0) && sd--);
+    }
+    if (!qd[0]) qd.shift();
+    q.e = e;
+    return round(q, dp ? pr + getBase10Exponent(q) + 1 : pr);
+  };
+}();
+function exp(x, sd) {
+  var denominator, guard, pow, sum, t, wpr, i = 0, k = 0, Ctor = x.constructor, pr = Ctor.precision;
+  if (getBase10Exponent(x) > 16) throw Error(exponentOutOfRange + getBase10Exponent(x));
+  if (!x.s) return new Ctor(ONE);
+  if (sd == null) {
+    external = false;
+    wpr = pr;
+  } else {
+    wpr = sd;
+  }
+  t = new Ctor(0.03125);
+  while (x.abs().gte(0.1)) {
+    x = x.times(t);
+    k += 5;
+  }
+  guard = Math.log(mathpow(2, k)) / Math.LN10 * 2 + 5 | 0;
+  wpr += guard;
+  denominator = pow = sum = new Ctor(ONE);
+  Ctor.precision = wpr;
+  for (; ; ) {
+    pow = round(pow.times(x), wpr);
+    denominator = denominator.times(++i);
+    t = sum.plus(divide(pow, denominator, wpr));
+    if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {
+      while (k--) sum = round(sum.times(sum), wpr);
+      Ctor.precision = pr;
+      return sd == null ? (external = true, round(sum, pr)) : sum;
+    }
+    sum = t;
+  }
+}
+function getBase10Exponent(x) {
+  var e = x.e * LOG_BASE, w = x.d[0];
+  for (; w >= 10; w /= 10) e++;
+  return e;
+}
+function getLn10(Ctor, sd, pr) {
+  if (sd > Ctor.LN10.sd()) {
+    external = true;
+    if (pr) Ctor.precision = pr;
+    throw Error(decimalError + "LN10 precision limit exceeded");
+  }
+  return round(new Ctor(Ctor.LN10), sd);
+}
+function getZeroString(k) {
+  var zs = "";
+  for (; k--; ) zs += "0";
+  return zs;
+}
+function ln(y, sd) {
+  var c, c0, denominator, e, numerator, sum, t, wpr, x2, n = 1, guard = 10, x = y, xd = x.d, Ctor = x.constructor, pr = Ctor.precision;
+  if (x.s < 1) throw Error(decimalError + (x.s ? "NaN" : "-Infinity"));
+  if (x.eq(ONE)) return new Ctor(0);
+  if (sd == null) {
+    external = false;
+    wpr = pr;
+  } else {
+    wpr = sd;
+  }
+  if (x.eq(10)) {
+    if (sd == null) external = true;
+    return getLn10(Ctor, wpr);
+  }
+  wpr += guard;
+  Ctor.precision = wpr;
+  c = digitsToString(xd);
+  c0 = c.charAt(0);
+  e = getBase10Exponent(x);
+  if (Math.abs(e) < 15e14) {
+    while (c0 < 7 && c0 != 1 || c0 == 1 && c.charAt(1) > 3) {
+      x = x.times(y);
+      c = digitsToString(x.d);
+      c0 = c.charAt(0);
+      n++;
+    }
+    e = getBase10Exponent(x);
+    if (c0 > 1) {
+      x = new Ctor("0." + c);
+      e++;
+    } else {
+      x = new Ctor(c0 + "." + c.slice(1));
+    }
+  } else {
+    t = getLn10(Ctor, wpr + 2, pr).times(e + "");
+    x = ln(new Ctor(c0 + "." + c.slice(1)), wpr - guard).plus(t);
+    Ctor.precision = pr;
+    return sd == null ? (external = true, round(x, pr)) : x;
+  }
+  sum = numerator = x = divide(x.minus(ONE), x.plus(ONE), wpr);
+  x2 = round(x.times(x), wpr);
+  denominator = 3;
+  for (; ; ) {
+    numerator = round(numerator.times(x2), wpr);
+    t = sum.plus(divide(numerator, new Ctor(denominator), wpr));
+    if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {
+      sum = sum.times(2);
+      if (e !== 0) sum = sum.plus(getLn10(Ctor, wpr + 2, pr).times(e + ""));
+      sum = divide(sum, new Ctor(n), wpr);
+      Ctor.precision = pr;
+      return sd == null ? (external = true, round(sum, pr)) : sum;
+    }
+    sum = t;
+    denominator += 2;
+  }
+}
+function parseDecimal(x, str) {
+  var e, i, len;
+  if ((e = str.indexOf(".")) > -1) str = str.replace(".", "");
+  if ((i = str.search(/e/i)) > 0) {
+    if (e < 0) e = i;
+    e += +str.slice(i + 1);
+    str = str.substring(0, i);
+  } else if (e < 0) {
+    e = str.length;
+  }
+  for (i = 0; str.charCodeAt(i) === 48; ) ++i;
+  for (len = str.length; str.charCodeAt(len - 1) === 48; ) --len;
+  str = str.slice(i, len);
+  if (str) {
+    len -= i;
+    e = e - i - 1;
+    x.e = mathfloor(e / LOG_BASE);
+    x.d = [];
+    i = (e + 1) % LOG_BASE;
+    if (e < 0) i += LOG_BASE;
+    if (i < len) {
+      if (i) x.d.push(+str.slice(0, i));
+      for (len -= LOG_BASE; i < len; ) x.d.push(+str.slice(i, i += LOG_BASE));
+      str = str.slice(i);
+      i = LOG_BASE - str.length;
+    } else {
+      i -= len;
+    }
+    for (; i--; ) str += "0";
+    x.d.push(+str);
+    if (external && (x.e > MAX_E || x.e < -MAX_E)) throw Error(exponentOutOfRange + e);
+  } else {
+    x.s = 0;
+    x.e = 0;
+    x.d = [0];
+  }
+  return x;
+}
+function round(x, sd, rm) {
+  var i, j, k, n, rd, doRound, w, xdi, xd = x.d;
+  for (n = 1, k = xd[0]; k >= 10; k /= 10) n++;
+  i = sd - n;
+  if (i < 0) {
+    i += LOG_BASE;
+    j = sd;
+    w = xd[xdi = 0];
+  } else {
+    xdi = Math.ceil((i + 1) / LOG_BASE);
+    k = xd.length;
+    if (xdi >= k) return x;
+    w = k = xd[xdi];
+    for (n = 1; k >= 10; k /= 10) n++;
+    i %= LOG_BASE;
+    j = i - LOG_BASE + n;
+  }
+  if (rm !== void 0) {
+    k = mathpow(10, n - j - 1);
+    rd = w / k % 10 | 0;
+    doRound = sd < 0 || xd[xdi + 1] !== void 0 || w % k;
+    doRound = rm < 4 ? (rd || doRound) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : rd > 5 || rd == 5 && (rm == 4 || doRound || rm == 6 && // Check whether the digit to the left of the rounding digit is odd.
+    (i > 0 ? j > 0 ? w / mathpow(10, n - j) : 0 : xd[xdi - 1]) % 10 & 1 || rm == (x.s < 0 ? 8 : 7));
+  }
+  if (sd < 1 || !xd[0]) {
+    if (doRound) {
+      k = getBase10Exponent(x);
+      xd.length = 1;
+      sd = sd - k - 1;
+      xd[0] = mathpow(10, (LOG_BASE - sd % LOG_BASE) % LOG_BASE);
+      x.e = mathfloor(-sd / LOG_BASE) || 0;
+    } else {
+      xd.length = 1;
+      xd[0] = x.e = x.s = 0;
+    }
+    return x;
+  }
+  if (i == 0) {
+    xd.length = xdi;
+    k = 1;
+    xdi--;
+  } else {
+    xd.length = xdi + 1;
+    k = mathpow(10, LOG_BASE - i);
+    xd[xdi] = j > 0 ? (w / mathpow(10, n - j) % mathpow(10, j) | 0) * k : 0;
+  }
+  if (doRound) {
+    for (; ; ) {
+      if (xdi == 0) {
+        if ((xd[0] += k) == BASE) {
+          xd[0] = 1;
+          ++x.e;
+        }
+        break;
+      } else {
+        xd[xdi] += k;
+        if (xd[xdi] != BASE) break;
+        xd[xdi--] = 0;
+        k = 1;
+      }
+    }
+  }
+  for (i = xd.length; xd[--i] === 0; ) xd.pop();
+  if (external && (x.e > MAX_E || x.e < -MAX_E)) {
+    throw Error(exponentOutOfRange + getBase10Exponent(x));
+  }
+  return x;
+}
+function subtract(x, y) {
+  var d, e, i, j, k, len, xd, xe, xLTy, yd, Ctor = x.constructor, pr = Ctor.precision;
+  if (!x.s || !y.s) {
+    if (y.s) y.s = -y.s;
+    else y = new Ctor(x);
+    return external ? round(y, pr) : y;
+  }
+  xd = x.d;
+  yd = y.d;
+  e = y.e;
+  xe = x.e;
+  xd = xd.slice();
+  k = xe - e;
+  if (k) {
+    xLTy = k < 0;
+    if (xLTy) {
+      d = xd;
+      k = -k;
+      len = yd.length;
+    } else {
+      d = yd;
+      e = xe;
+      len = xd.length;
+    }
+    i = Math.max(Math.ceil(pr / LOG_BASE), len) + 2;
+    if (k > i) {
+      k = i;
+      d.length = 1;
+    }
+    d.reverse();
+    for (i = k; i--; ) d.push(0);
+    d.reverse();
+  } else {
+    i = xd.length;
+    len = yd.length;
+    xLTy = i < len;
+    if (xLTy) len = i;
+    for (i = 0; i < len; i++) {
+      if (xd[i] != yd[i]) {
+        xLTy = xd[i] < yd[i];
+        break;
+      }
+    }
+    k = 0;
+  }
+  if (xLTy) {
+    d = xd;
+    xd = yd;
+    yd = d;
+    y.s = -y.s;
+  }
+  len = xd.length;
+  for (i = yd.length - len; i > 0; --i) xd[len++] = 0;
+  for (i = yd.length; i > k; ) {
+    if (xd[--i] < yd[i]) {
+      for (j = i; j && xd[--j] === 0; ) xd[j] = BASE - 1;
+      --xd[j];
+      xd[i] += BASE;
+    }
+    xd[i] -= yd[i];
+  }
+  for (; xd[--len] === 0; ) xd.pop();
+  for (; xd[0] === 0; xd.shift()) --e;
+  if (!xd[0]) return new Ctor(0);
+  y.d = xd;
+  y.e = e;
+  return external ? round(y, pr) : y;
+}
+function toString3(x, isExp, sd) {
+  var k, e = getBase10Exponent(x), str = digitsToString(x.d), len = str.length;
+  if (isExp) {
+    if (sd && (k = sd - len) > 0) {
+      str = str.charAt(0) + "." + str.slice(1) + getZeroString(k);
+    } else if (len > 1) {
+      str = str.charAt(0) + "." + str.slice(1);
+    }
+    str = str + (e < 0 ? "e" : "e+") + e;
+  } else if (e < 0) {
+    str = "0." + getZeroString(-e - 1) + str;
+    if (sd && (k = sd - len) > 0) str += getZeroString(k);
+  } else if (e >= len) {
+    str += getZeroString(e + 1 - len);
+    if (sd && (k = sd - e - 1) > 0) str = str + "." + getZeroString(k);
+  } else {
+    if ((k = e + 1) < len) str = str.slice(0, k) + "." + str.slice(k);
+    if (sd && (k = sd - len) > 0) {
+      if (e + 1 === len) str += ".";
+      str += getZeroString(k);
+    }
+  }
+  return x.s < 0 ? "-" + str : str;
+}
+function truncate(arr, len) {
+  if (arr.length > len) {
+    arr.length = len;
+    return true;
+  }
+}
+function clone(obj) {
+  var i, p, ps;
+  function Decimal2(value) {
+    var x = this;
+    if (!(x instanceof Decimal2)) return new Decimal2(value);
+    x.constructor = Decimal2;
+    if (value instanceof Decimal2) {
+      x.s = value.s;
+      x.e = value.e;
+      x.d = (value = value.d) ? value.slice() : value;
+      return;
+    }
+    if (typeof value === "number") {
+      if (value * 0 !== 0) {
+        throw Error(invalidArgument + value);
+      }
+      if (value > 0) {
+        x.s = 1;
+      } else if (value < 0) {
+        value = -value;
+        x.s = -1;
+      } else {
+        x.s = 0;
+        x.e = 0;
+        x.d = [0];
+        return;
+      }
+      if (value === ~~value && value < 1e7) {
+        x.e = 0;
+        x.d = [value];
+        return;
+      }
+      return parseDecimal(x, value.toString());
+    } else if (typeof value !== "string") {
+      throw Error(invalidArgument + value);
+    }
+    if (value.charCodeAt(0) === 45) {
+      value = value.slice(1);
+      x.s = -1;
+    } else {
+      x.s = 1;
+    }
+    if (isDecimal.test(value)) parseDecimal(x, value);
+    else throw Error(invalidArgument + value);
+  }
+  Decimal2.prototype = P;
+  Decimal2.ROUND_UP = 0;
+  Decimal2.ROUND_DOWN = 1;
+  Decimal2.ROUND_CEIL = 2;
+  Decimal2.ROUND_FLOOR = 3;
+  Decimal2.ROUND_HALF_UP = 4;
+  Decimal2.ROUND_HALF_DOWN = 5;
+  Decimal2.ROUND_HALF_EVEN = 6;
+  Decimal2.ROUND_HALF_CEIL = 7;
+  Decimal2.ROUND_HALF_FLOOR = 8;
+  Decimal2.clone = clone;
+  Decimal2.config = Decimal2.set = config;
+  if (obj === void 0) obj = {};
+  if (obj) {
+    ps = ["precision", "rounding", "toExpNeg", "toExpPos", "LN10"];
+    for (i = 0; i < ps.length; ) if (!obj.hasOwnProperty(p = ps[i++])) obj[p] = this[p];
+  }
+  Decimal2.config(obj);
+  return Decimal2;
+}
+function config(obj) {
+  if (!obj || typeof obj !== "object") {
+    throw Error(decimalError + "Object expected");
+  }
+  var i, p, v, ps = [
+    "precision",
+    1,
+    MAX_DIGITS,
+    "rounding",
+    0,
+    8,
+    "toExpNeg",
+    -1 / 0,
+    0,
+    "toExpPos",
+    0,
+    1 / 0
+  ];
+  for (i = 0; i < ps.length; i += 3) {
+    if ((v = obj[p = ps[i]]) !== void 0) {
+      if (mathfloor(v) === v && v >= ps[i + 1] && v <= ps[i + 2]) this[p] = v;
+      else throw Error(invalidArgument + p + ": " + v);
+    }
+  }
+  if ((v = obj[p = "LN10"]) !== void 0) {
+    if (v == Math.LN10) this[p] = new this(v);
+    else throw Error(invalidArgument + p + ": " + v);
+  }
+  return this;
+}
+var Decimal = clone(defaults2);
+ONE = new Decimal(1);
+
+// src/sdk/sdk-legacy/utils/formatter.ts
 function rayToNumber(num) {
   return Number(toBigInt(num) / 10n ** 21n) / 1e6;
 }
 function toSignificant(num, decimals2, precision = 6) {
   if (num === 1n) return "0";
-  const divider = new decimal_jsLight.Decimal(10).toPower(decimals2);
-  const number = new decimal_jsLight.Decimal(num.toString()).div(divider);
+  const divider = new Decimal(10).toPower(decimals2);
+  const number = new Decimal(num.toString()).div(divider);
   return number.toSignificantDigits(precision, 4).toString();
 }
 function toBN(num, decimals2) {
   if (num === "") return 0n;
-  const multiplier = new decimal_jsLight.Decimal(10).toPower(decimals2);
-  const number = new decimal_jsLight.Decimal(num).mul(multiplier);
+  const multiplier = new Decimal(10).toPower(decimals2);
+  const number = new Decimal(num).mul(multiplier);
   return BigInt(number.toFixed(0));
 }
 function shortAddress(address) {
@@ -87742,7 +88724,7 @@ var POOL_REWARDS_ABI = [
 
 // src/sdk/sdk-legacy/gearboxRewards/apy.ts
 var PERCENTAGE_FACTOR_1KK = PERCENTAGE_DECIMALS * PERCENTAGE_FACTOR;
-var ONE = PERCENTAGE_FACTOR_1KK * 10n;
+var ONE2 = PERCENTAGE_FACTOR_1KK * 10n;
 var GearboxRewardsApy = class {
   static getPoolExtraAPY_V3({
     rewardPoolsInfo,
@@ -87823,7 +88805,7 @@ var GearboxRewardsApy = class {
       reward.decimals
     );
     const durationRatio = toBigInt(SECONDS_PER_YEAR) * WAD / info.duration;
-    const apyBn = rewardMoney * ONE / supplyMoney * durationRatio / WAD;
+    const apyBn = rewardMoney * ONE2 / supplyMoney * durationRatio / WAD;
     return Math.round(Number(apyBn) / 10);
   }
   static getCAExtraAPY_V3({