teleton 0.1.7 → 0.1.9

package/dist/{chunk-TQBJNXWV.js → chunk-7AUS3OYB.js}

@@ -12020,7 +12020,697 @@ import { WalletContractV5R1 as WalletContractV5R17, TonClient as TonClient9, toN
 import { SendMode as SendMode6 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint9 } from "@orbs-network/ton-access";
 import { DEX, pTON } from "@ston-fi/sdk";
-import { StonApiClient } from "@ston-fi/api";
+
+// node_modules/@ston-fi/api/dist/esm/index.js
+import { ofetch } from "ofetch";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+      key = keys[i];
+      if (!__hasOwnProp.call(to, key) && key !== except) {
+        __defProp(to, key, {
+          get: ((k) => from[k]).bind(null, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+      }
+    }
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+  value: mod,
+  enumerable: true
+}) : target, mod));
+var normalizeDate = (date) => {
+  return date.toISOString().split(".")[0];
+};
+var require_map_obj = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+  const isObject2 = (value) => typeof value === "object" && value !== null;
+  const mapObjectSkip2 = /* @__PURE__ */ Symbol("skip");
+  const isObjectCustom2 = (value) => isObject2(value) && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
+  const mapObject2 = (object, mapper, options, isSeen = /* @__PURE__ */ new WeakMap()) => {
+    options = {
+      deep: false,
+      target: {},
+      ...options
+    };
+    if (isSeen.has(object)) return isSeen.get(object);
+    isSeen.set(object, options.target);
+    const { target } = options;
+    delete options.target;
+    const mapArray = (array) => array.map((element) => isObjectCustom2(element) ? mapObject2(element, mapper, options, isSeen) : element);
+    if (Array.isArray(object)) return mapArray(object);
+    for (const [key, value] of Object.entries(object)) {
+      const mapResult = mapper(key, value, object);
+      if (mapResult === mapObjectSkip2) continue;
+      let [newKey, newValue, { shouldRecurse = true } = {}] = mapResult;
+      if (newKey === "__proto__") continue;
+      if (options.deep && shouldRecurse && isObjectCustom2(newValue)) newValue = Array.isArray(newValue) ? mapArray(newValue) : mapObject2(newValue, mapper, options, isSeen);
+      target[newKey] = newValue;
+    }
+    return target;
+  };
+  module.exports = (object, mapper, options) => {
+    if (!isObject2(object)) throw new TypeError(`Expected an object, got \`${object}\` (${typeof object})`);
+    return mapObject2(object, mapper, options);
+  };
+  module.exports.mapObjectSkip = mapObjectSkip2;
+}));
+var import_map_obj = /* @__PURE__ */ __toESM(require_map_obj(), 1);
+var QuickLRU = class extends Map {
+  constructor(options = {}) {
+    super();
+    if (!(options.maxSize && options.maxSize > 0)) throw new TypeError("`maxSize` must be a number greater than 0");
+    if (typeof options.maxAge === "number" && options.maxAge === 0) throw new TypeError("`maxAge` must be a number greater than 0");
+    this.maxSize = options.maxSize;
+    this.maxAge = options.maxAge || Number.POSITIVE_INFINITY;
+    this.onEviction = options.onEviction;
+    this.cache = /* @__PURE__ */ new Map();
+    this.oldCache = /* @__PURE__ */ new Map();
+    this._size = 0;
+  }
+  _emitEvictions(cache$2) {
+    if (typeof this.onEviction !== "function") return;
+    for (const [key, item] of cache$2) this.onEviction(key, item.value);
+  }
+  _deleteIfExpired(key, item) {
+    if (typeof item.expiry === "number" && item.expiry <= Date.now()) {
+      if (typeof this.onEviction === "function") this.onEviction(key, item.value);
+      return this.delete(key);
+    }
+    return false;
+  }
+  _getOrDeleteIfExpired(key, item) {
+    if (this._deleteIfExpired(key, item) === false) return item.value;
+  }
+  _getItemValue(key, item) {
+    return item.expiry ? this._getOrDeleteIfExpired(key, item) : item.value;
+  }
+  _peek(key, cache$2) {
+    const item = cache$2.get(key);
+    return this._getItemValue(key, item);
+  }
+  _set(key, value) {
+    this.cache.set(key, value);
+    this._size++;
+    if (this._size >= this.maxSize) {
+      this._size = 0;
+      this._emitEvictions(this.oldCache);
+      this.oldCache = this.cache;
+      this.cache = /* @__PURE__ */ new Map();
+    }
+  }
+  _moveToRecent(key, item) {
+    this.oldCache.delete(key);
+    this._set(key, item);
+  }
+  *_entriesAscending() {
+    for (const item of this.oldCache) {
+      const [key, value] = item;
+      if (!this.cache.has(key)) {
+        if (this._deleteIfExpired(key, value) === false) yield item;
+      }
+    }
+    for (const item of this.cache) {
+      const [key, value] = item;
+      if (this._deleteIfExpired(key, value) === false) yield item;
+    }
+  }
+  get(key) {
+    if (this.cache.has(key)) {
+      const item = this.cache.get(key);
+      return this._getItemValue(key, item);
+    }
+    if (this.oldCache.has(key)) {
+      const item = this.oldCache.get(key);
+      if (this._deleteIfExpired(key, item) === false) {
+        this._moveToRecent(key, item);
+        return item.value;
+      }
+    }
+  }
+  set(key, value, { maxAge = this.maxAge } = {}) {
+    const expiry = typeof maxAge === "number" && maxAge !== Number.POSITIVE_INFINITY ? Date.now() + maxAge : void 0;
+    if (this.cache.has(key)) this.cache.set(key, {
+      value,
+      expiry
+    });
+    else this._set(key, {
+      value,
+      expiry
+    });
+    return this;
+  }
+  has(key) {
+    if (this.cache.has(key)) return !this._deleteIfExpired(key, this.cache.get(key));
+    if (this.oldCache.has(key)) return !this._deleteIfExpired(key, this.oldCache.get(key));
+    return false;
+  }
+  peek(key) {
+    if (this.cache.has(key)) return this._peek(key, this.cache);
+    if (this.oldCache.has(key)) return this._peek(key, this.oldCache);
+  }
+  delete(key) {
+    const deleted = this.cache.delete(key);
+    if (deleted) this._size--;
+    return this.oldCache.delete(key) || deleted;
+  }
+  clear() {
+    this.cache.clear();
+    this.oldCache.clear();
+    this._size = 0;
+  }
+  resize(newSize) {
+    if (!(newSize && newSize > 0)) throw new TypeError("`maxSize` must be a number greater than 0");
+    const items = [...this._entriesAscending()];
+    const removeCount = items.length - newSize;
+    if (removeCount < 0) {
+      this.cache = new Map(items);
+      this.oldCache = /* @__PURE__ */ new Map();
+      this._size = items.length;
+    } else {
+      if (removeCount > 0) this._emitEvictions(items.slice(0, removeCount));
+      this.oldCache = new Map(items.slice(removeCount));
+      this.cache = /* @__PURE__ */ new Map();
+      this._size = 0;
+    }
+    this.maxSize = newSize;
+  }
+  *keys() {
+    for (const [key] of this) yield key;
+  }
+  *values() {
+    for (const [, value] of this) yield value;
+  }
+  *[Symbol.iterator]() {
+    for (const item of this.cache) {
+      const [key, value] = item;
+      if (this._deleteIfExpired(key, value) === false) yield [key, value.value];
+    }
+    for (const item of this.oldCache) {
+      const [key, value] = item;
+      if (!this.cache.has(key)) {
+        if (this._deleteIfExpired(key, value) === false) yield [key, value.value];
+      }
+    }
+  }
+  *entriesDescending() {
+    let items = [...this.cache];
+    for (let i = items.length - 1; i >= 0; --i) {
+      const [key, value] = items[i];
+      if (this._deleteIfExpired(key, value) === false) yield [key, value.value];
+    }
+    items = [...this.oldCache];
+    for (let i = items.length - 1; i >= 0; --i) {
+      const [key, value] = items[i];
+      if (!this.cache.has(key)) {
+        if (this._deleteIfExpired(key, value) === false) yield [key, value.value];
+      }
+    }
+  }
+  *entriesAscending() {
+    for (const [key, value] of this._entriesAscending()) yield [key, value.value];
+  }
+  get size() {
+    if (!this._size) return this.oldCache.size;
+    let oldCacheSize = 0;
+    for (const key of this.oldCache.keys()) if (!this.cache.has(key)) oldCacheSize++;
+    return Math.min(this._size + oldCacheSize, this.maxSize);
+  }
+  entries() {
+    return this.entriesAscending();
+  }
+  forEach(callbackFunction, thisArgument = this) {
+    for (const [key, value] of this.entriesAscending()) callbackFunction.call(thisArgument, value, key, this);
+  }
+  get [Symbol.toStringTag]() {
+    return JSON.stringify([...this.entriesAscending()]);
+  }
+};
+var handlePreserveConsecutiveUppercase = (decamelized, separator) => {
+  decamelized = decamelized.replace(/((?<![\p{Uppercase_Letter}\d])[\p{Uppercase_Letter}\d](?![\p{Uppercase_Letter}\d]))/gu, ($0) => $0.toLowerCase());
+  return decamelized.replace(new RegExp("(?<!\\p{Uppercase_Letter})(\\p{Uppercase_Letter}+)(\\p{Uppercase_Letter}\\p{Lowercase_Letter}+)", "gu"), (_, $1, $2) => $1 + separator + $2.toLowerCase());
+};
+function decamelize(text, { separator = "_", preserveConsecutiveUppercase: preserveConsecutiveUppercase$1 = false } = {}) {
+  if (!(typeof text === "string" && typeof separator === "string")) throw new TypeError("The `text` and `separator` arguments should be of type `string`");
+  if (text.length < 2) return preserveConsecutiveUppercase$1 ? text : text.toLowerCase();
+  const replacement = `$1${separator}$2`;
+  const decamelized = text.replace(new RegExp("([\\p{Lowercase_Letter}\\d])(\\p{Uppercase_Letter})", "gu"), replacement);
+  if (preserveConsecutiveUppercase$1) return handlePreserveConsecutiveUppercase(decamelized, separator);
+  return decamelized.replace(new RegExp("(\\p{Uppercase_Letter})(\\p{Uppercase_Letter}\\p{Lowercase_Letter}+)", "gu"), replacement).toLowerCase();
+}
+var has$1 = (array, key) => array.some((element) => {
+  if (typeof element === "string") return element === key;
+  element.lastIndex = 0;
+  return element.test(key);
+});
+var cache$1 = new QuickLRU({ maxSize: 1e5 });
+var isObject$2 = (value) => typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
+var transform$1 = (input, options = {}) => {
+  if (!isObject$2(input)) return input;
+  const { separator = "_", exclude, deep = false } = options;
+  const makeMapper = (parentPath) => (key, value) => {
+    if (deep && isObject$2(value)) {
+      const path = parentPath === void 0 ? key : `${parentPath}.${key}`;
+      value = (0, import_map_obj.default)(value, makeMapper(path));
+    }
+    if (!(exclude && has$1(exclude, key))) {
+      const cacheKey = `${separator}${key}`;
+      if (cache$1.has(cacheKey)) key = cache$1.get(cacheKey);
+      else {
+        const returnValue = decamelize(key, { separator });
+        if (key.length < 100) cache$1.set(cacheKey, returnValue);
+        key = returnValue;
+      }
+    }
+    return [key, value];
+  };
+  return (0, import_map_obj.default)(input, makeMapper(void 0));
+};
+function decamelizeKeys$1(input, options) {
+  if (Array.isArray(input)) return Object.keys(input).map((key) => transform$1(input[key], options));
+  return transform$1(input, options);
+}
+function decamelizeKeys(val) {
+  return decamelizeKeys$1(val, { deep: true });
+}
+function toUrlSafe(str) {
+  let safeStr = str;
+  while (safeStr.indexOf("/") >= 0) safeStr = safeStr.replace("/", "_");
+  while (safeStr.indexOf("+") >= 0) safeStr = safeStr.replace("+", "-");
+  while (safeStr.indexOf("=") >= 0) safeStr = safeStr.replace("=", "");
+  return safeStr;
+}
+function normalizeRequest(path, options) {
+  const pathWithParams = path.replace(/{([a-zA-Z0-9_]+)}/g, (_, key) => {
+    const value = options?.query?.[key];
+    if (!value) throw new Error(`Missing value for path parameter "${key}"`);
+    delete options?.query?.[key];
+    return toUrlSafe(value);
+  });
+  if (options?.query) {
+    for (const key in options.query) {
+      const value = options.query[key];
+      if (typeof value === "string") options.query[key] = toUrlSafe(value);
+    }
+    options.query = decamelizeKeys(options.query);
+  }
+  if (options?.body && typeof options.body === "object") options.body = decamelizeKeys(options.body);
+  return [pathWithParams, options];
+}
+var isObject$1 = (value) => typeof value === "object" && value !== null;
+var isObjectCustom = (value) => isObject$1(value) && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
+var mapObjectSkip = /* @__PURE__ */ Symbol("mapObjectSkip");
+var _mapObject = (object, mapper, options, isSeen = /* @__PURE__ */ new WeakMap()) => {
+  options = {
+    deep: false,
+    target: {},
+    ...options
+  };
+  if (isSeen.has(object)) return isSeen.get(object);
+  isSeen.set(object, options.target);
+  const { target } = options;
+  delete options.target;
+  const mapArray = (array) => array.map((element) => isObjectCustom(element) ? _mapObject(element, mapper, options, isSeen) : element);
+  if (Array.isArray(object)) return mapArray(object);
+  for (const [key, value] of Object.entries(object)) {
+    const mapResult = mapper(key, value, object);
+    if (mapResult === mapObjectSkip) continue;
+    let [newKey, newValue, { shouldRecurse = true } = {}] = mapResult;
+    if (newKey === "__proto__") continue;
+    if (options.deep && shouldRecurse && isObjectCustom(newValue)) newValue = Array.isArray(newValue) ? mapArray(newValue) : _mapObject(newValue, mapper, options, isSeen);
+    target[newKey] = newValue;
+  }
+  return target;
+};
+function mapObject(object, mapper, options) {
+  if (!isObject$1(object)) throw new TypeError(`Expected an object, got \`${object}\` (${typeof object})`);
+  return _mapObject(object, mapper, options);
+}
+var UPPERCASE = /[\p{Lu}]/u;
+var LOWERCASE = /[\p{Ll}]/u;
+var LEADING_CAPITAL = /^[\p{Lu}](?![\p{Lu}])/gu;
+var IDENTIFIER = /([\p{Alpha}\p{N}_]|$)/u;
+var SEPARATORS = /[_.\- ]+/;
+var LEADING_SEPARATORS = /* @__PURE__ */ new RegExp("^" + SEPARATORS.source);
+var SEPARATORS_AND_IDENTIFIER = new RegExp(SEPARATORS.source + IDENTIFIER.source, "gu");
+var NUMBERS_AND_IDENTIFIER = new RegExp("\\d+" + IDENTIFIER.source, "gu");
+var preserveCamelCase = (string, toLowerCase, toUpperCase, preserveConsecutiveUppercase$1) => {
+  let isLastCharLower = false;
+  let isLastCharUpper = false;
+  let isLastLastCharUpper = false;
+  let isLastLastCharPreserved = false;
+  for (let index = 0; index < string.length; index++) {
+    const character = string[index];
+    isLastLastCharPreserved = index > 2 ? string[index - 3] === "-" : true;
+    if (isLastCharLower && UPPERCASE.test(character)) {
+      string = string.slice(0, index) + "-" + string.slice(index);
+      isLastCharLower = false;
+      isLastLastCharUpper = isLastCharUpper;
+      isLastCharUpper = true;
+      index++;
+    } else if (isLastCharUpper && isLastLastCharUpper && LOWERCASE.test(character) && (!isLastLastCharPreserved || preserveConsecutiveUppercase$1)) {
+      string = string.slice(0, index - 1) + "-" + string.slice(index - 1);
+      isLastLastCharUpper = isLastCharUpper;
+      isLastCharUpper = false;
+      isLastCharLower = true;
+    } else {
+      isLastCharLower = toLowerCase(character) === character && toUpperCase(character) !== character;
+      isLastLastCharUpper = isLastCharUpper;
+      isLastCharUpper = toUpperCase(character) === character && toLowerCase(character) !== character;
+    }
+  }
+  return string;
+};
+var preserveConsecutiveUppercase = (input, toLowerCase) => {
+  LEADING_CAPITAL.lastIndex = 0;
+  return input.replaceAll(LEADING_CAPITAL, (match) => toLowerCase(match));
+};
+var postProcess = (input, toUpperCase) => {
+  SEPARATORS_AND_IDENTIFIER.lastIndex = 0;
+  NUMBERS_AND_IDENTIFIER.lastIndex = 0;
+  return input.replaceAll(NUMBERS_AND_IDENTIFIER, (match, pattern, offset) => ["_", "-"].includes(input.charAt(offset + match.length)) ? match : toUpperCase(match)).replaceAll(SEPARATORS_AND_IDENTIFIER, (_, identifier) => toUpperCase(identifier));
+};
+function camelCase(input, options) {
+  if (!(typeof input === "string" || Array.isArray(input))) throw new TypeError("Expected the input to be `string | string[]`");
+  options = {
+    pascalCase: false,
+    preserveConsecutiveUppercase: false,
+    ...options
+  };
+  if (Array.isArray(input)) input = input.map((x) => x.trim()).filter((x) => x.length).join("-");
+  else input = input.trim();
+  if (input.length === 0) return "";
+  const toLowerCase = options.locale === false ? (string) => string.toLowerCase() : (string) => string.toLocaleLowerCase(options.locale);
+  const toUpperCase = options.locale === false ? (string) => string.toUpperCase() : (string) => string.toLocaleUpperCase(options.locale);
+  if (input.length === 1) {
+    if (SEPARATORS.test(input)) return "";
+    return options.pascalCase ? toUpperCase(input) : toLowerCase(input);
+  }
+  if (input !== toLowerCase(input)) input = preserveCamelCase(input, toLowerCase, toUpperCase, options.preserveConsecutiveUppercase);
+  input = input.replace(LEADING_SEPARATORS, "");
+  input = options.preserveConsecutiveUppercase ? preserveConsecutiveUppercase(input, toLowerCase) : toLowerCase(input);
+  if (options.pascalCase) input = toUpperCase(input.charAt(0)) + input.slice(1);
+  return postProcess(input, toUpperCase);
+}
+var has = (array, key) => array.some((element) => {
+  if (typeof element === "string") return element === key;
+  element.lastIndex = 0;
+  return element.test(key);
+});
+var cache = new QuickLRU({ maxSize: 1e5 });
+var isObject = (value) => typeof value === "object" && value !== null && !(value instanceof RegExp) && !(value instanceof Error) && !(value instanceof Date);
+var transform = (input, options = {}) => {
+  if (!isObject(input)) return input;
+  const { exclude, pascalCase = false, stopPaths, deep = false, preserveConsecutiveUppercase: preserveConsecutiveUppercase$1 = false } = options;
+  const stopPathsSet = new Set(stopPaths);
+  const makeMapper = (parentPath) => (key, value) => {
+    if (deep && isObject(value)) {
+      const path = parentPath === void 0 ? key : `${parentPath}.${key}`;
+      if (!stopPathsSet.has(path)) value = mapObject(value, makeMapper(path));
+    }
+    if (!(exclude && has(exclude, key))) {
+      const cacheKey = pascalCase ? `${key}_` : key;
+      if (cache.has(cacheKey)) key = cache.get(cacheKey);
+      else {
+        const returnValue = camelCase(key, {
+          pascalCase,
+          locale: false,
+          preserveConsecutiveUppercase: preserveConsecutiveUppercase$1
+        });
+        if (key.length < 100) cache.set(cacheKey, returnValue);
+        key = returnValue;
+      }
+    }
+    return [key, value];
+  };
+  return mapObject(input, makeMapper(void 0));
+};
+function camelcaseKeys$1(input, options) {
+  if (Array.isArray(input)) return Object.keys(input).map((key) => transform(input[key], options));
+  return transform(input, options);
+}
+function camelcaseKeys(val) {
+  return camelcaseKeys$1(val, { deep: true });
+}
+function denullifyValues(obj) {
+  const newObj = {};
+  for (const k in obj) {
+    const v = obj[k];
+    newObj[k] = v === null ? void 0 : v && typeof v === "object" && v.__proto__.constructor === Object ? denullifyValues(v) : v;
+  }
+  return newObj;
+}
+function normalizeResponse(response) {
+  return denullifyValues(camelcaseKeys(response));
+}
+var StonApiClient = class {
+  constructor(options) {
+    this.apiFetch = ofetch.create({ baseURL: options?.baseURL ?? options?.baseUrl ?? "https://api.ston.fi" });
+  }
+  async getAsset(assetAddress) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/assets/{assetAddress}", {
+      method: "GET",
+      query: { assetAddress }
+    }))).asset;
+  }
+  async getAssets() {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/assets", { method: "GET" }))).assetList;
+  }
+  async queryAssets(body) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/assets/query", {
+      method: "POST",
+      body
+    }))).assetList;
+  }
+  /**
+  * @deprecated use `queryAssets` method with `searchTerms` parameter instead
+  */
+  async searchAssets(query) {
+    return this.queryAssets({
+      ...query,
+      searchTerms: [query.searchString]
+    });
+  }
+  async getFarm(farmAddress) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/farms/{farmAddress}", {
+      method: "GET",
+      query: { farmAddress }
+    }))).farm;
+  }
+  async getFarms(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/farms", {
+      method: "GET",
+      query
+    }))).farmList;
+  }
+  async getFarmsByPool(poolAddress) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/farms_by_pool/{poolAddress}", {
+      method: "GET",
+      query: { poolAddress }
+    }))).farmList;
+  }
+  async getSwapPairs(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/markets", {
+      method: "GET",
+      query
+    }))).pairs;
+  }
+  async getSwapStatus(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/swap/status", {
+      method: "GET",
+      query
+    })));
+  }
+  async getPool(data) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/pools/{poolAddress}", {
+      method: "GET",
+      query: typeof data === "string" ? { poolAddress: data } : data
+    }))).pool;
+  }
+  async getPools(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/pools", {
+      method: "GET",
+      query
+    }))).poolList;
+  }
+  async getPoolsByAssetPair(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/pools/by_market/{asset0Address}/{asset1Address}", {
+      method: "GET",
+      query
+    }))).poolList;
+  }
+  async queryPools({ searchTerms: searchTerm, unconditionalAssets: unconditionalAsset, ...query }) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/pools/query", {
+      method: "POST",
+      query: {
+        ...query,
+        searchTerm,
+        unconditionalAsset
+      }
+    }))).poolList;
+  }
+  async queryTransactions(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/transactions/query", {
+      method: "GET",
+      query: {
+        ...query,
+        minTxTimestamp: query.minTxTimestamp ? normalizeDate(query.minTxTimestamp) : void 0
+      }
+    })));
+  }
+  async simulateSwap({ offerUnits: units, ...query }) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/swap/simulate", {
+      method: "POST",
+      query: {
+        ...query,
+        units
+      }
+    })));
+  }
+  async simulateReverseSwap({ askUnits: units, ...query }) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/reverse_swap/simulate", {
+      method: "POST",
+      query: {
+        ...query,
+        units
+      }
+    })));
+  }
+  async simulateLiquidityProvision(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/liquidity_provision/simulate", {
+      method: "POST",
+      query
+    })));
+  }
+  async getJettonWalletAddress(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/jetton/{jettonAddress}/address", {
+      method: "GET",
+      query
+    }))).address;
+  }
+  async getWalletAsset(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/assets/{assetAddress}", {
+      method: "GET",
+      query
+    }))).asset;
+  }
+  async getWalletAssets(walletAddress) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/assets", {
+      method: "GET",
+      query: { walletAddress }
+    }))).assetList;
+  }
+  async getWalletFarm(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/farms/{farmAddress}", {
+      method: "GET",
+      query
+    }))).farm;
+  }
+  async getWalletFarms(data) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/farms", {
+      method: "GET",
+      query: typeof data === "string" ? { walletAddress: data } : data
+    }))).farmList;
+  }
+  async getWalletPool(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/pools/{poolAddress}", {
+      method: "GET",
+      query
+    }))).pool;
+  }
+  async getWalletPools(data) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/pools", {
+      method: "GET",
+      query: typeof data === "string" ? { walletAddress: data } : data
+    }))).poolList;
+  }
+  async getWalletStakes(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/stakes", {
+      method: "GET",
+      query
+    })));
+  }
+  async getWalletVaultsFee(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/fee_vaults", {
+      method: "GET",
+      query
+    }))).vaultList;
+  }
+  async getWalletOperations({ since, until, ...query }) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/wallets/{walletAddress}/operations", {
+      method: "GET",
+      query: {
+        ...query,
+        since: normalizeDate(since),
+        until: normalizeDate(until)
+      }
+    }))).operations;
+  }
+  async getOperations({ since, until }) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/stats/operations", {
+      method: "GET",
+      query: {
+        since: normalizeDate(since),
+        until: normalizeDate(until)
+      }
+    }))).operations;
+  }
+  async getAssetsFeeStats({ since, until, referrerAddress }) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/stats/fees", {
+      method: "GET",
+      query: {
+        since: normalizeDate(since),
+        until: normalizeDate(until),
+        referrerAddress
+      }
+    })));
+  }
+  async getWithdrawalsFeeStats({ since, until, referrerAddress }) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/stats/fee_withdrawals", {
+      method: "GET",
+      query: {
+        since: normalizeDate(since),
+        until: normalizeDate(until),
+        referrerAddress
+      }
+    }))).withdrawals;
+  }
+  async getAccrualsFeeStats({ since, until, referrerAddress }) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/stats/fee_accruals", {
+      method: "GET",
+      query: {
+        since: normalizeDate(since),
+        until: normalizeDate(until),
+        referrerAddress
+      }
+    }))).operations;
+  }
+  async getStakingStats() {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/stats/staking", { method: "GET" })));
+  }
+  async getRouters(query) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/routers", {
+      method: "GET",
+      query
+    }))).routerList;
+  }
+  async getRouter(routerAddress) {
+    return normalizeResponse(await this.apiFetch(...normalizeRequest("/v1/routers/{routerAddress}", {
+      method: "GET",
+      query: { routerAddress }
+    }))).router;
+  }
+};
+
+// src/agent/tools/jetton/swap.ts
 var NATIVE_TON_ADDRESS = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 var jettonSwapTool = {
   name: "jetton_swap",
@@ -12608,7 +13298,6 @@ var jettonSearchExecutor = async (params, context) => {
 // src/agent/tools/jetton/quote.ts
 import { Type as Type86 } from "@sinclair/typebox";
 import { toNano as toNano8 } from "@ton/ton";
-import { StonApiClient as StonApiClient2 } from "@ston-fi/api";
 var NATIVE_TON_ADDRESS2 = "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c";
 var jettonQuoteTool = {
   name: "jetton_quote",
@@ -12639,7 +13328,7 @@ var jettonQuoteExecutor = async (params, context) => {
     const isTonInput = from_asset.toLowerCase() === "ton";
     const fromAddress = isTonInput ? NATIVE_TON_ADDRESS2 : from_asset;
     const toAddress = to_asset;
-    const stonApiClient = new StonApiClient2();
+    const stonApiClient = new StonApiClient();
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
       askAddress: toAddress,
@@ -13581,7 +14270,6 @@ import { Type as Type94 } from "@sinclair/typebox";
 import { TonClient as TonClient13, toNano as toNano11, fromNano as fromNano6 } from "@ton/ton";
 import { Address as Address11 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint13 } from "@orbs-network/ton-access";
-import { StonApiClient as StonApiClient3 } from "@ston-fi/api";
 import { Factory as Factory3, Asset as Asset3, PoolType as PoolType3, ReadinessStatus as ReadinessStatus3 } from "@dedust/sdk";
 var dexQuoteTool = {
   name: "dex_quote",
@@ -13612,7 +14300,7 @@ async function getStonfiQuote(fromAsset, toAsset, amount, slippage) {
     const isTonOutput = toAsset.toLowerCase() === "ton";
     const fromAddress = isTonInput ? NATIVE_TON_ADDRESS3 : fromAsset;
     const toAddress = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
-    const stonApiClient = new StonApiClient3();
+    const stonApiClient = new StonApiClient();
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
       askAddress: toAddress,
@@ -13841,7 +14529,6 @@ import { mnemonicToPrivateKey as mnemonicToPrivateKey10 } from "@ton/crypto";
 import { WalletContractV5R1 as WalletContractV5R110, TonClient as TonClient14, toNano as toNano12, fromNano as fromNano7 } from "@ton/ton";
 import { Address as Address12, SendMode as SendMode8, internal as internal8 } from "@ton/core";
 import { getHttpEndpoint as getHttpEndpoint14 } from "@orbs-network/ton-access";
-import { StonApiClient as StonApiClient4 } from "@ston-fi/api";
 import { DEX as DEX2, pTON as pTON2 } from "@ston-fi/sdk";
 import { Factory as Factory4, Asset as Asset4, PoolType as PoolType4, ReadinessStatus as ReadinessStatus4, JettonRoot as JettonRoot2, VaultJetton as VaultJetton2 } from "@dedust/sdk";
 var dexSwapTool = {
@@ -13878,7 +14565,7 @@ async function getStonfiQuote2(fromAsset, toAsset, amount, slippage) {
     const isTonOutput = toAsset.toLowerCase() === "ton";
     const fromAddress = isTonInput ? NATIVE_TON_ADDRESS3 : fromAsset;
     const toAddress = isTonOutput ? NATIVE_TON_ADDRESS3 : toAsset;
-    const stonApiClient = new StonApiClient4();
+    const stonApiClient = new StonApiClient();
     const simulationResult = await stonApiClient.simulateSwap({
       offerAddress: fromAddress,
       askAddress: toAddress,

package/dist/cli/index.js

@@ -17,7 +17,7 @@ import {
   saveWallet,
   validateApiKeyFormat,
   walletExists
-} from "../chunk-TQBJNXWV.js";
+} from "../chunk-7AUS3OYB.js";
 import "../chunk-B2PRMXOH.js";
 import {
   fetchWithTimeout

package/dist/index.js

@@ -1,7 +1,7 @@
 import {
   TonnetApp,
   main
-} from "./chunk-TQBJNXWV.js";
+} from "./chunk-7AUS3OYB.js";
 import "./chunk-B2PRMXOH.js";
 import "./chunk-PMX75DTX.js";
 import "./chunk-E2NXSWOS.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "teleton",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Personal AI Agent for Telegram",
   "author": "ZKProof (https://t.me/zkproof)",
   "license": "MIT",
@@ -82,7 +82,6 @@
     "typescript": "^5.7.0"
   },
   "optionalDependencies": {
-    "@ston-fi/api": "^0.30.0",
     "edge-tts": "^1.0.1"
   },
   "engines": {