@stableflow/core 3.0.0-beta-02a59f37a0-20260515

package/dist/index.mjs

@@ -0,0 +1,2191 @@
+import axios from 'axios';
+import FormData from 'form-data';
+import { Buffer } from 'buffer';
+import Big from 'big.js';
+import bs58 from 'bs58';
+
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), member.set(obj, value), value);
+
+// src/core/ApiError.ts
+var ApiError = class extends Error {
+  constructor(request2, response, message) {
+    super(message);
+    this.name = "ApiError";
+    this.url = response.url;
+    this.status = response.status;
+    this.statusText = response.statusText;
+    this.body = response.body;
+    this.request = request2;
+  }
+};
+
+// src/core/CancelablePromise.ts
+var CancelError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CancelError";
+  }
+  get isCancelled() {
+    return true;
+  }
+};
+var _isResolved, _isRejected, _isCancelled, _cancelHandlers, _promise, _resolve, _reject;
+var CancelablePromise = class {
+  constructor(executor) {
+    __privateAdd(this, _isResolved);
+    __privateAdd(this, _isRejected);
+    __privateAdd(this, _isCancelled);
+    __privateAdd(this, _cancelHandlers);
+    __privateAdd(this, _promise);
+    __privateAdd(this, _resolve);
+    __privateAdd(this, _reject);
+    __privateSet(this, _isResolved, false);
+    __privateSet(this, _isRejected, false);
+    __privateSet(this, _isCancelled, false);
+    __privateSet(this, _cancelHandlers, []);
+    __privateSet(this, _promise, new Promise((resolve2, reject) => {
+      __privateSet(this, _resolve, resolve2);
+      __privateSet(this, _reject, reject);
+      const onResolve = (value) => {
+        if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+          return;
+        }
+        __privateSet(this, _isResolved, true);
+        if (__privateGet(this, _resolve)) __privateGet(this, _resolve).call(this, value);
+      };
+      const onReject = (reason) => {
+        if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+          return;
+        }
+        __privateSet(this, _isRejected, true);
+        if (__privateGet(this, _reject)) __privateGet(this, _reject).call(this, reason);
+      };
+      const onCancel = (cancelHandler) => {
+        if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+          return;
+        }
+        __privateGet(this, _cancelHandlers).push(cancelHandler);
+      };
+      Object.defineProperty(onCancel, "isResolved", {
+        get: () => __privateGet(this, _isResolved)
+      });
+      Object.defineProperty(onCancel, "isRejected", {
+        get: () => __privateGet(this, _isRejected)
+      });
+      Object.defineProperty(onCancel, "isCancelled", {
+        get: () => __privateGet(this, _isCancelled)
+      });
+      return executor(onResolve, onReject, onCancel);
+    }));
+  }
+  get [Symbol.toStringTag]() {
+    return "Cancellable Promise";
+  }
+  then(onFulfilled, onRejected) {
+    return __privateGet(this, _promise).then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    return __privateGet(this, _promise).catch(onRejected);
+  }
+  finally(onFinally) {
+    return __privateGet(this, _promise).finally(onFinally);
+  }
+  cancel() {
+    if (__privateGet(this, _isResolved) || __privateGet(this, _isRejected) || __privateGet(this, _isCancelled)) {
+      return;
+    }
+    __privateSet(this, _isCancelled, true);
+    if (__privateGet(this, _cancelHandlers).length) {
+      try {
+        for (const cancelHandler of __privateGet(this, _cancelHandlers)) {
+          cancelHandler();
+        }
+      } catch (error) {
+        console.warn("Cancellation threw an error", error);
+        return;
+      }
+    }
+    __privateGet(this, _cancelHandlers).length = 0;
+    if (__privateGet(this, _reject)) __privateGet(this, _reject).call(this, new CancelError("Request aborted"));
+  }
+  get isCancelled() {
+    return __privateGet(this, _isCancelled);
+  }
+};
+_isResolved = new WeakMap();
+_isRejected = new WeakMap();
+_isCancelled = new WeakMap();
+_cancelHandlers = new WeakMap();
+_promise = new WeakMap();
+_resolve = new WeakMap();
+_reject = new WeakMap();
+
+// src/core/OpenAPI.ts
+var OpenAPI = {
+  BASE: "https://api.stableflow.ai",
+  VERSION: "1.0.0",
+  WITH_CREDENTIALS: false,
+  CREDENTIALS: "include",
+  TOKEN: void 0,
+  USERNAME: void 0,
+  PASSWORD: void 0,
+  HEADERS: void 0,
+  ENCODE_PATH: void 0,
+  DEBUG: false
+};
+
+// src/utils/log.ts
+var logStyles = {
+  "red-50": "background:oklch(97.1% 0.013 17.38);color:#000;",
+  "red-100": "background:oklch(93.6% 0.032 17.717);color:#000;",
+  "red-200": "background:oklch(88.5% 0.062 18.334);color:#000;",
+  "red-300": "background:oklch(80.8% 0.114 19.571);color:#000;",
+  "red-400": "background:oklch(70.4% 0.191 22.216);color:#fff;",
+  "red-500": "background:oklch(63.7% 0.237 25.331);color:#fff;",
+  "red-600": "background:oklch(57.7% 0.245 27.325);color:#fff;",
+  "red-700": "background:oklch(50.5% 0.213 27.518);color:#fff;",
+  "red-800": "background:oklch(44.4% 0.177 26.899);color:#fff;",
+  "red-900": "background:oklch(39.6% 0.141 25.723);color:#fff;",
+  "red-950": "background:oklch(25.8% 0.092 26.042);color:#fff;",
+  "yellow-50": "background:oklch(98.73% 0.0262 102.21);color:#000;",
+  "yellow-100": "background:oklch(97.29% 0.0693 103.19);color:#000;",
+  "yellow-200": "background:oklch(94.51% 0.1243 101.54);color:#000;",
+  "yellow-300": "background:oklch(90.52% 0.1657 98.11);color:#000;",
+  "yellow-400": "background:oklch(86.06% 0.1731 91.94);color:#fff;",
+  "yellow-500": "background:oklch(79.52% 0.1617 86.05);color:#fff;",
+  "yellow-600": "background:oklch(68.06% 0.1423 75.83);color:#fff;",
+  "yellow-700": "background:oklch(55.38% 0.1207 66.44);color:#fff;",
+  "yellow-800": "background:oklch(47.62% 0.1034 61.91);color:#fff;",
+  "yellow-900": "background:oklch(42.1% 0.0897 57.71);color:#fff;",
+  "yellow-950": "background:oklch(28.57% 0.0639 53.81);color:#fff;",
+  "green-50": "background:oklch(98.19% 0.0181 155.83);color:#000;",
+  "green-100": "background:oklch(96.24% 0.0434 156.74);color:#000;",
+  "green-200": "background:oklch(92.5% 0.0806 155.99);color:#000;",
+  "green-300": "background:oklch(87.12% 0.1363 154.45);color:#000;",
+  "green-400": "background:oklch(80.03% 0.1821 151.71);color:#fff;",
+  "green-500": "background:oklch(72.27% 0.192 149.58);color:#fff;",
+  "green-600": "background:oklch(62.71% 0.1699 149.21);color:#fff;",
+  "green-700": "background:oklch(52.73% 0.1371 150.07);color:#fff;",
+  "green-800": "background:oklch(44.79% 0.1083 151.33);color:#fff;",
+  "green-900": "background:oklch(39.25% 0.0896 152.54);color:#fff;",
+  "green-950": "background:oklch(26.64% 0.0628 152.93);color:#fff;",
+  "blue-50": "background:oklch(97.05% 0.0142 254.6);color:#000;",
+  "blue-100": "background:oklch(93.19% 0.0316 255.59);color:#000;",
+  "blue-200": "background:oklch(88.23% 0.0571 254.13);color:#000;",
+  "blue-300": "background:oklch(80.91% 0.0956 251.81);color:#000;",
+  "blue-400": "background:oklch(71.37% 0.1434 254.62);color:#fff;",
+  "blue-500": "background:oklch(62.31% 0.188 259.81);color:#fff;",
+  "blue-600": "background:oklch(54.61% 0.2152 262.88);color:#fff;",
+  "blue-700": "background:oklch(48.82% 0.2172 264.38);color:#fff;",
+  "blue-800": "background:oklch(42.44% 0.1809 265.64);color:#fff;",
+  "blue-900": "background:oklch(37.91% 0.1378 265.52);color:#fff;",
+  "blue-950": "background:oklch(28.23% 0.0874 267.94);color:#fff;",
+  "sky-50": "background:oklch(97.71% 0.0125 236.62);color:#000;",
+  "sky-100": "background:oklch(95.14% 0.025 236.82);color:#000;",
+  "sky-200": "background:oklch(90.14% 0.0555 230.9);color:#000;",
+  "sky-300": "background:oklch(82.76% 0.1013 230.32);color:#000;",
+  "sky-400": "background:oklch(75.35% 0.139 232.66);color:#fff;",
+  "sky-500": "background:oklch(68.47% 0.1479 237.32);color:#fff;",
+  "sky-600": "background:oklch(58.76% 0.1389 241.97);color:#fff;",
+  "sky-700": "background:oklch(50% 0.1193 242.75);color:#fff;",
+  "sky-800": "background:oklch(44.34% 0.1 240.79);color:#fff;",
+  "sky-900": "background:oklch(39.12% 0.0845 240.88);color:#fff;",
+  "sky-950": "background:oklch(29.35% 0.0632 243.16);color:#fff;",
+  "teal-50": "background:oklch(98.36% 0.0142 180.72);color:#000;",
+  "teal-100": "background:oklch(95.27% 0.0498 180.8);color:#000;",
+  "teal-200": "background:oklch(91% 0.0927 180.43);color:#000;",
+  "teal-300": "background:oklch(85.49% 0.1251 181.07);color:#000;",
+  "teal-400": "background:oklch(78.45% 0.1325 181.91);color:#fff;",
+  "teal-500": "background:oklch(70.38% 0.123 182.5);color:#fff;",
+  "teal-600": "background:oklch(60.02% 0.1038 184.7);color:#fff;",
+  "teal-700": "background:oklch(51.09% 0.0861 186.39);color:#fff;",
+  "teal-800": "background:oklch(43.7% 0.0705 188.22);color:#fff;",
+  "teal-900": "background:oklch(38.61% 0.059 188.42);color:#fff;",
+  "teal-950": "background:oklch(27.73% 0.0447 192.52);color:#fff;",
+  "purple-50": "background:oklch(97.68% 0.0142 308.3);color:#000;",
+  "purple-100": "background:oklch(94.64% 0.0327 307.17);color:#000;",
+  "purple-200": "background:oklch(90.24% 0.0604 306.7);color:#000;",
+  "purple-300": "background:oklch(82.68% 0.1082 306.38);color:#000;",
+  "purple-400": "background:oklch(72.17% 0.1767 305.5);color:#fff;",
+  "purple-500": "background:oklch(62.68% 0.2325 303.9);color:#fff;",
+  "purple-600": "background:oklch(55.75% 0.2525 302.32);color:#fff;",
+  "purple-700": "background:oklch(49.55% 0.2369 301.92);color:#fff;",
+  "purple-800": "background:oklch(43.83% 0.1983 303.72);color:#fff;",
+  "purple-900": "background:oklch(38.07% 0.1661 304.99);color:#fff;",
+  "purple-950": "background:oklch(29.05% 0.1432 302.72);color:#fff;",
+  "pink-50": "background:oklch(97.14% 0.0141 343.2);color:#000;",
+  "pink-100": "background:oklch(94.82% 0.0276 342.26);color:#000;",
+  "pink-200": "background:oklch(89.94% 0.0589 343.23);color:#000;",
+  "pink-300": "background:oklch(82.28% 0.1095 346.02);color:#000;",
+  "pink-400": "background:oklch(72.53% 0.1752 349.76);color:#fff;",
+  "pink-500": "background:oklch(65.59% 0.2118 354.31);color:#fff;",
+  "pink-600": "background:oklch(59.16% 0.218 354.58);color:#fff;",
+  "pink-700": "background:oklch(52.46% 0.199 353.96);color:#fff;",
+  "pink-800": "background:oklch(45.87% 0.1697 353.82);color:#fff;",
+  "pink-900": "background:oklch(40.78% 0.1442 352.43);color:#fff;",
+  "pink-950": "background:oklch(28.45% 0.1048 353.91);color:#fff;",
+  "rose-50": "background:oklch(96.94% 0.0151 12.42);color:#000;",
+  "rose-100": "background:oklch(94.14% 0.0297 12.58);color:#000;",
+  "rose-200": "background:oklch(89.24% 0.0559 10);color:#000;",
+  "rose-300": "background:oklch(80.97% 0.1061 11.64);color:#000;",
+  "rose-400": "background:oklch(71.92% 0.169 13.43);color:#fff;",
+  "rose-500": "background:oklch(64.5% 0.2154 16.44);color:#fff;",
+  "rose-600": "background:oklch(58.58% 0.222 17.58);color:#fff;",
+  "rose-700": "background:oklch(51.43% 0.1978 16.93);color:#fff;",
+  "rose-800": "background:oklch(45.46% 0.1713 13.7);color:#fff;",
+  "rose-900": "background:oklch(41.03% 0.1502 10.27);color:#fff;",
+  "rose-950": "background:oklch(27.08% 0.1009 12.09);color:#fff;",
+  "gray-50": "background:oklch(98.46% 0.0017 247.84);color:#000;",
+  "gray-100": "background:oklch(96.7% 0.0029 264.54);color:#000;",
+  "gray-200": "background:oklch(92.76% 0.0058 264.53);color:#000;",
+  "gray-300": "background:oklch(87.17% 0.0093 258.34);color:#000;",
+  "gray-400": "background:oklch(71.37% 0.0192 261.32);color:#fff;",
+  "gray-500": "background:oklch(55.1% 0.0234 264.36);color:#fff;",
+  "gray-600": "background:oklch(44.55% 0.0234 264.36);color:#fff;",
+  "gray-700": "background:oklch(37.29% 0.0306 259.73);color:#fff;",
+  "gray-800": "background:oklch(27.81% 0.0296 256.85);color:#fff;",
+  "gray-900": "background:oklch(21.01% 0.0318 264.66);color:#fff;",
+  "gray-950": "background:oklch(12.96% 0.0274 261.69);color:#fff;",
+  "indigo-50": "background:oklch(96.2% 0.018 272.314);color:#000;",
+  "indigo-100": "background:oklch(93% 0.034 272.788);color:#000;",
+  "indigo-200": "background:oklch(87% 0.065 274.039);color:#000;",
+  "indigo-300": "background:oklch(78.5% 0.115 274.713);color:#000;",
+  "indigo-400": "background:oklch(67.3% 0.182 276.935);color:#fff;",
+  "indigo-500": "background:oklch(58.5% 0.233 277.117);color:#fff;",
+  "indigo-600": "background:oklch(51.1% 0.262 276.966);color:#fff;",
+  "indigo-700": "background:oklch(45.7% 0.24 277.023);color:#fff;",
+  "indigo-800": "background:oklch(39.8% 0.195 277.366);color:#fff;",
+  "indigo-900": "background:oklch(35.9% 0.144 278.697);color:#fff;",
+  "indigo-950": "background:oklch(25.7% 0.09 281.288);color:#fff;",
+  "fuchsia-50": "background:oklch(97.7% 0.017 320.058);color:#000;",
+  "fuchsia-100": "background:oklch(95.2% 0.037 318.852);color:#000;",
+  "fuchsia-200": "background:oklch(90.3% 0.076 319.62);color:#000;",
+  "fuchsia-300": "background:oklch(83.3% 0.145 321.434);color:#000;",
+  "fuchsia-400": "background:oklch(74% 0.238 322.16);color:#fff;",
+  "fuchsia-500": "background:oklch(66.7% 0.295 322.15);color:#fff;",
+  "fuchsia-600": "background:oklch(59.1% 0.293 322.896);color:#fff;",
+  "fuchsia-700": "background:oklch(51.8% 0.253 323.949);color:#fff;",
+  "fuchsia-800": "background:oklch(45.2% 0.211 324.591);color:#fff;",
+  "fuchsia-900": "background:oklch(40.1% 0.17 325.612);color:#fff;",
+  "fuchsia-950": "background:oklch(29.3% 0.136 325.661);color:#fff;",
+  "stone-50": "background:oklch(98.5% 0.001 106.423);color:#000;",
+  "stone-100": "background:oklch(97% 0.001 106.424);color:#000;",
+  "stone-200": "background:oklch(92.3% 0.003 48.717);color:#000;",
+  "stone-300": "background:oklch(86.9% 0.005 56.366);color:#000;",
+  "stone-400": "background:oklch(70.9% 0.01 56.259);color:#fff;",
+  "stone-500": "background:oklch(55.3% 0.013 58.071);color:#fff;",
+  "stone-600": "background:oklch(44.4% 0.011 73.639);color:#fff;",
+  "stone-700": "background:oklch(37.4% 0.01 67.558);color:#fff;",
+  "stone-800": "background:oklch(26.8% 0.007 34.298);color:#fff;",
+  "stone-900": "background:oklch(21.6% 0.006 56.043);color:#fff;",
+  "stone-950": "background:oklch(14.7% 0.004 49.25);color:#fff;",
+  "lime-50": "background:oklch(98.6% 0.031 120.757);color:#000;",
+  "lime-100": "background:oklch(96.7% 0.067 122.328);color:#000;",
+  "lime-200": "background:oklch(93.8% 0.127 124.321);color:#000;",
+  "lime-300": "background:oklch(89.7% 0.196 126.665);color:#000;",
+  "lime-400": "background:oklch(84.1% 0.238 128.85);color:#fff;",
+  "lime-500": "background:oklch(76.8% 0.233 130.85);color:#fff;",
+  "lime-600": "background:oklch(64.8% 0.2 131.684);color:#fff;",
+  "lime-700": "background:oklch(53.2% 0.157 131.589);color:#fff;",
+  "lime-800": "background:oklch(45.3% 0.124 130.933);color:#fff;",
+  "lime-900": "background:oklch(40.5% 0.101 131.063);color:#fff;",
+  "lime-950": "background:oklch(27.4% 0.072 132.109);color:#fff;"
+};
+var csl = (isDebug, type, style, str, ...args) => {
+  if (!isDebug) {
+    return;
+  }
+  const _style = logStyles[style] || logStyles["blue-400"];
+  console.log(`%c[StableFlowAiSDK]${type ? ".[" + type + "]" : ""} ${str}`, _style, ...args);
+};
+var Csl = class {
+  constructor(isDebug) {
+    this.log = (type, style, str, ...args) => {
+      csl(this.isDebug, type, style, str, ...args);
+    };
+    this.info = (type, str, ...args) => {
+      csl(this.isDebug, type, "blue-400", str, ...args);
+    };
+    this.error = (type, str, ...args) => {
+      csl(this.isDebug, type, "red-400", str, ...args);
+    };
+    this.success = (type, str, ...args) => {
+      csl(this.isDebug, type, "green-400", str, ...args);
+    };
+    this.simple = (str, ...args) => {
+      csl(this.isDebug, "", "blue-400", str, ...args);
+    };
+    this.isDebug = isDebug;
+  }
+};
+var isDefined = (value) => {
+  return value !== void 0 && value !== null;
+};
+var isString = (value) => {
+  return typeof value === "string";
+};
+var isStringWithValue = (value) => {
+  return isString(value) && value !== "";
+};
+var isBlob = (value) => {
+  return typeof value === "object" && typeof value.type === "string" && typeof value.stream === "function" && typeof value.arrayBuffer === "function" && typeof value.constructor === "function" && typeof value.constructor.name === "string" && /^(Blob|File)$/.test(value.constructor.name) && /^(Blob|File)$/.test(value[Symbol.toStringTag]);
+};
+var isFormData = (value) => {
+  return value instanceof FormData;
+};
+var isSuccess = (status) => {
+  return status >= 200 && status < 300;
+};
+var base64 = (str) => {
+  try {
+    return btoa(str);
+  } catch (err) {
+    return Buffer.from(str).toString("base64");
+  }
+};
+var getQueryString = (params) => {
+  const qs = [];
+  const append = (key, value) => {
+    qs.push(`${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`);
+  };
+  const process = (key, value) => {
+    if (isDefined(value)) {
+      if (Array.isArray(value)) {
+        value.forEach((v) => {
+          process(key, v);
+        });
+      } else if (typeof value === "object") {
+        Object.entries(value).forEach(([k, v]) => {
+          process(`${key}[${k}]`, v);
+        });
+      } else {
+        append(key, value);
+      }
+    }
+  };
+  Object.entries(params).forEach(([key, value]) => {
+    process(key, value);
+  });
+  if (qs.length > 0) {
+    return `?${qs.join("&")}`;
+  }
+  return "";
+};
+var getUrl = (config, options) => {
+  const encoder = config.ENCODE_PATH || encodeURI;
+  const path = options.url.replace("{api-version}", config.VERSION).replace(/{(.*?)}/g, (substring, group) => {
+    if (options.path?.hasOwnProperty(group)) {
+      return encoder(String(options.path[group]));
+    }
+    return substring;
+  });
+  const url = `${config.BASE}${path}`;
+  if (options.query) {
+    return `${url}${getQueryString(options.query)}`;
+  }
+  return url;
+};
+var getFormData = (options) => {
+  if (options.formData) {
+    const formData = new FormData();
+    const process = (key, value) => {
+      if (isString(value) || isBlob(value)) {
+        formData.append(key, value);
+      } else {
+        formData.append(key, JSON.stringify(value));
+      }
+    };
+    Object.entries(options.formData).filter(([_, value]) => isDefined(value)).forEach(([key, value]) => {
+      if (Array.isArray(value)) {
+        value.forEach((v) => process(key, v));
+      } else {
+        process(key, value);
+      }
+    });
+    return formData;
+  }
+  return void 0;
+};
+var resolve = async (options, resolver) => {
+  if (typeof resolver === "function") {
+    return resolver(options);
+  }
+  return resolver;
+};
+var getHeaders = async (config, options, formData) => {
+  const [token, username, password, additionalHeaders] = await Promise.all([
+    resolve(options, config.TOKEN),
+    resolve(options, config.USERNAME),
+    resolve(options, config.PASSWORD),
+    resolve(options, config.HEADERS)
+  ]);
+  const formHeaders = typeof formData?.getHeaders === "function" && formData?.getHeaders() || {};
+  const headers = Object.entries({
+    Accept: "application/json",
+    ...additionalHeaders,
+    ...options.headers,
+    ...formHeaders
+  }).filter(([_, value]) => isDefined(value)).reduce((headers2, [key, value]) => ({
+    ...headers2,
+    [key]: String(value)
+  }), {});
+  if (isStringWithValue(token)) {
+    headers["Authorization"] = `Bearer ${token}`;
+  }
+  if (isStringWithValue(username) && isStringWithValue(password)) {
+    const credentials = base64(`${username}:${password}`);
+    headers["Authorization"] = `Basic ${credentials}`;
+  }
+  if (options.body !== void 0) {
+    if (options.mediaType) {
+      headers["Content-Type"] = options.mediaType;
+    } else if (isBlob(options.body)) {
+      headers["Content-Type"] = options.body.type || "application/octet-stream";
+    } else if (isString(options.body)) {
+      headers["Content-Type"] = "text/plain";
+    } else if (!isFormData(options.body)) {
+      headers["Content-Type"] = "application/json";
+    }
+  }
+  return headers;
+};
+var getRequestBody = (options) => {
+  if (options.body) {
+    return options.body;
+  }
+  return void 0;
+};
+var sendRequest = async (config, options, url, body, formData, headers, onCancel, axiosClient) => {
+  const source = axios.CancelToken.source();
+  const requestConfig = {
+    url,
+    headers,
+    data: body ?? formData,
+    method: options.method,
+    withCredentials: config.WITH_CREDENTIALS,
+    withXSRFToken: config.CREDENTIALS === "include" ? config.WITH_CREDENTIALS : false,
+    cancelToken: source.token
+  };
+  onCancel(() => source.cancel("The user aborted a request."));
+  try {
+    return await axiosClient.request(requestConfig);
+  } catch (error) {
+    const axiosError = error;
+    if (axiosError.response) {
+      return axiosError.response;
+    }
+    throw error;
+  }
+};
+var getResponseHeader = (response, responseHeader) => {
+  if (responseHeader) {
+    const content = response.headers[responseHeader];
+    if (isString(content)) {
+      return content;
+    }
+  }
+  return void 0;
+};
+var getResponseBody = (response) => {
+  if (response.status !== 204) {
+    return response.data;
+  }
+  return void 0;
+};
+var catchErrorCodes = (options, result) => {
+  const errors = {
+    400: "Bad Request",
+    401: "Unauthorized",
+    403: "Forbidden",
+    404: "Not Found",
+    500: "Internal Server Error",
+    502: "Bad Gateway",
+    503: "Service Unavailable",
+    ...options.errors
+  };
+  const error = errors[result.status];
+  if (error) {
+    throw new ApiError(options, result, error);
+  }
+  if (!result.ok) {
+    const errorStatus = result.status ?? "unknown";
+    const errorStatusText = result.statusText ?? "unknown";
+    const errorBody = (() => {
+      try {
+        return JSON.stringify(result.body, null, 2);
+      } catch (e) {
+        return void 0;
+      }
+    })();
+    throw new ApiError(
+      options,
+      result,
+      `Generic Error: status: ${errorStatus}; status text: ${errorStatusText}; body: ${errorBody}`
+    );
+  }
+};
+var request = (config, options, axiosClient = axios) => {
+  const csl2 = new Csl(config.DEBUG);
+  return new CancelablePromise(async (resolve2, reject, onCancel) => {
+    try {
+      const url = getUrl(config, options);
+      const formData = getFormData(options);
+      const body = getRequestBody(options);
+      const headers = await getHeaders(config, options, formData);
+      csl2.simple("\n\u{1F535} ========== API Request ==========");
+      csl2.simple("Method:", options.method);
+      csl2.simple("URL:", url);
+      csl2.simple("Headers:", JSON.stringify(headers, null, 2));
+      if (body) {
+        csl2.simple("Body:", JSON.stringify(body, null, 2));
+      }
+      if (formData) {
+        csl2.simple("FormData:", formData);
+      }
+      csl2.simple("====================================\n");
+      if (!onCancel.isCancelled) {
+        const response = await sendRequest(config, options, url, body, formData, headers, onCancel, axiosClient);
+        const responseBody = getResponseBody(response);
+        const responseHeader = getResponseHeader(response, options.responseHeader);
+        const result = {
+          url,
+          ok: isSuccess(response.status),
+          status: response.status,
+          statusText: response.statusText,
+          body: responseHeader ?? responseBody
+        };
+        catchErrorCodes(options, result);
+        csl2.simple("\n\u{1F7E2} ========== API Response ==========");
+        csl2.simple("Status:", response.status, response.statusText);
+        csl2.simple("Response Headers:", JSON.stringify(response.headers, null, 2));
+        csl2.simple("Response Body:", JSON.stringify(responseBody, null, 2));
+        csl2.simple("=====================================\n");
+        resolve2(result.body);
+      }
+    } catch (error) {
+      csl2.simple("\n\u{1F534} ========== API Error ==========");
+      csl2.simple("Error:", error);
+      if (error instanceof ApiError) {
+        csl2.simple("Status:", error.status);
+        csl2.simple("Status Text:", error.statusText);
+        csl2.simple("URL:", error.url);
+        csl2.simple("Body:", JSON.stringify(error.body, null, 2));
+      }
+      csl2.simple("==================================\n");
+      reject(error);
+    }
+  });
+};
+
+// src/core/Send.ts
+var SendType = /* @__PURE__ */ ((SendType2) => {
+  SendType2["SEND"] = "SEND";
+  SendType2["TRANSFER"] = "TRANSFER";
+  return SendType2;
+})(SendType || {});
+
+// src/core/Service.ts
+var Service = {
+  OneClick: "oneclick",
+  Usdt0: "usdt0",
+  CCTP: "cctp",
+  FraxZero: "fraxzero",
+  FraxZeroOneClick: "fraxzero-oneclick",
+  OneClickFraxZero: "oneclick-fraxzero",
+  Usdt0OneClick: "usdt0-oneclick",
+  OneClickUsdt0: "oneclick-usdt0",
+  Native: "native"
+};
+var ServiceBackend = {
+  [Service.OneClick]: "nearintents",
+  [Service.Usdt0]: "layerzero",
+  [Service.CCTP]: "cctp",
+  [Service.FraxZero]: "fraxzero",
+  [Service.FraxZeroOneClick]: "fraxzerointent",
+  [Service.OneClickFraxZero]: "intentfraxzero",
+  [Service.Usdt0OneClick]: "zerointent",
+  [Service.OneClickUsdt0]: "intentzero",
+  [Service.Native]: "native"
+};
+
+// src/models/GetExecutionStatusResponse.ts
+var GetExecutionStatusResponse;
+((GetExecutionStatusResponse2) => {
+  ((status2) => {
+    status2["KNOWN_DEPOSIT_TX"] = "KNOWN_DEPOSIT_TX";
+    status2["PENDING_DEPOSIT"] = "PENDING_DEPOSIT";
+    status2["INCOMPLETE_DEPOSIT"] = "INCOMPLETE_DEPOSIT";
+    status2["PROCESSING"] = "PROCESSING";
+    status2["SUCCESS"] = "SUCCESS";
+    status2["REFUNDED"] = "REFUNDED";
+    status2["FAILED"] = "FAILED";
+  })(GetExecutionStatusResponse2.status || (GetExecutionStatusResponse2.status = {}));
+})(GetExecutionStatusResponse || (GetExecutionStatusResponse = {}));
+
+// src/models/QuoteRequest.ts
+var QuoteRequest;
+((QuoteRequest2) => {
+  ((depositMode2) => {
+    depositMode2["SIMPLE"] = "SIMPLE";
+    depositMode2["MEMO"] = "MEMO";
+  })(QuoteRequest2.depositMode || (QuoteRequest2.depositMode = {}));
+  ((swapType2) => {
+    swapType2["EXACT_INPUT"] = "EXACT_INPUT";
+    swapType2["EXACT_OUTPUT"] = "EXACT_OUTPUT";
+    swapType2["FLEX_INPUT"] = "FLEX_INPUT";
+  })(QuoteRequest2.swapType || (QuoteRequest2.swapType = {}));
+  ((depositType2) => {
+    depositType2["ORIGIN_CHAIN"] = "ORIGIN_CHAIN";
+    depositType2["INTENTS"] = "INTENTS";
+  })(QuoteRequest2.depositType || (QuoteRequest2.depositType = {}));
+  ((refundType2) => {
+    refundType2["ORIGIN_CHAIN"] = "ORIGIN_CHAIN";
+    refundType2["INTENTS"] = "INTENTS";
+  })(QuoteRequest2.refundType || (QuoteRequest2.refundType = {}));
+  ((recipientType2) => {
+    recipientType2["DESTINATION_CHAIN"] = "DESTINATION_CHAIN";
+    recipientType2["INTENTS"] = "INTENTS";
+  })(QuoteRequest2.recipientType || (QuoteRequest2.recipientType = {}));
+})(QuoteRequest || (QuoteRequest = {}));
+
+// src/models/SubmitDepositTxResponse.ts
+var SubmitDepositTxResponse;
+((SubmitDepositTxResponse2) => {
+  ((status2) => {
+    status2["KNOWN_DEPOSIT_TX"] = "KNOWN_DEPOSIT_TX";
+    status2["PENDING_DEPOSIT"] = "PENDING_DEPOSIT";
+    status2["INCOMPLETE_DEPOSIT"] = "INCOMPLETE_DEPOSIT";
+    status2["PROCESSING"] = "PROCESSING";
+    status2["SUCCESS"] = "SUCCESS";
+    status2["REFUNDED"] = "REFUNDED";
+    status2["FAILED"] = "FAILED";
+  })(SubmitDepositTxResponse2.status || (SubmitDepositTxResponse2.status = {}));
+})(SubmitDepositTxResponse || (SubmitDepositTxResponse = {}));
+
+// src/models/TokenResponse.ts
+var TokenResponse;
+((TokenResponse2) => {
+  ((blockchain2) => {
+    blockchain2["NEAR"] = "near";
+    blockchain2["ETH"] = "eth";
+    blockchain2["BASE"] = "base";
+    blockchain2["ARB"] = "arb";
+    blockchain2["BTC"] = "btc";
+    blockchain2["SOL"] = "sol";
+    blockchain2["TON"] = "ton";
+    blockchain2["DOGE"] = "doge";
+    blockchain2["XRP"] = "xrp";
+    blockchain2["ZEC"] = "zec";
+    blockchain2["GNOSIS"] = "gnosis";
+    blockchain2["BERA"] = "bera";
+    blockchain2["BSC"] = "bsc";
+    blockchain2["POL"] = "pol";
+    blockchain2["TRON"] = "tron";
+    blockchain2["SUI"] = "sui";
+    blockchain2["OP"] = "op";
+    blockchain2["AVAX"] = "avax";
+    blockchain2["CARDANO"] = "cardano";
+  })(TokenResponse2.blockchain || (TokenResponse2.blockchain = {}));
+})(TokenResponse || (TokenResponse = {}));
+
+// src/models/Status.ts
+var TransactionStatus = /* @__PURE__ */ ((TransactionStatus2) => {
+  TransactionStatus2["Pending"] = "pending";
+  TransactionStatus2["Success"] = "success";
+  TransactionStatus2["Failed"] = "failed";
+  return TransactionStatus2;
+})(TransactionStatus || {});
+
+// src/services/SFA.ts
+var submitOneclickDepositTx = (requestBody) => {
+  return request(OpenAPI, {
+    method: "POST",
+    url: "/v0/deposit/submit",
+    body: requestBody,
+    mediaType: "application/json",
+    errors: {
+      400: `Bad Request - Invalid input data`,
+      401: `Unauthorized - JWT token is invalid`
+    }
+  });
+};
+var SFA = class {
+  /**
+   * Get supported tokens
+   * Retrieves a list of tokens currently supported by the StableFlow AI API for asset swaps.
+   */
+  static getTokens() {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/v0/tokens"
+    });
+  }
+  /**
+   * Request a swap quote
+   * Generates a swap quote based on input parameters such as the assets, amount, slippage tolerance, and recipient/refund information.
+   */
+  static getQuote(requestBody) {
+    return request(OpenAPI, {
+      method: "POST",
+      url: "/v0/quote",
+      body: requestBody,
+      mediaType: "application/json",
+      errors: {
+        400: `Bad Request - Invalid input data`,
+        401: `Unauthorized - JWT token is invalid`
+      }
+    });
+  }
+  /**
+   * Check swap execution status
+   * Retrieves the current status of a swap using the unique deposit address from the quote.
+   */
+  static getExecutionStatus(depositAddress, depositMemo) {
+    return request(OpenAPI, {
+      method: "GET",
+      url: "/v0/status",
+      query: {
+        "depositAddress": depositAddress,
+        "depositMemo": depositMemo
+      },
+      errors: {
+        401: `Unauthorized - JWT token is invalid`,
+        404: `Deposit address not found`
+      }
+    });
+  }
+};
+/**
+ * Submit deposit transaction hash (OneClick)
+ * Optionally notifies the service that a deposit has been sent to the specified address.
+ */
+SFA.submitDepositTx = submitOneclickDepositTx;
+
+// src/wallets/config/rpcs.ts
+var NetworkRpcUrlsMap = {
+  "eth": ["https://0xrpc.io/eth"],
+  "arb": ["https://arb1.arbitrum.io/rpc"],
+  "bsc": ["https://56.rpc.thirdweb.com"],
+  "avax": ["https://api.avax.network/ext/bc/C/rpc"],
+  "base": ["https://mainnet.base.org"],
+  "pol": ["https://polygon-rpc.com"],
+  "gnosis": ["https://rpc.gnosischain.com"],
+  "op": ["https://mainnet.optimism.io"],
+  "bera": ["https://rpc.berachain.com"],
+  "tron": ["https://api.trongrid.io"],
+  "aptos": ["https://api.mainnet.aptoslabs.com/v1"],
+  "sol": ["https://solana-rpc.publicnode.com"],
+  "near": ["https://nearinner.deltarpc.com"],
+  "xlayer": ["https://rpc.xlayer.tech"],
+  "plasma": ["https://rpc.plasma.to"],
+  "mantle": ["https://rpc.mantle.xyz", "https://mantle-rpc.publicnode.com"],
+  "megaeth": ["https://mainnet.megaeth.com/rpc"],
+  "ink": ["https://rpc-gel.inkonchain.com", "https://rpc-qnd.inkonchain.com"],
+  "stable": ["https://rpc.stable.xyz"],
+  "celo": ["https://forno.celo.org"],
+  "sei": ["https://sei-evm-rpc.publicnode.com"],
+  "flare": ["https://flare-api.flare.network/ext/C/rpc"],
+  "frax": ["https://rpc.frax.com"],
+  "ton": ["https://toncenter.com/api/v2/jsonRPC"],
+  "sui": ["https://fullnode.mainnet.sui.io:443"],
+  "katana": ["https://rpc.katana.network", "https://katana.drpc.org"]
+};
+var getRpcUrls = (blockchain) => {
+  return NetworkRpcUrlsMap[blockchain] || [];
+};
+var getChainRpcUrl = (blockchain) => {
+  return {
+    rpcUrls: NetworkRpcUrlsMap[blockchain],
+    rpcUrl: NetworkRpcUrlsMap[blockchain][0]
+  };
+};
+var setRpcUrls = (urls) => {
+  for (const blockchain in urls) {
+    const prev = NetworkRpcUrlsMap[blockchain] ?? [];
+    const next = urls[blockchain];
+    for (let i = next.length - 1; i >= 0; i--) {
+      const rpc = next[i];
+      if (prev.some((_rpc) => _rpc.toLowerCase() === rpc.toLowerCase())) {
+        continue;
+      }
+      prev.unshift(rpc);
+    }
+  }
+  return NetworkRpcUrlsMap;
+};
+
+// src/wallets/config/chains.ts
+var chainTypes = {
+  near: {
+    value: "near"},
+  sol: {
+    value: "sol"},
+  evm: {
+    value: "evm"},
+  tron: {
+    value: "tron"},
+  aptos: {
+    value: "aptos"},
+  ton: {
+    value: "ton"}};
+var getStableflowChainLogo = (name) => {
+  return `/chains/${name}.png`;
+};
+var chains = {
+  near: {
+    chainName: "Near",
+    blockchain: "near",
+    chainIcon: getStableflowChainLogo("near"),
+    chainIconGray: getStableflowChainLogo("near-gray"),
+    chainType: chainTypes.near.value,
+    blockExplorerUrl: "https://nearblocks.io/txns",
+    blockExplorerUrls: ["https://nearblocks.io"],
+    primaryColor: "#76EA9E",
+    nativeToken: {
+      symbol: "NEAR",
+      decimals: 24
+    },
+    ...getChainRpcUrl("near")
+  },
+  sol: {
+    chainName: "Solana",
+    blockchain: "sol",
+    chainIcon: getStableflowChainLogo("solana"),
+    chainIconGray: getStableflowChainLogo("solana-gray"),
+    chainType: chainTypes.sol.value,
+    blockExplorerUrl: "https://solscan.io/tx",
+    blockExplorerUrls: ["https://solscan.io"],
+    primaryColor: "#B93EF0",
+    nativeToken: {
+      symbol: "SOL",
+      decimals: 9
+    },
+    ...getChainRpcUrl("sol")
+  },
+  eth: {
+    chainName: "Ethereum",
+    blockchain: "eth",
+    chainIcon: getStableflowChainLogo("Ethereum"),
+    chainIconGray: getStableflowChainLogo("Ethereum-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 1,
+    blockExplorerUrl: "https://etherscan.io/tx",
+    blockExplorerUrls: ["https://etherscan.io"],
+    primaryColor: "#7083ee",
+    nativeToken: {
+      symbol: "ETH",
+      decimals: 18
+    },
+    ...getChainRpcUrl("eth")
+  },
+  arb: {
+    chainName: "Arbitrum",
+    blockchain: "arb",
+    chainIcon: getStableflowChainLogo("Arbitrum"),
+    chainIconGray: getStableflowChainLogo("Arbitrum-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 42161,
+    blockExplorerUrl: "https://arbiscan.io/tx",
+    blockExplorerUrls: ["https://arbiscan.io"],
+    primaryColor: "#4763A7",
+    nativeToken: {
+      symbol: "ETH",
+      decimals: 18
+    },
+    ...getChainRpcUrl("arb")
+  },
+  bsc: {
+    chainName: "BNB Chain",
+    blockchain: "bsc",
+    chainIcon: getStableflowChainLogo("bsc"),
+    chainIconGray: getStableflowChainLogo("bsc-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 56,
+    blockExplorerUrl: "https://bscscan.com/tx",
+    blockExplorerUrls: ["https://bscscan.com"],
+    primaryColor: "#F1C144",
+    nativeToken: {
+      symbol: "BNB",
+      decimals: 18
+    },
+    ...getChainRpcUrl("bsc")
+  },
+  avax: {
+    chainName: "Avalanche",
+    blockchain: "avax",
+    chainIcon: getStableflowChainLogo("Avalanche"),
+    chainIconGray: getStableflowChainLogo("Avalanche-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 43114,
+    blockExplorerUrl: "https://snowtrace.io/tx",
+    blockExplorerUrls: ["https://snowtrace.io"],
+    primaryColor: "#9D2620",
+    nativeToken: {
+      symbol: "AVAX",
+      decimals: 18
+    },
+    ...getChainRpcUrl("avax")
+  },
+  base: {
+    chainName: "Base",
+    blockchain: "base",
+    chainIcon: getStableflowChainLogo("Base"),
+    chainIconGray: getStableflowChainLogo("Base-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 8453,
+    blockExplorerUrl: "https://basescan.org/tx",
+    blockExplorerUrls: ["https://basescan.org"],
+    primaryColor: "#3137F6",
+    nativeToken: {
+      symbol: "ETH",
+      decimals: 18
+    },
+    ...getChainRpcUrl("base")
+  },
+  pol: {
+    chainName: "Polygon",
+    blockchain: "pol",
+    chainIcon: getStableflowChainLogo("Polygon"),
+    chainIconGray: getStableflowChainLogo("Polygon-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 137,
+    blockExplorerUrl: "https://polygonscan.com/tx",
+    blockExplorerUrls: ["https://polygonscan.com"],
+    primaryColor: "#5A2AD1",
+    nativeToken: {
+      symbol: "POL",
+      decimals: 18
+    },
+    ...getChainRpcUrl("pol")
+  },
+  gnosis: {
+    ...getChainRpcUrl("gnosis")
+  },
+  op: {
+    chainName: "Optimism",
+    blockchain: "op",
+    chainIcon: getStableflowChainLogo("Optimism"),
+    chainIconGray: getStableflowChainLogo("Optimism-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 10,
+    blockExplorerUrl: "https://optimistic.etherscan.io/tx",
+    blockExplorerUrls: ["https://optimistic.etherscan.io"],
+    primaryColor: "#B5271D",
+    nativeToken: {
+      symbol: "ETH",
+      decimals: 18
+    },
+    ...getChainRpcUrl("op")
+  },
+  tron: {
+    chainName: "Tron",
+    blockchain: "tron",
+    chainIcon: getStableflowChainLogo("Tron"),
+    chainIconGray: getStableflowChainLogo("Tron-gray"),
+    chainType: chainTypes.tron.value,
+    blockExplorerUrl: "https://tronscan.org/#/transaction",
+    blockExplorerUrls: ["https://tronscan.org"],
+    primaryColor: "#BC3221",
+    nativeToken: {
+      symbol: "TRX",
+      decimals: 6
+    },
+    ...getChainRpcUrl("tron")
+  },
+  aptos: {
+    chainName: "Aptos",
+    blockchain: "aptos",
+    chainIcon: getStableflowChainLogo("Aptos"),
+    chainIconGray: getStableflowChainLogo("Aptos-gray"),
+    chainType: chainTypes.aptos.value,
+    blockExplorerUrl: "https://aptoscan.com/transaction",
+    blockExplorerUrls: ["https://aptoscan.com"],
+    primaryColor: "#000000",
+    nativeToken: {
+      symbol: "APT",
+      decimals: 8
+    },
+    ...getChainRpcUrl("aptos")
+  },
+  bera: {
+    chainName: "Berachain",
+    blockchain: "bera",
+    chainIcon: getStableflowChainLogo("Berachain"),
+    chainIconGray: getStableflowChainLogo("Berachain-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 80094,
+    blockExplorerUrl: "https://berascan.com/tx/",
+    blockExplorerUrls: ["https://berascan.com"],
+    primaryColor: "#F37325",
+    nativeToken: {
+      symbol: "BERA",
+      decimals: 18
+    },
+    ...getChainRpcUrl("bera")
+  },
+  xlayer: {
+    chainName: "X Layer",
+    blockchain: "xlayer",
+    chainIcon: getStableflowChainLogo("xlayer"),
+    chainIconGray: getStableflowChainLogo("xlayer-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 196,
+    blockExplorerUrl: "https://www.oklink.com/xlayer/tx/",
+    blockExplorerUrls: ["https://www.oklink.com"],
+    primaryColor: "#000000",
+    nativeToken: {
+      symbol: "OKB",
+      decimals: 18
+    },
+    ...getChainRpcUrl("xlayer")
+  },
+  plasma: {
+    chainName: "Plasma",
+    blockchain: "plasma",
+    chainIcon: getStableflowChainLogo("Plasma"),
+    chainIconGray: getStableflowChainLogo("Plasma-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 9745,
+    blockExplorerUrl: "https://plasmascan.to/tx/",
+    blockExplorerUrls: ["https://plasmascan.to"],
+    primaryColor: "#162F29",
+    nativeToken: {
+      symbol: "XPL",
+      decimals: 18
+    },
+    ...getChainRpcUrl("plasma")
+  },
+  ton: {
+    chainName: "Ton",
+    blockchain: "ton",
+    chainIcon: getStableflowChainLogo("Ton"),
+    chainIconGray: getStableflowChainLogo("Ton-gray"),
+    chainType: chainTypes.ton.value,
+    blockExplorerUrl: "https://tonviewer.com/transaction/",
+    blockExplorerUrls: ["https://tonviewer.com"],
+    primaryColor: "#0098EA",
+    nativeToken: {
+      symbol: "TON",
+      decimals: 9
+    },
+    ...getChainRpcUrl("ton")
+  },
+  mantle: {
+    chainName: "Mantle",
+    blockchain: "mantle",
+    chainIcon: getStableflowChainLogo("Mantle"),
+    chainIconGray: getStableflowChainLogo("Mantle-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 5e3,
+    blockExplorerUrl: "https://mantlescan.xyz/tx/",
+    blockExplorerUrls: ["https://mantlescan.xyz"],
+    primaryColor: "#162F29",
+    nativeToken: {
+      symbol: "MNT",
+      decimals: 18
+    },
+    ...getChainRpcUrl("mantle")
+  },
+  megaeth: {
+    chainName: "MegaETH",
+    blockchain: "megaeth",
+    chainIcon: getStableflowChainLogo("MegaETH"),
+    chainIconGray: getStableflowChainLogo("MegaETH-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 4326,
+    blockExplorerUrl: "https://mega.etherscan.io/tx/",
+    blockExplorerUrls: ["https://mega.etherscan.io"],
+    primaryColor: "#19191A",
+    nativeToken: {
+      symbol: "ETH",
+      decimals: 18
+    },
+    ...getChainRpcUrl("megaeth")
+  },
+  ink: {
+    chainName: "Ink",
+    blockchain: "ink",
+    chainIcon: getStableflowChainLogo("Ink"),
+    chainIconGray: getStableflowChainLogo("Ink-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 57073,
+    blockExplorerUrl: "https://explorer.inkonchain.com/tx/",
+    blockExplorerUrls: ["https://explorer.inkonchain.com"],
+    primaryColor: "#7132F5",
+    nativeToken: {
+      symbol: "ETH",
+      decimals: 18
+    },
+    ...getChainRpcUrl("ink")
+  },
+  stable: {
+    chainName: "Stable",
+    blockchain: "stable",
+    chainIcon: getStableflowChainLogo("Stable"),
+    chainIconGray: getStableflowChainLogo("Stable-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 988,
+    blockExplorerUrl: "https://uniscan.xyz/tx/",
+    blockExplorerUrls: ["https://uniscan.xyz"],
+    primaryColor: "#01241D",
+    nativeToken: {
+      symbol: "USDT0",
+      decimals: 18
+    },
+    ...getChainRpcUrl("stable")
+  },
+  celo: {
+    chainName: "Celo",
+    blockchain: "celo",
+    chainIcon: getStableflowChainLogo("Celo"),
+    chainIconGray: getStableflowChainLogo("Celo-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 42220,
+    blockExplorerUrl: "https://celoscan.io/tx/",
+    blockExplorerUrls: ["https://celoscan.io"],
+    primaryColor: "#FCFF52",
+    nativeToken: {
+      symbol: "CELO",
+      decimals: 18
+    },
+    ...getChainRpcUrl("celo")
+  },
+  sei: {
+    chainName: "Sei",
+    blockchain: "sei",
+    chainIcon: getStableflowChainLogo("Sei"),
+    chainIconGray: getStableflowChainLogo("Sei-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 1329,
+    blockExplorerUrl: "https://seitrace.com/tx/",
+    blockExplorerUrls: ["https://seitrace.com"],
+    primaryColor: "#991717",
+    nativeToken: {
+      symbol: "SEI",
+      decimals: 18
+    },
+    ...getChainRpcUrl("sei")
+  },
+  flare: {
+    chainName: "Flare",
+    blockchain: "flare",
+    chainIcon: getStableflowChainLogo("Flare"),
+    chainIconGray: getStableflowChainLogo("Flare-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 14,
+    blockExplorerUrl: "https://flare-explorer.flare.network/tx/",
+    blockExplorerUrls: ["https://flare-explorer.flare.network"],
+    primaryColor: "#E62058",
+    nativeToken: {
+      symbol: "FLR",
+      decimals: 18
+    },
+    ...getChainRpcUrl("flare")
+  },
+  frax: {
+    chainName: "Fraxtal",
+    blockchain: "frax",
+    chainIcon: getStableflowChainLogo("Frax"),
+    chainIconGray: getStableflowChainLogo("Frax-gray"),
+    chainType: chainTypes.evm.value,
+    chainId: 252,
+    blockExplorerUrl: "https://fraxscan.com/tx/",
+    blockExplorerUrls: ["https://fraxscan.com"],
+    primaryColor: "#000",
+    nativeToken: {
+      symbol: "FRAX",
+      decimals: 18
+    },
+    ...getChainRpcUrl("frax")
+  },
+  sui: {
+    ...getChainRpcUrl("sui")
+  },
+  katana: {
+    ...getChainRpcUrl("katana")
+  }
+};
+var chains_default = chains;
+
+// src/wallets/config/usdt.ts
+var usdt = {
+  symbol: "USDT",
+  decimals: 6,
+  icon: "/usdt.png",
+  name: "Tether USD"
+};
+var usdtChains = {
+  eth: {
+    ...usdt,
+    assetId: "nep141:eth-0xdac17f958d2ee523a2206206994597c13d831ec7.omft.near",
+    contractAddress: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+    ...chains_default.eth,
+    services: [Service.OneClick, Service.Usdt0, Service.Native]
+  },
+  bsc: {
+    ...usdt,
+    assetId: "nep245:v2_1.omni.hot.tg:56_2CMMyVTGZkeyNZTSvS5sarzfir6g",
+    contractAddress: "0x55d398326f99059ff775485246999027b3197955",
+    ...chains_default.bsc,
+    decimals: 18,
+    services: [Service.OneClick, Service.Native]
+  },
+  op: {
+    ...usdt,
+    assetId: "nep245:v2_1.omni.hot.tg:10_359RPSJVdTxwTJT9TyGssr2rFoWo",
+    contractAddress: "0x94b008aa00579c1307b0ef2c499ad98a8ce58e58",
+    ...chains_default.op,
+    services: [Service.OneClick]
+  },
+  avax: {
+    ...usdt,
+    assetId: "nep245:v2_1.omni.hot.tg:43114_372BeH7ENZieCaabwkbWkBiTTgXp",
+    contractAddress: "0x9702230a8ea53601f5cd2dc00fdbc13d4df4a8c7",
+    ...chains_default.avax,
+    services: [Service.OneClick]
+  },
+  // disabled gnosis temporarily, 22/Oct/2025
+  // gnosis: {
+  //   ...usdt,
+  //   assetId: "nep141:gnosis-0x4ecaba5870353805a9f068101a40e0f32ed605c6.omft.near",
+  //   contractAddress: "0x4ecaba5870353805a9f068101a40e0f32ed605c6",
+  //   ...chains.gnosis,
+  //   services: [Service.OneClick],
+  // },
+  near: {
+    ...usdt,
+    assetId: "nep141:usdt.tether-token.near",
+    contractAddress: "usdt.tether-token.near",
+    ...chains_default.near,
+    services: [Service.OneClick]
+  },
+  sol: {
+    ...usdt,
+    assetId: "nep141:sol-c800a4bd850783ccb82c2b2c7e84175443606352.omft.near",
+    contractAddress: "Es9vMFrzaCERmJfrF4H2FYD4KCoNkY11McCe8BenwNYB",
+    ...chains_default.sol,
+    services: [Service.OneClick, Service.Usdt0]
+  },
+  tron: {
+    ...usdt,
+    assetId: "nep141:tron-d28a265909efecdcee7c5028585214ea0b96f015.omft.near",
+    contractAddress: "TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t",
+    ...chains_default.tron,
+    services: [Service.OneClick, Service.Usdt0]
+  },
+  aptos: {
+    ...usdt,
+    assetId: "nep141:aptos-88cb7619440a914fe6400149a12b443c3ac21d59.omft.near",
+    contractAddress: "0x357b0b74bc833e95a115ad22604854d6b0fca151cecd94111770e5d6ffc9dc2b",
+    ...chains_default.aptos,
+    services: [Service.OneClick]
+  },
+  ton: {
+    ...usdt,
+    assetId: "nep245:v2_1.omni.hot.tg:1117_3tsdfyziyc7EJbP2aULWSKU4toBaAcN4FdTgfm5W1mC4ouR",
+    contractAddress: "EQCxE6mUtQJKFnGfaROTKOt1lZbDiiX1kCixRv7Nw2Id_sDs",
+    ...chains_default.ton,
+    services: [Service.OneClick, Service.Usdt0]
+  }
+};
+({
+  ...usdtChains.sol,
+  chains: [usdtChains.sol]
+});
+({
+  ...usdtChains.near,
+  chains: [usdtChains.near]
+});
+({
+  chains: Object.values(usdtChains).filter((chain) => chain.chainType === "evm")
+});
+({
+  ...usdtChains.tron,
+  chains: [usdtChains.tron]
+});
+({
+  ...usdtChains.aptos,
+  chains: [usdtChains.aptos]
+});
+({
+  ...usdtChains.ton,
+  chains: [usdtChains.ton]
+});
+
+// src/wallets/config/usdt0.ts
+var usdt0 = {
+  symbol: "USD\u20AE0",
+  decimals: 6,
+  icon: "/usdt0.png",
+  name: "USD\u20AE0"
+};
+var usdt0Chains = {
+  // eth: {
+  //   ...usdt0,
+  //   symbol: "USDT",
+  //   icon: "/usdt.png",
+  //   assetId: "nep141:eth-0xdac17f958d2ee523a2206206994597c13d831ec7.omft.near",
+  //   contractAddress: "0xdac17f958d2ee523a2206206994597c13d831ec7",
+  //   ...chains.eth,
+  //   services: [Service.OneClick, Service.Usdt0, Service.Native],
+  // },
+  arb: {
+    ...usdt0,
+    assetId: "nep141:arb-0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9.omft.near",
+    contractAddress: "0xfd086bc7cd5c481dcc9c85ebe478a1c0b69fcbb9",
+    ...chains_default.arb,
+    services: [Service.OneClick, Service.Usdt0, Service.Native]
+  },
+  pol: {
+    ...usdt0,
+    assetId: "nep245:v2_1.omni.hot.tg:137_3hpYoaLtt8MP1Z2GH1U473DMRKgr",
+    contractAddress: "0xc2132d05d31c914a87c6611c10748aeb04b58e8f",
+    ...chains_default.pol,
+    services: [Service.OneClick, Service.Usdt0]
+  },
+  op: {
+    ...usdt0,
+    assetId: "",
+    contractAddress: "0x01bFF41798a0BcF287b996046Ca68b395DbC1071",
+    ...chains_default.op,
+    services: [Service.Usdt0]
+  },
+  bera: {
+    ...usdt0,
+    assetId: "nep141:bera-0x779ded0c9e1022225f8e0630b35a9b54be713736.omft.near",
+    contractAddress: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+    ...chains_default.bera,
+    services: [Service.OneClick, Service.Usdt0]
+  },
+  xlayer: {
+    ...usdt0,
+    assetId: "nep245:v2_1.omni.hot.tg:196_2fezDCvVYRsG8wrK6deJ2VRPiAS1",
+    contractAddress: "0x779ded0c9e1022225f8e0630b35a9b54be713736",
+    ...chains_default.xlayer,
+    services: [Service.OneClick, Service.Usdt0]
+  },
+  plasma: {
+    ...usdt0,
+    assetId: "nep245:v2_1.omni.hot.tg:9745_3aL9skCy1yhPoDB8oKMmRHRN7SJW",
+    contractAddress: "0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb",
+    ...chains_default.plasma,
+    services: [Service.OneClick, Service.Usdt0]
+  },
+  mantle: {
+    ...usdt0,
+    assetId: "",
+    contractAddress: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+    ...chains_default.mantle,
+    services: [Service.Usdt0]
+  },
+  megaeth: {
+    ...usdt0,
+    assetId: "",
+    contractAddress: "0xb8ce59fc3717ada4c02eadf9682a9e934f625ebb",
+    ...chains_default.megaeth,
+    services: [Service.Usdt0]
+  },
+  ink: {
+    ...usdt0,
+    assetId: "",
+    contractAddress: "0x0200C29006150606B650577BBE7B6248F58470c1",
+    ...chains_default.ink,
+    services: [Service.Usdt0]
+  },
+  stable: {
+    ...usdt0,
+    assetId: "",
+    contractAddress: "0x779Ded0c9e1022225f8E0630b35a9b54bE713736",
+    ...chains_default.stable,
+    services: [Service.Usdt0]
+  },
+  celo: {
+    ...usdt0,
+    assetId: "",
+    contractAddress: "0x48065fbBE25f71C9282ddf5e1cD6D6A887483D5e",
+    ...chains_default.celo,
+    services: [Service.Usdt0]
+  },
+  sei: {
+    ...usdt0,
+    assetId: "",
+    contractAddress: "0x9151434b16b9763660705744891fA906F660EcC5",
+    ...chains_default.sei,
+    services: [Service.Usdt0]
+  },
+  flare: {
+    ...usdt0,
+    assetId: "",
+    contractAddress: "0xe7cd86e13AC4309349F30B3435a9d337750fC82D",
+    ...chains_default.flare,
+    services: [Service.Usdt0]
+  }
+};
+({
+  chains: Object.values(usdt0Chains).filter((chain) => chain.chainType === "evm")
+});
+
+// src/wallets/config/usdc.ts
+var usdc = {
+  symbol: "USDC",
+  decimals: 6,
+  icon: "/usdc.png",
+  name: "USD Coin"
+};
+var usdcChains = {
+  eth: {
+    ...usdc,
+    assetId: "nep141:eth-0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48.omft.near",
+    contractAddress: "0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48",
+    ...chains_default.eth,
+    services: [Service.OneClick, Service.CCTP, Service.Native]
+  },
+  arb: {
+    ...usdc,
+    assetId: "nep141:arb-0xaf88d065e77c8cc2239327c5edb3a432268e5831.omft.near",
+    contractAddress: "0xaf88d065e77c8cc2239327c5edb3a432268e5831",
+    ...chains_default.arb,
+    services: [Service.OneClick, Service.CCTP, Service.Native]
+  },
+  base: {
+    ...usdc,
+    assetId: "nep141:base-0x833589fcd6edb6e08f4c7c32d4f71b54bda02913.omft.near",
+    contractAddress: "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913",
+    ...chains_default.base,
+    services: [Service.OneClick, Service.CCTP, Service.Native]
+  },
+  // gnosis: {
+  //   ...usdc,
+  //   assetId:
+  //     "nep141:gnosis-0x2a22f9c3b484c3629090feed35f17ff8f88f76f0.omft.near",
+  //   contractAddress: "0x2a22f9c3b484c3629090feed35f17ff8f88f76f0",
+  //   ...chains.gnosis,
+  //   services: [Service.OneClick],
+  // },
+  pol: {
+    ...usdc,
+    assetId: "nep245:v2_1.omni.hot.tg:137_qiStmoQJDQPTebaPjgx5VBxZv6L",
+    contractAddress: "0x3c499c542cef5e3811e1192ce70d8cc03d5c3359",
+    ...chains_default.pol,
+    services: [Service.OneClick, Service.CCTP]
+  },
+  bsc: {
+    ...usdc,
+    assetId: "nep245:v2_1.omni.hot.tg:56_2w93GqMcEmQFDru84j3HZZWt557r",
+    contractAddress: "0x8ac76a51cc950d9822d68b83fe1ad97b32cd580d",
+    ...chains_default.bsc,
+    decimals: 18,
+    services: [Service.OneClick, Service.Native]
+  },
+  op: {
+    ...usdc,
+    assetId: "nep245:v2_1.omni.hot.tg:10_A2ewyUyDp6qsue1jqZsGypkCxRJ",
+    contractAddress: "0x0b2c639c533813f4aa9d7837caf62653d097ff85",
+    ...chains_default.op,
+    services: [Service.OneClick, Service.CCTP]
+  },
+  avax: {
+    ...usdc,
+    assetId: "nep245:v2_1.omni.hot.tg:43114_3atVJH3r5c4GqiSYmg9fECvjc47o",
+    contractAddress: "0xb97ef9ef8734c71904d8002f8b6bc66dd9c48a6e",
+    ...chains_default.avax,
+    services: [Service.OneClick, Service.CCTP]
+  },
+  near: {
+    ...usdc,
+    assetId: "nep141:17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1",
+    contractAddress: "17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1",
+    ...chains_default.near,
+    services: [Service.OneClick]
+  },
+  sol: {
+    ...usdc,
+    assetId: "nep141:sol-5ce3bf3a31af18be40ba30f721101b4341690186.omft.near",
+    contractAddress: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+    ...chains_default.sol,
+    services: [Service.OneClick, Service.CCTP]
+  },
+  xlayer: {
+    ...usdc,
+    assetId: "nep245:v2_1.omni.hot.tg:196_2dK9kLNR7Ekq7su8FxNGiUW3djTw",
+    contractAddress: "0x74b7f16337b8972027f6196a17a631ac6de26d22",
+    ...chains_default.xlayer,
+    services: [Service.OneClick]
+  },
+  aptos: {
+    ...usdc,
+    assetId: "nep141:aptos-34ee497f210c5a511e8d5b53bc56d75b63612bb5.omft.near",
+    contractAddress: "0xbae207659db88bea0cbead6da0ed00aac12edcdda169e591cd41c94180b46f3b",
+    ...chains_default.aptos,
+    services: [Service.OneClick]
+  }
+};
+({
+  ...usdcChains.sol,
+  chains: [usdcChains.sol]
+});
+({
+  ...usdcChains.near,
+  chains: [usdcChains.near]
+});
+({
+  ...usdcChains.aptos,
+  chains: [usdcChains.aptos]
+});
+({
+  chains: Object.values(usdcChains).filter((chain) => chain.chainType === "evm")
+});
+
+// src/wallets/config/frxusd.ts
+var frxusd = {
+  symbol: "frxUSD",
+  decimals: 18,
+  icon: "/frxusd.png",
+  name: "Frax USD"
+};
+var frxusdChains = {
+  frax: {
+    ...frxusd,
+    assetId: "",
+    contractAddress: "0xFc00000000000000000000000000000000000001",
+    ...chains_default.frax,
+    services: [Service.FraxZero]
+  },
+  eth: {
+    ...frxusd,
+    assetId: "",
+    contractAddress: "0xCAcd6fd266aF91b8AeD52aCCc382b4e165586E29",
+    ...chains_default.eth,
+    services: [Service.FraxZero]
+  },
+  arb: {
+    ...frxusd,
+    assetId: "",
+    contractAddress: "0x80Eede496655FB9047dd39d9f418d5483ED600df",
+    ...chains_default.arb,
+    services: [Service.FraxZero]
+  },
+  avax: {
+    ...frxusd,
+    assetId: "",
+    contractAddress: "0x80Eede496655FB9047dd39d9f418d5483ED600df",
+    ...chains_default.avax,
+    services: [Service.FraxZero]
+  },
+  // base: {
+  //   ...frxusd,
+  //   assetId: "",
+  //   contractAddress: "0xe5020A6d073a794B6E7f05678707dE47986Fb0b6",
+  //   ...chains.base,
+  //   services: [Service.FraxZero],
+  // },
+  bera: {
+    ...frxusd,
+    assetId: "",
+    contractAddress: "0x80Eede496655FB9047dd39d9f418d5483ED600df",
+    ...chains_default.bera,
+    services: [Service.FraxZero]
+  },
+  bsc: {
+    ...frxusd,
+    assetId: "",
+    contractAddress: "0x80Eede496655FB9047dd39d9f418d5483ED600df",
+    ...chains_default.bsc,
+    services: [Service.FraxZero]
+  },
+  op: {
+    ...frxusd,
+    assetId: "",
+    contractAddress: "0x80Eede496655FB9047dd39d9f418d5483ED600df",
+    ...chains_default.op,
+    services: [Service.FraxZero]
+  },
+  pol: {
+    ...frxusd,
+    assetId: "",
+    contractAddress: "0x80Eede496655FB9047dd39d9f418d5483ED600df",
+    ...chains_default.pol,
+    services: [Service.FraxZero]
+  },
+  xlayer: {
+    ...frxusd,
+    assetId: "",
+    contractAddress: "0x80eede496655fb9047dd39d9f418d5483ed600df",
+    ...chains_default.xlayer,
+    services: [Service.FraxZero]
+  },
+  sol: {
+    ...frxusd,
+    assetId: "",
+    contractAddress: "GzX1ireZDU865FiMaKrdVB1H6AE8LAqWYCg6chrMrfBw",
+    decimals: 9,
+    ...chains_default.sol,
+    services: [Service.FraxZero]
+  }
+};
+({
+  ...frxusdChains.sol,
+  chains: [frxusdChains.sol]
+});
+({
+  chains: Object.values(frxusdChains).filter((chain) => chain.chainType === "evm")
+});
+
+// src/wallets/config/tokens.ts
+var tokens = [
+  ...Object.values(usdtChains),
+  ...Object.values(usdcChains),
+  ...Object.values(usdt0Chains),
+  ...Object.values(frxusdChains)
+];
+var usdtTokens = [...Object.values(usdtChains), ...Object.values(usdt0Chains)];
+var usdcTokens = Object.values(usdcChains);
+var frxusdTokens = Object.values(frxusdChains);
+
+// src/wallets/config/addresses.ts
+var DefaultAddresses = {
+  near: "stableflow.near",
+  sol: "2bRTgL16xgu6VkSRY7TJcLRuT93T1pLtaYeChhyhfFcX",
+  evm: "0x10b06e6A12E86f8C2b55B5073fA3dB39b120C7F5",
+  tron: "TSKMAaJLnWAUa6cKtTTm5oathCQPPaJZtF",
+  aptos: "0x93493b07d031c4f18ad1e874575761be7e47d4cea5c81d538600e8ec72d6ab1c",
+  ton: "UQBv1hzUIB5liMe1cqxUAvfO2tWMnN6wDyXP4DFSptAbePVK",
+  sui: "0xeae6dbc896a8a6994c093bf8ea47116063f0b016f1fdc61bff95ba9dfb36c4d2"
+};
+
+// src/wallets/config/erc20.ts
+var erc20_default = [
+  {
+    inputs: [
+      { internalType: "address", name: "owner", type: "address" },
+      { internalType: "address", name: "spender", type: "address" }
+    ],
+    name: "allowance",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "spender", type: "address" },
+      { internalType: "uint256", name: "value", type: "uint256" }
+    ],
+    name: "approve",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint256", name: "value", type: "uint256" }
+    ],
+    name: "transfer",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+
+// src/utils/price.ts
+function getPrice(prices, symbol) {
+  let price = "1";
+  if (prices[symbol]) {
+    price = prices[symbol];
+    if (price !== "0") {
+      return price;
+    }
+  }
+  if (prices[symbol.toLowerCase()]) {
+    price = prices[symbol.toLowerCase()];
+    if (price !== "0") {
+      return price;
+    }
+  }
+  if (prices[symbol.toUpperCase()]) {
+    price = prices[symbol.toUpperCase()];
+    if (price !== "0") {
+      return price;
+    }
+  }
+  return "1";
+}
+var addThousandSeparator = (numberString) => {
+  if (!numberString) return "0";
+  const parts = String(numberString).split(".");
+  const integerPart = parts[0].replace(/\B(?=(\d{3})+(?!\d))/g, ",");
+  const decimalPart = parts[1] ? `.${parts[1]}` : "";
+  return integerPart + decimalPart;
+};
+var formatNumber = (value, precision, isSimple, options) => {
+  const {
+    prefix = "",
+    isLTIntegerZero,
+    isZeroPrecision,
+    isShort,
+    isShortUppercase,
+    round = Big.roundHalfUp,
+    isLessPrecision = true
+  } = options || {};
+  const isValid = () => {
+    try {
+      if (!value) return false;
+      Big(value);
+      return true;
+    } catch (err) {
+      return false;
+    }
+  };
+  if (!value || !isValid() || Big(value).eq(0)) {
+    if (isSimple) {
+      if (isZeroPrecision) {
+        return `${prefix}${Big(0).toFixed(precision, round)}`;
+      }
+      return `${prefix}0`;
+    }
+    if (isZeroPrecision) {
+      return {
+        integer: `${prefix}0`,
+        decimal: Big(0).toFixed(precision, round).replace(/^\d/, "")
+      };
+    }
+    return {
+      integer: `${prefix}0`,
+      decimal: ""
+    };
+  }
+  if (isLessPrecision && Big(value).lt(Big(10).pow(-precision))) {
+    if (isSimple) {
+      return `< ${prefix}${Big(10).pow(-precision).toFixed(precision, round)}`;
+    }
+    if (isLTIntegerZero) {
+      return {
+        integer: `< ${prefix}0`,
+        decimal: Big(10).pow(-precision).toFixed(precision, round).replace(/^\d/, "")
+      };
+    }
+    return {
+      integer: "",
+      decimal: `< ${prefix}${Big(10).pow(-precision).toFixed(precision, round)}`
+    };
+  }
+  const finalValue = addThousandSeparator(Big(value).toFixed(precision, round));
+  const firstPart = finalValue.split(".")[0];
+  let secondPart = finalValue.split(".")[1] || "";
+  if (secondPart) {
+    secondPart = "." + secondPart;
+  }
+  if (isSimple) {
+    if (isShort) {
+      const formatter = (split, unit) => {
+        const _num = Big(value).div(split).toFixed(precision, 0).replace(/(?:\.0*|(\.\d+?)0+)$/, "$1");
+        const inter = _num.split(".")?.[0]?.replace(/\d(?=(\d{3})+\b)/g, "$&,");
+        const decimal = _num.split(".")?.[1] ?? "";
+        return `${prefix}${inter}${decimal ? "." + decimal : ""}${unit}`;
+      };
+      if (Big(value).gte(1e12)) {
+        return formatter(1e12, isShortUppercase ? "T" : "t");
+      }
+      if (Big(value).gte(1e9)) {
+        return formatter(1e9, isShortUppercase ? "B" : "b");
+      }
+      if (Big(value).gte(1e6)) {
+        return formatter(1e6, isShortUppercase ? "M" : "m");
+      }
+      if (Big(value).gte(1e3)) {
+        return formatter(1e3, isShortUppercase ? "K" : "k");
+      }
+    }
+    if (isZeroPrecision) {
+      return `${prefix}${firstPart}${secondPart}`;
+    }
+    return `${prefix}${firstPart}${secondPart.replace(/[.]?0*$/, "")}`;
+  }
+  if (isZeroPrecision) {
+    return {
+      integer: `${prefix}${firstPart}`,
+      decimal: secondPart
+    };
+  }
+  return {
+    integer: `${prefix}${firstPart}`,
+    decimal: secondPart.replace(/[.]?0*$/, "")
+  };
+};
+var numberRemoveEndZero = (value) => {
+  return value.replace("-", "").replace(/\.?0+$/, "");
+};
+function zeroPadValue(hex, lengthBytes) {
+  const normalized = hex.startsWith("0x") ? hex.slice(2) : hex;
+  const targetLen = lengthBytes * 2;
+  if (normalized.length > targetLen) {
+    throw new Error(`hex value exceeds ${lengthBytes} bytes`);
+  }
+  return "0x" + normalized.padStart(targetLen, "0");
+}
+function tronAddressToBytes32(tronAddress) {
+  try {
+    const decoded = bs58.decode(tronAddress);
+    const addressBytes = decoded.slice(1, 21);
+    if (addressBytes.length !== 20) {
+      throw new Error("Invalid Tron address length");
+    }
+    const paddedBytes = Buffer.concat([
+      Buffer.alloc(12, 0),
+      // 12 zero bytes
+      addressBytes
+      // 20-byte address
+    ]);
+    return "0x" + paddedBytes.toString("hex");
+  } catch (error) {
+    throw new Error(`Failed to convert Tron address: ${error.message}`);
+  }
+}
+function solanaAddressToBytes32(solanaAddress) {
+  const decoded = bs58.decode(solanaAddress);
+  if (decoded.length !== 32) {
+    throw new Error("Invalid Solana address length");
+  }
+  return "0x" + Buffer.from(decoded).toString("hex");
+}
+function tonAddressToBytes32(tonAddress) {
+  try {
+    const parsed = parseTonAddress(tonAddress);
+    if (parsed.hash.length !== 32) {
+      throw new Error("Invalid TON address hash length");
+    }
+    return "0x" + bytesToHex(parsed.hash);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Failed to convert TON address: ${message}`);
+  }
+}
+function addressToBytes32(chainType, address) {
+  if (chainType === "evm") {
+    return zeroPadValue(address, 32);
+  }
+  if (chainType === "sol") {
+    return solanaAddressToBytes32(address);
+  }
+  if (chainType === "tron") {
+    return tronAddressToBytes32(address);
+  }
+  if (chainType === "ton") {
+    return tonAddressToBytes32(address);
+  }
+  return address;
+}
+function parseTonAddress(address) {
+  const input = address.trim();
+  if (!input) {
+    throw new Error("Address is empty");
+  }
+  if (isRawTonAddress(input)) {
+    return parseRawTonAddress(input);
+  }
+  return parseUserFriendlyTonAddress(input);
+}
+function crc16Ccitt(data) {
+  let crc = 0;
+  for (const byte of data) {
+    crc ^= byte << 8;
+    for (let i = 0; i < 8; i++) {
+      if ((crc & 32768) !== 0) {
+        crc = (crc << 1 ^ 4129) & 65535;
+      } else {
+        crc = crc << 1 & 65535;
+      }
+    }
+  }
+  return new Uint8Array([crc >> 8 & 255, crc & 255]);
+}
+function base64ToBytes(input) {
+  let normalized = input.replace(/-/g, "+").replace(/_/g, "/");
+  const padding = normalized.length % 4;
+  if (padding === 2) {
+    normalized += "==";
+  } else if (padding === 3) {
+    normalized += "=";
+  } else if (padding !== 0) {
+    throw new Error("Invalid base64 TON address");
+  }
+  if (typeof Buffer !== "undefined") {
+    return new Uint8Array(Buffer.from(normalized, "base64"));
+  }
+  if (typeof atob !== "undefined") {
+    const binary = atob(normalized);
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i++) {
+      bytes[i] = binary.charCodeAt(i);
+    }
+    return bytes;
+  }
+  throw new Error("No base64 decoder available");
+}
+function hexToBytes(hex) {
+  if (hex.length % 2 !== 0) {
+    throw new Error("Invalid hex string");
+  }
+  const bytes = new Uint8Array(hex.length / 2);
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = Number.parseInt(hex.slice(i * 2, i * 2 + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new Error("Invalid hex string");
+    }
+    bytes[i] = byte;
+  }
+  return bytes;
+}
+function bytesToHex(bytes) {
+  return Array.from(bytes).map((byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function isRawTonAddress(address) {
+  return /^-?\d+:[0-9a-fA-F]{64}$/.test(address);
+}
+function parseRawTonAddress(address) {
+  const [workchainPart, hashPart] = address.split(":");
+  if (!workchainPart || !hashPart) {
+    throw new Error("Invalid raw TON address");
+  }
+  const workchain = Number(workchainPart);
+  if (!Number.isInteger(workchain)) {
+    throw new Error("Invalid TON workchain");
+  }
+  if (!/^[0-9a-fA-F]{64}$/.test(hashPart)) {
+    throw new Error("Invalid TON address hash");
+  }
+  return {
+    workchain,
+    hash: hexToBytes(hashPart),
+    isUserFriendly: false
+  };
+}
+function parseUserFriendlyTonAddress(address) {
+  if (!/^[A-Za-z0-9+/_-]{48}$/.test(address)) {
+    throw new Error("Invalid user-friendly TON address format");
+  }
+  const data = base64ToBytes(address);
+  if (data.length !== 36) {
+    throw new Error("Invalid user-friendly TON address length");
+  }
+  const body = data.slice(0, 34);
+  const checksum = data.slice(34, 36);
+  const expectedChecksum = crc16Ccitt(body);
+  if (checksum[0] !== expectedChecksum[0] || checksum[1] !== expectedChecksum[1]) {
+    throw new Error("Invalid TON address checksum");
+  }
+  const flags = data[0];
+  const isTestOnly = (flags & 128) !== 0;
+  const tag = flags & 127;
+  if (tag !== 17 && tag !== 81) {
+    throw new Error("Invalid TON address flags");
+  }
+  const isBounceable = tag === 17;
+  const workchainByte = data[1];
+  const workchain = workchainByte === 255 ? -1 : workchainByte;
+  const hash = data.slice(2, 34);
+  if (hash.length !== 32) {
+    throw new Error("Invalid TON address hash length");
+  }
+  return {
+    workchain,
+    hash,
+    isUserFriendly: true,
+    isBounceable,
+    isTestOnly
+  };
+}
+
+// src/utils/exec-time.ts
+var ExecTime = class {
+  constructor(options) {
+    this.startTimestamp = 0;
+    this.currentTimestamp = 0;
+    this.performanceThreshold = 1e3;
+    const { type, logStyle, isPerformance, isDebug } = options;
+    this.type = type;
+    this.logStyle = logStyle ?? "stone-500";
+    this.isPerformance = isPerformance ?? false;
+    this.isDebug = isDebug;
+    this.csl = new Csl(isDebug);
+    if (!isDebug) return;
+    this.startTimestamp = performance.now();
+    this.currentTimestamp = this.startTimestamp;
+  }
+  breakpoint() {
+    if (!this.isDebug) return;
+    this.currentTimestamp = performance.now();
+  }
+  log(subType, str, ...params) {
+    const duration = performance.now() - this.currentTimestamp;
+    if (this.isPerformance) {
+      if (duration <= this.performanceThreshold) {
+        return;
+      }
+    }
+    this.csl.log(this.type, this.logStyle, `<${subType}>cost: %c%sms%c${str ? ", " + str : ""}`, "color:red;font-weight:bold;", duration.toFixed(0), "color:black;font-weight:normal;", ...params);
+  }
+  logTotal(subType, str, ...params) {
+    const duration = performance.now() - this.startTimestamp;
+    this.csl.log(this.type, this.logStyle, `<${subType}>total cost: %c%sms%c${str ? ", " + str : ""}`, "color:red;font-weight:bold;", duration.toFixed(0), "color:black;font-weight:normal;", ...params);
+  }
+};
+var formatQuoteError = (error, options) => {
+  const { service, fromToken } = options;
+  const defaultErrorMessage = "Failed to get quote, please try again later";
+  if (service === Service.OneClick) {
+    const getQuoteErrorMessage = () => {
+      const _messageResult = {
+        message: defaultErrorMessage,
+        sourceMessage: error?.response?.data?.message || defaultErrorMessage
+      };
+      if (error?.response?.data?.message && error?.response?.data?.message !== "Internal server error") {
+        if (error?.response?.data?.message === "Failed to get quote") {
+          _messageResult.message = "Amount exceeds max";
+          return _messageResult;
+        }
+        if (error?.response?.data?.message?.includes("Amount is too low for bridge, try at least")) {
+          const match = error.response.data.message.match(/try at least\s+(\d+(?:\.\d+)?)/i);
+          let minimumAmount = match ? match[1] : Big(1).times(10 ** fromToken.decimals).toFixed(0);
+          minimumAmount = Big(minimumAmount).div(10 ** fromToken.decimals).toFixed(fromToken.decimals);
+          _messageResult.message = `Amount is too low, at least ${minimumAmount}`;
+          return _messageResult;
+        }
+        return _messageResult;
+      }
+      return _messageResult;
+    };
+    const onclickErrMsg = getQuoteErrorMessage();
+    return {
+      serviceType: service,
+      error: onclickErrMsg.message
+    };
+  }
+  return {
+    serviceType: service,
+    error: error?.message || defaultErrorMessage
+  };
+};
+
+// src/utils/service.ts
+var getRouteStatus = (service, disabledServices) => {
+  const result = { disabled: false };
+  if (!disabledServices || disabledServices.length === 0) {
+    return result;
+  }
+  const IS_PAUSE_ONECLICK = disabledServices.includes(Service.OneClick);
+  const IS_PAUSE_USDT0 = disabledServices.includes(Service.Usdt0);
+  const IS_PAUSE_CCTP = disabledServices.includes(Service.CCTP);
+  const IS_PAUSE_FRAXZERO = disabledServices.includes(Service.FraxZero);
+  const IS_PAUSE_NATIVE = disabledServices.includes(Service.Native);
+  const IS_PAUSE_USDT0_ONECLICK = disabledServices.includes(Service.OneClickUsdt0);
+  const IS_PAUSE_ONECLICK_USDT0 = disabledServices.includes(Service.OneClickUsdt0);
+  const IS_PAUSE_FRAXZERO_ONECLICK = disabledServices.includes(Service.FraxZeroOneClick);
+  const IS_PAUSE_ONECLICK_FRAXZERO = disabledServices.includes(Service.OneClickFraxZero);
+  const IS_PAUSE_ALL = IS_PAUSE_ONECLICK && IS_PAUSE_USDT0 && IS_PAUSE_CCTP && IS_PAUSE_FRAXZERO && IS_PAUSE_NATIVE;
+  if (IS_PAUSE_ALL) {
+    result.disabled = true;
+    return result;
+  }
+  if (service === Service.CCTP) {
+    if (IS_PAUSE_CCTP) {
+      result.disabled = true;
+      return result;
+    }
+  }
+  if (service === Service.FraxZero) {
+    if (IS_PAUSE_FRAXZERO) {
+      result.disabled = true;
+      return result;
+    }
+  }
+  if ([Service.FraxZeroOneClick, Service.OneClickFraxZero].includes(service)) {
+    if (IS_PAUSE_ONECLICK || IS_PAUSE_FRAXZERO) {
+      result.disabled = true;
+      return result;
+    }
+  }
+  if (service === Service.Native) {
+    if (IS_PAUSE_NATIVE) {
+      result.disabled = true;
+      return result;
+    }
+  }
+  if (service === Service.OneClick) {
+    if (IS_PAUSE_ONECLICK) {
+      result.disabled = true;
+      return result;
+    }
+  }
+  if (service === Service.Usdt0) {
+    if (IS_PAUSE_USDT0) {
+      result.disabled = true;
+      return result;
+    }
+  }
+  if ([Service.Usdt0OneClick, Service.OneClickUsdt0].includes(service)) {
+    if (IS_PAUSE_ONECLICK || IS_PAUSE_USDT0) {
+      result.disabled = true;
+      return result;
+    }
+  }
+  if (service === Service.Usdt0OneClick) {
+    if (IS_PAUSE_USDT0_ONECLICK) {
+      result.disabled = true;
+      return result;
+    }
+  }
+  if (service === Service.OneClickUsdt0) {
+    if (IS_PAUSE_ONECLICK_USDT0) {
+      result.disabled = true;
+      return result;
+    }
+  }
+  if (service === Service.FraxZeroOneClick) {
+    if (IS_PAUSE_FRAXZERO_ONECLICK) {
+      result.disabled = true;
+      return result;
+    }
+  }
+  if (service === Service.OneClickFraxZero) {
+    if (IS_PAUSE_ONECLICK_FRAXZERO) {
+      result.disabled = true;
+      return result;
+    }
+  }
+  return result;
+};
+
+// src/utils/cctp.ts
+async function quoteSignature(params) {
+  const response = await request(OpenAPI, {
+    method: "POST",
+    url: "/v0/cctp/sign",
+    body: params,
+    headers: {
+      "Content-Type": "application/json"
+    },
+    errors: {
+      400: `Bad Request - Invalid input data`,
+      401: `Unauthorized - JWT token is invalid`
+    }
+  });
+  return response.data ?? {};
+}
+
+export { ApiError, CancelError, CancelablePromise, Csl, DefaultAddresses, ExecTime, GetExecutionStatusResponse, NetworkRpcUrlsMap, OpenAPI, QuoteRequest, SFA, SendType, Service, ServiceBackend, SubmitDepositTxResponse, TokenResponse, TransactionStatus, addressToBytes32, erc20_default as erc20Abi, formatNumber, formatQuoteError, frxusdChains, frxusdTokens, getChainRpcUrl, getPrice, getRouteStatus, getRpcUrls, numberRemoveEndZero, quoteSignature, request, setRpcUrls, tokens, usdcChains, usdcTokens, usdt0Chains, usdtChains, usdtTokens };
+//# sourceMappingURL=index.mjs.map
+//# sourceMappingURL=index.mjs.map