@crypticdot/defituna-api 1.10.16 → 3.0.0

package/dist/index.cjs

@@ -0,0 +1,1718 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  LeaderboardPeriod: () => LeaderboardPeriod,
+  LeaderboardSortBy: () => LeaderboardSortBy,
+  LimitOrderStatus: () => LimitOrderStatus,
+  LpPositionsHistoryQueryFilter: () => LpPositionsHistoryQueryFilter,
+  NotificationAction: () => NotificationAction,
+  NotificationEntity: () => NotificationEntity,
+  OrderHistoryStatus: () => OrderHistoryStatus,
+  OrderHistoryType: () => OrderHistoryType,
+  OrderHistoryUIDirection: () => OrderHistoryUIDirection,
+  PoolProvider: () => PoolProvider,
+  PoolSubscriptionTopic: () => PoolSubscriptionTopic,
+  StakingPositionActionType: () => StakingPositionActionType,
+  TradeHistoryAction: () => TradeHistoryAction,
+  TradeHistoryUIDirection: () => TradeHistoryUIDirection,
+  TunaLpPositionAutoCompound: () => TunaLpPositionAutoCompound,
+  TunaLpPositionAutoCompounding: () => TunaLpPositionAutoCompounding,
+  TunaLpPositionLimitOrderSwap: () => TunaLpPositionLimitOrderSwap,
+  TunaLpPositionRebalance: () => TunaLpPositionRebalance,
+  TunaLpPositionsActionType: () => TunaLpPositionsActionType,
+  TunaPositionDtoState: () => TunaPositionDtoState,
+  TunaPositionMarketMaker: () => TunaPositionMarketMaker,
+  TunaPositionPoolToken: () => TunaPositionPoolToken,
+  TunaSpotPositionDtoState: () => TunaSpotPositionDtoState,
+  WalletSubscriptionTopic: () => WalletSubscriptionTopic,
+  eventIsInitialMessage: () => eventIsInitialMessage,
+  eventIsLendingPosition: () => eventIsLendingPosition,
+  eventIsOrderHistory: () => eventIsOrderHistory,
+  eventIsPoolSwap: () => eventIsPoolSwap,
+  eventIsStakingPosition: () => eventIsStakingPosition,
+  eventIsStateSnapshot: () => eventIsStateSnapshot,
+  eventIsTradeHistory: () => eventIsTradeHistory,
+  getCloseSpotPositionQuote: () => getCloseSpotPositionQuote,
+  getDecreaseSpotPositionQuote: () => getDecreaseSpotPositionQuote,
+  getFeesStats: () => getFeesStats,
+  getFusionFeesStats: () => getFusionFeesStats,
+  getGetCloseSpotPositionQuoteUrl: () => getGetCloseSpotPositionQuoteUrl,
+  getGetDecreaseSpotPositionQuoteUrl: () => getGetDecreaseSpotPositionQuoteUrl,
+  getGetFeesStatsUrl: () => getGetFeesStatsUrl,
+  getGetFusionFeesStatsUrl: () => getGetFusionFeesStatsUrl,
+  getGetIncreaseSpotPositionQuoteUrl: () => getGetIncreaseSpotPositionQuoteUrl,
+  getGetLendingPositionUrl: () => getGetLendingPositionUrl,
+  getGetLendingPositionsUrl: () => getGetLendingPositionsUrl,
+  getGetLimitOrderQuoteByInputUrl: () => getGetLimitOrderQuoteByInputUrl,
+  getGetLimitOrderQuoteByOutputUrl: () => getGetLimitOrderQuoteByOutputUrl,
+  getGetLimitOrderUrl: () => getGetLimitOrderUrl,
+  getGetLimitOrdersUrl: () => getGetLimitOrdersUrl,
+  getGetLpPositionActionsUrl: () => getGetLpPositionActionsUrl,
+  getGetLpPositionsUrl: () => getGetLpPositionsUrl,
+  getGetLpSpotLeaderboardUrl: () => getGetLpSpotLeaderboardUrl,
+  getGetMarketUrl: () => getGetMarketUrl,
+  getGetMarketsUrl: () => getGetMarketsUrl,
+  getGetMintUrl: () => getGetMintUrl,
+  getGetMintsUrl: () => getGetMintsUrl,
+  getGetOraclePriceUrl: () => getGetOraclePriceUrl,
+  getGetOraclePricesUrl: () => getGetOraclePricesUrl,
+  getGetOrderHistoryUrl: () => getGetOrderHistoryUrl,
+  getGetPoolCandlesUrl: () => getGetPoolCandlesUrl,
+  getGetPoolOrderBookUrl: () => getGetPoolOrderBookUrl,
+  getGetPoolSwapsUrl: () => getGetPoolSwapsUrl,
+  getGetPoolTicksUrl: () => getGetPoolTicksUrl,
+  getGetPoolUrl: () => getGetPoolUrl,
+  getGetPoolsUrl: () => getGetPoolsUrl,
+  getGetPositionsStatsUrl: () => getGetPositionsStatsUrl,
+  getGetPositionsTotalUrl: () => getGetPositionsTotalUrl,
+  getGetSpotPositionUrl: () => getGetSpotPositionUrl,
+  getGetSpotPositionsUrl: () => getGetSpotPositionsUrl,
+  getGetStakingLeaderboardUrl: () => getGetStakingLeaderboardUrl,
+  getGetStakingRevenueStatsUrl: () => getGetStakingRevenueStatsUrl,
+  getGetStakingTreasuryUrl: () => getGetStakingTreasuryUrl,
+  getGetSwapQuoteByInputUrl: () => getGetSwapQuoteByInputUrl,
+  getGetSwapQuoteByOutputUrl: () => getGetSwapQuoteByOutputUrl,
+  getGetTradableAmountUrl: () => getGetTradableAmountUrl,
+  getGetTradeHistoryUrl: () => getGetTradeHistoryUrl,
+  getGetTunaPositionUrl: () => getGetTunaPositionUrl,
+  getGetTunaPositionsUrl: () => getGetTunaPositionsUrl,
+  getGetUserStakingPositionHistoryUrl: () => getGetUserStakingPositionHistoryUrl,
+  getGetUserStakingPositionUrl: () => getGetUserStakingPositionUrl,
+  getGetVaultHistoryUrl: () => getGetVaultHistoryUrl,
+  getGetVaultUrl: () => getGetVaultUrl,
+  getGetVaultsUrl: () => getGetVaultsUrl,
+  getIncreaseSpotPositionQuote: () => getIncreaseSpotPositionQuote,
+  getLendingPosition: () => getLendingPosition,
+  getLendingPositions: () => getLendingPositions,
+  getLimitOrder: () => getLimitOrder,
+  getLimitOrderQuoteByInput: () => getLimitOrderQuoteByInput,
+  getLimitOrderQuoteByOutput: () => getLimitOrderQuoteByOutput,
+  getLimitOrders: () => getLimitOrders,
+  getLpPositionActions: () => getLpPositionActions,
+  getLpPositions: () => getLpPositions,
+  getLpSpotLeaderboard: () => getLpSpotLeaderboard,
+  getMarket: () => getMarket,
+  getMarkets: () => getMarkets,
+  getMint: () => getMint,
+  getMints: () => getMints,
+  getOraclePrice: () => getOraclePrice,
+  getOraclePrices: () => getOraclePrices,
+  getOrderHistory: () => getOrderHistory,
+  getPool: () => getPool,
+  getPoolCandles: () => getPoolCandles,
+  getPoolOrderBook: () => getPoolOrderBook,
+  getPoolSwaps: () => getPoolSwaps,
+  getPoolTicks: () => getPoolTicks,
+  getPools: () => getPools,
+  getPositionsStats: () => getPositionsStats,
+  getPositionsTotal: () => getPositionsTotal,
+  getSpotPosition: () => getSpotPosition,
+  getSpotPositions: () => getSpotPositions,
+  getSseUpdatesStream: () => getSseUpdatesStream,
+  getSseUrl: () => getSseUrl,
+  getStakingLeaderboard: () => getStakingLeaderboard,
+  getStakingRevenueStats: () => getStakingRevenueStats,
+  getStakingTreasury: () => getStakingTreasury,
+  getSwapQuoteByInput: () => getSwapQuoteByInput,
+  getSwapQuoteByOutput: () => getSwapQuoteByOutput,
+  getTradableAmount: () => getTradableAmount,
+  getTradeHistory: () => getTradeHistory,
+  getTunaPosition: () => getTunaPosition,
+  getTunaPositions: () => getTunaPositions,
+  getUpdateStreamSubscriptionUrl: () => getUpdateStreamSubscriptionUrl,
+  getUserStakingPosition: () => getUserStakingPosition,
+  getUserStakingPositionHistory: () => getUserStakingPositionHistory,
+  getVault: () => getVault,
+  getVaultHistory: () => getVaultHistory,
+  getVaults: () => getVaults,
+  setTunaBaseUrl: () => setTunaBaseUrl,
+  sse: () => sse,
+  unwrap: () => unwrap,
+  updateStreamSubscription: () => updateStreamSubscription
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/baseUrl.ts
+var baseUrl = "https://api.defituna.com/api";
+function setTunaBaseUrl(url) {
+  baseUrl = url.replace(/\/$/, "");
+}
+function resolveTunaUrl(url, init) {
+  const resolvedBaseUrl = init?.baseUrl?.replace(/\/$/, "") ?? baseUrl;
+  const fullUrl = resolvedBaseUrl && !url.startsWith("http") ? `${resolvedBaseUrl}${url.startsWith("/") ? "" : "/"}${url}` : url;
+  return fullUrl;
+}
+
+// src/customFetch.ts
+var snakeToCamel = (s) => s.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+var camelToSnake = (s) => s.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+var isPlainObject = (v) => !!v && typeof v === "object" && Object.getPrototypeOf(v) === Object.prototype;
+function mapKeysDeep(value, keyMap, onValue) {
+  const patched = onValue ? onValue(value) : value;
+  if (Array.isArray(patched)) {
+    return patched.map((x, _i) => mapKeysDeep(x, keyMap, onValue));
+  }
+  if (isPlainObject(patched)) {
+    const out = {};
+    for (const [k, v] of Object.entries(patched)) {
+      const nk = keyMap(k);
+      out[nk] = mapKeysDeep(v, keyMap, onValue);
+    }
+    return out;
+  }
+  return patched;
+}
+var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?Z$/;
+var INT_STRING_RE = /^-?\d+$/;
+function reviveScalars(v) {
+  if (typeof v !== "string") return v;
+  if (ISO_DATE_RE.test(v)) {
+    const d = new Date(v);
+    if (!Number.isNaN(d.getTime())) return d;
+  }
+  if (INT_STRING_RE.test(v)) {
+    try {
+      return BigInt(v);
+    } catch {
+    }
+  }
+  return v;
+}
+function normalizeResponseJson(raw) {
+  const revived = mapKeysDeep(raw, (k) => k, reviveScalars);
+  return mapKeysDeep(revived, snakeToCamel);
+}
+function normalizeRequestBody(body) {
+  return mapKeysDeep(body, camelToSnake);
+}
+function modifyQuery(url) {
+  const u = new URL(url);
+  const params = u.searchParams;
+  const grouped = /* @__PURE__ */ new Map();
+  for (const [key, value] of params.entries()) {
+    if (!grouped.has(key)) {
+      grouped.set(key, []);
+    }
+    grouped.get(key).push(value);
+  }
+  const newParams = new URLSearchParams();
+  for (const [key, values] of grouped.entries()) {
+    const snakeKey = camelToSnake(key);
+    newParams.set(snakeKey, values.join(","));
+  }
+  u.search = newParams.toString();
+  return u.toString();
+}
+async function customFetch(url, init) {
+  const fullUrl = resolveTunaUrl(url, init);
+  const finalInit = { ...init };
+  if (finalInit.body && typeof finalInit.body === "object" && !(finalInit.body instanceof FormData)) {
+    const snaked = normalizeRequestBody(finalInit.body);
+    finalInit.body = JSON.stringify(snaked);
+    finalInit.headers = {
+      "content-type": "application/json",
+      ...finalInit.headers || {}
+    };
+  }
+  const fullUrlWithQuery = modifyQuery(fullUrl);
+  const res = await fetch(fullUrlWithQuery, finalInit);
+  const text = await res.text();
+  let data = void 0;
+  try {
+    const raw = JSON.parse(text);
+    data = normalizeResponseJson(raw);
+  } catch {
+  }
+  return { status: res.status, data };
+}
+
+// src/gen/defiTunaAPI.ts
+var LeaderboardPeriod = {
+  week: "week"
+};
+var LeaderboardSortBy = {
+  profit: "profit",
+  percent: "percent"
+};
+var LimitOrderStatus = {
+  open: "open",
+  partiallyFilled: "partially_filled",
+  filled: "filled",
+  complete: "complete",
+  cancelled: "cancelled"
+};
+var LpPositionsHistoryQueryFilter = {
+  opened: "opened",
+  closed: "closed",
+  all: "all"
+};
+var NotificationAction = {
+  create: "create",
+  update: "update"
+};
+var NotificationEntity = {
+  initialMessage: "initial_message",
+  poolSwap: "pool_swap",
+  orderBook: "order_book",
+  oraclePrice: "oracle_price",
+  market: "market",
+  tunaPosition: "tuna_position",
+  tunaSpotPosition: "tuna_spot_position",
+  stakingPosition: "staking_position",
+  lendingPosition: "lending_position",
+  fusionLimitOrder: "fusion_limit_order",
+  tradeHistoryEntry: "trade_history_entry",
+  orderHistoryEntry: "order_history_entry",
+  stateSnapshot: "state_snapshot"
+};
+var OrderHistoryStatus = {
+  open: "open",
+  partiallyFilled: "partially_filled",
+  filled: "filled",
+  cancelled: "cancelled",
+  claimed: "claimed",
+  rejected: "rejected"
+};
+var OrderHistoryType = {
+  market: "market",
+  limit: "limit",
+  takeProfitMarket: "take_profit_market",
+  stopLossMarket: "stop_loss_market",
+  liquidationMarket: "liquidation_market"
+};
+var OrderHistoryUIDirection = {
+  buy: "buy",
+  sell: "sell",
+  long: "long",
+  short: "short"
+};
+var PoolProvider = {
+  orca: "orca",
+  fusion: "fusion"
+};
+var PoolSubscriptionTopic = {
+  poolSwaps: "pool_swaps",
+  orderBook: "order_book",
+  poolPrices: "pool_prices"
+};
+var StakingPositionActionType = {
+  stake: "stake",
+  unstake: "unstake",
+  withdraw: "withdraw",
+  claimRewards: "claim_rewards",
+  compoundRewards: "compound_rewards"
+};
+var TradeHistoryAction = {
+  swap: "swap",
+  limitOrderFill: "limit_order_fill",
+  positionIncrease: "position_increase",
+  positionDecrease: "position_decrease",
+  takeProfit: "take_profit",
+  stopLoss: "stop_loss",
+  liquidation: "liquidation"
+};
+var TradeHistoryUIDirection = {
+  buy: "buy",
+  sell: "sell",
+  openLong: "open_long",
+  closeLong: "close_long",
+  openShort: "open_short",
+  closeShort: "close_short"
+};
+var TunaLpPositionAutoCompound = {
+  noAutoCompound: "no_auto_compound",
+  autoCompound: "auto_compound",
+  autoCompoundWithLeverage: "auto_compound_with_leverage"
+};
+var TunaLpPositionAutoCompounding = {
+  withLeverage: "with_leverage",
+  withoutLeverage: "without_leverage"
+};
+var TunaLpPositionLimitOrderSwap = {
+  noSwap: "no_swap",
+  swapToTokenA: "swap_to_token_a",
+  swapToTokenB: "swap_to_token_b"
+};
+var TunaLpPositionRebalance = {
+  noRebalance: "no_rebalance",
+  autoRebalance: "auto_rebalance"
+};
+var TunaLpPositionsActionType = {
+  openPosition: "open_position",
+  closePosition: "close_position",
+  increaseLiquidity: "increase_liquidity",
+  decreaseLiquidity: "decrease_liquidity",
+  repayDebt: "repay_debt",
+  liquidate: "liquidate",
+  executeLimitOrder: "execute_limit_order",
+  collectFees: "collect_fees",
+  collectRewards: "collect_rewards",
+  collectAndCompoundFees: "collect_and_compound_fees",
+  rebalancePosition: "rebalance_position",
+  setLimitOrders: "set_limit_orders",
+  setFlags: "set_flags",
+  setRebalanceThreshold: "set_rebalance_threshold"
+};
+var TunaPositionDtoState = {
+  open: "open",
+  liquidated: "liquidated",
+  closedByLimitOrder: "closed_by_limit_order",
+  closed: "closed"
+};
+var TunaPositionMarketMaker = {
+  fusion: "fusion",
+  orca: "orca"
+};
+var TunaPositionPoolToken = {
+  a: "a",
+  b: "b"
+};
+var TunaSpotPositionDtoState = {
+  open: "open",
+  closed: "closed"
+};
+var WalletSubscriptionTopic = {
+  tunaPositions: "tuna_positions",
+  tunaSpotPositions: "tuna_spot_positions",
+  lendingPositions: "lending_positions",
+  fusionLimitOrders: "fusion_limit_orders",
+  stakingPosition: "staking_position",
+  tradeHistory: "trade_history",
+  orderHistory: "order_history"
+};
+var getGetLpSpotLeaderboardUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/lp-spot-leaderboard?${stringifiedParams}` : `/v1/lp-spot-leaderboard`;
+};
+var getLpSpotLeaderboard = async (params, options) => {
+  return customFetch(
+    getGetLpSpotLeaderboardUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetMarketsUrl = () => {
+  return `/v1/markets`;
+};
+var getMarkets = async (options) => {
+  return customFetch(
+    getGetMarketsUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetMarketUrl = (marketAddress) => {
+  return `/v1/markets/${marketAddress}`;
+};
+var getMarket = async (marketAddress, options) => {
+  return customFetch(
+    getGetMarketUrl(marketAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetMintsUrl = () => {
+  return `/v1/mints`;
+};
+var getMints = async (options) => {
+  return customFetch(
+    getGetMintsUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetMintUrl = (mintAddress) => {
+  return `/v1/mints/${mintAddress}`;
+};
+var getMint = async (mintAddress, options) => {
+  return customFetch(
+    getGetMintUrl(mintAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetOraclePricesUrl = () => {
+  return `/v1/oracle-prices`;
+};
+var getOraclePrices = async (options) => {
+  return customFetch(
+    getGetOraclePricesUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetOraclePriceUrl = (mintAddress) => {
+  return `/v1/oracle-prices/${mintAddress}`;
+};
+var getOraclePrice = async (mintAddress, options) => {
+  return customFetch(
+    getGetOraclePriceUrl(mintAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetPoolsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/pools?${stringifiedParams}` : `/v1/pools`;
+};
+var getPools = async (params, options) => {
+  return customFetch(
+    getGetPoolsUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetPoolUrl = (poolAddress) => {
+  return `/v1/pools/${poolAddress}`;
+};
+var getPool = async (poolAddress, options) => {
+  return customFetch(
+    getGetPoolUrl(poolAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetPoolCandlesUrl = (poolAddress, params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value instanceof Date ? value.toISOString() : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/pools/${poolAddress}/candles?${stringifiedParams}` : `/v1/pools/${poolAddress}/candles`;
+};
+var getPoolCandles = async (poolAddress, params, options) => {
+  return customFetch(
+    getGetPoolCandlesUrl(poolAddress, params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetPoolOrderBookUrl = (poolAddress, params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/pools/${poolAddress}/order-book?${stringifiedParams}` : `/v1/pools/${poolAddress}/order-book`;
+};
+var getPoolOrderBook = async (poolAddress, params, options) => {
+  return customFetch(
+    getGetPoolOrderBookUrl(poolAddress, params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetPoolSwapsUrl = (poolAddress) => {
+  return `/v1/pools/${poolAddress}/swaps`;
+};
+var getPoolSwaps = async (poolAddress, options) => {
+  return customFetch(
+    getGetPoolSwapsUrl(poolAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetPoolTicksUrl = (poolAddress) => {
+  return `/v1/pools/${poolAddress}/ticks`;
+};
+var getPoolTicks = async (poolAddress, options) => {
+  return customFetch(
+    getGetPoolTicksUrl(poolAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetCloseSpotPositionQuoteUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/quotes/close-spot-position?${stringifiedParams}` : `/v1/quotes/close-spot-position`;
+};
+var getCloseSpotPositionQuote = async (params, options) => {
+  return customFetch(
+    getGetCloseSpotPositionQuoteUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetDecreaseSpotPositionQuoteUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/quotes/decrease-spot-position?${stringifiedParams}` : `/v1/quotes/decrease-spot-position`;
+};
+var getDecreaseSpotPositionQuote = async (params, options) => {
+  return customFetch(
+    getGetDecreaseSpotPositionQuoteUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetIncreaseSpotPositionQuoteUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/quotes/increase-spot-position?${stringifiedParams}` : `/v1/quotes/increase-spot-position`;
+};
+var getIncreaseSpotPositionQuote = async (params, options) => {
+  return customFetch(
+    getGetIncreaseSpotPositionQuoteUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetLimitOrderQuoteByInputUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/quotes/limit-order-by-input?${stringifiedParams}` : `/v1/quotes/limit-order-by-input`;
+};
+var getLimitOrderQuoteByInput = async (params, options) => {
+  return customFetch(
+    getGetLimitOrderQuoteByInputUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetLimitOrderQuoteByOutputUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/quotes/limit-order-by-output?${stringifiedParams}` : `/v1/quotes/limit-order-by-output`;
+};
+var getLimitOrderQuoteByOutput = async (params, options) => {
+  return customFetch(
+    getGetLimitOrderQuoteByOutputUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetSwapQuoteByInputUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/quotes/swap-by-input?${stringifiedParams}` : `/v1/quotes/swap-by-input`;
+};
+var getSwapQuoteByInput = async (params, options) => {
+  return customFetch(
+    getGetSwapQuoteByInputUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetSwapQuoteByOutputUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/quotes/swap-by-output?${stringifiedParams}` : `/v1/quotes/swap-by-output`;
+};
+var getSwapQuoteByOutput = async (params, options) => {
+  return customFetch(
+    getGetSwapQuoteByOutputUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetTradableAmountUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/quotes/tradable-amount?${stringifiedParams}` : `/v1/quotes/tradable-amount`;
+};
+var getTradableAmount = async (params, options) => {
+  return customFetch(
+    getGetTradableAmountUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetStakingLeaderboardUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/staking/leaderboard?${stringifiedParams}` : `/v1/staking/leaderboard`;
+};
+var getStakingLeaderboard = async (params, options) => {
+  return customFetch(
+    getGetStakingLeaderboardUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetStakingTreasuryUrl = () => {
+  return `/v1/staking/treasury`;
+};
+var getStakingTreasury = async (options) => {
+  return customFetch(
+    getGetStakingTreasuryUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetFeesStatsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value instanceof Date ? value.toISOString() : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/stats/fees?${stringifiedParams}` : `/v1/stats/fees`;
+};
+var getFeesStats = async (params, options) => {
+  return customFetch(
+    getGetFeesStatsUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetFusionFeesStatsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value instanceof Date ? value.toISOString() : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/stats/fusion-fees?${stringifiedParams}` : `/v1/stats/fusion-fees`;
+};
+var getFusionFeesStats = async (params, options) => {
+  return customFetch(
+    getGetFusionFeesStatsUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetPositionsStatsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value instanceof Date ? value.toISOString() : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/stats/positions?${stringifiedParams}` : `/v1/stats/positions`;
+};
+var getPositionsStats = async (params, options) => {
+  return customFetch(
+    getGetPositionsStatsUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetPositionsTotalUrl = () => {
+  return `/v1/stats/positions/total`;
+};
+var getPositionsTotal = async (options) => {
+  return customFetch(
+    getGetPositionsTotalUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetStakingRevenueStatsUrl = (params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/stats/staking/revenue?${stringifiedParams}` : `/v1/stats/staking/revenue`;
+};
+var getStakingRevenueStats = async (params, options) => {
+  return customFetch(
+    getGetStakingRevenueStatsUrl(params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getSseUrl = () => {
+  return `/v1/streams/sse`;
+};
+var sse = async (options) => {
+  return customFetch(
+    getSseUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getUpdateStreamSubscriptionUrl = (streamId) => {
+  return `/v1/streams/${streamId}/subscription`;
+};
+var updateStreamSubscription = async (streamId, subscriptionOptions, options) => {
+  return customFetch(
+    getUpdateStreamSubscriptionUrl(streamId),
+    {
+      ...options,
+      method: "PUT",
+      headers: { "Content-Type": "application/json", ...options?.headers },
+      body: JSON.stringify(
+        subscriptionOptions
+      )
+    }
+  );
+};
+var getGetLendingPositionsUrl = (userAddress) => {
+  return `/v1/users/${userAddress}/lending-positions`;
+};
+var getLendingPositions = async (userAddress, options) => {
+  return customFetch(
+    getGetLendingPositionsUrl(userAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetLendingPositionUrl = (userAddress, lendingPositionAddress) => {
+  return `/v1/users/${userAddress}/lending-positions/${lendingPositionAddress}`;
+};
+var getLendingPosition = async (userAddress, lendingPositionAddress, options) => {
+  return customFetch(
+    getGetLendingPositionUrl(userAddress, lendingPositionAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetLimitOrdersUrl = (userAddress, params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    const explodeParameters = ["pool", "status"];
+    if (Array.isArray(value) && explodeParameters.includes(key)) {
+      value.forEach((v) => {
+        normalizedParams.append(key, v === null ? "null" : v.toString());
+      });
+      return;
+    }
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/users/${userAddress}/limit-orders?${stringifiedParams}` : `/v1/users/${userAddress}/limit-orders`;
+};
+var getLimitOrders = async (userAddress, params, options) => {
+  return customFetch(
+    getGetLimitOrdersUrl(userAddress, params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetLimitOrderUrl = (userAddress, limitOrderAddress) => {
+  return `/v1/users/${userAddress}/limit-orders/${limitOrderAddress}`;
+};
+var getLimitOrder = async (userAddress, limitOrderAddress, options) => {
+  return customFetch(
+    getGetLimitOrderUrl(userAddress, limitOrderAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetLpPositionsUrl = (userAddress, params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value instanceof Date ? value.toISOString() : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/users/${userAddress}/lp-positions?${stringifiedParams}` : `/v1/users/${userAddress}/lp-positions`;
+};
+var getLpPositions = async (userAddress, params, options) => {
+  return customFetch(
+    getGetLpPositionsUrl(userAddress, params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetLpPositionActionsUrl = (userAddress, positionAddress) => {
+  return `/v1/users/${userAddress}/lp-positions/${positionAddress}/actions`;
+};
+var getLpPositionActions = async (userAddress, positionAddress, options) => {
+  return customFetch(
+    getGetLpPositionActionsUrl(userAddress, positionAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetOrderHistoryUrl = (userAddress, params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    const explodeParameters = ["pool", "orderType", "uiDirection"];
+    if (Array.isArray(value) && explodeParameters.includes(key)) {
+      value.forEach((v) => {
+        normalizedParams.append(key, v === null ? "null" : v.toString());
+      });
+      return;
+    }
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/users/${userAddress}/order-history?${stringifiedParams}` : `/v1/users/${userAddress}/order-history`;
+};
+var getOrderHistory = async (userAddress, params, options) => {
+  return customFetch(
+    getGetOrderHistoryUrl(userAddress, params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetSpotPositionsUrl = (userAddress) => {
+  return `/v1/users/${userAddress}/spot-positions`;
+};
+var getSpotPositions = async (userAddress, options) => {
+  return customFetch(
+    getGetSpotPositionsUrl(userAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetSpotPositionUrl = (userAddress, spotPositionAddress) => {
+  return `/v1/users/${userAddress}/spot-positions/${spotPositionAddress}`;
+};
+var getSpotPosition = async (userAddress, spotPositionAddress, options) => {
+  return customFetch(
+    getGetSpotPositionUrl(userAddress, spotPositionAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetUserStakingPositionUrl = (userAddress) => {
+  return `/v1/users/${userAddress}/staking-position`;
+};
+var getUserStakingPosition = async (userAddress, options) => {
+  return customFetch(
+    getGetUserStakingPositionUrl(userAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetUserStakingPositionHistoryUrl = (userAddress) => {
+  return `/v1/users/${userAddress}/staking-position/history`;
+};
+var getUserStakingPositionHistory = async (userAddress, options) => {
+  return customFetch(
+    getGetUserStakingPositionHistoryUrl(userAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetTradeHistoryUrl = (userAddress, params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    const explodeParameters = ["pool", "action", "uiDirection"];
+    if (Array.isArray(value) && explodeParameters.includes(key)) {
+      value.forEach((v) => {
+        normalizedParams.append(key, v === null ? "null" : v.toString());
+      });
+      return;
+    }
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/users/${userAddress}/trade-history?${stringifiedParams}` : `/v1/users/${userAddress}/trade-history`;
+};
+var getTradeHistory = async (userAddress, params, options) => {
+  return customFetch(
+    getGetTradeHistoryUrl(userAddress, params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetTunaPositionsUrl = (userAddress) => {
+  return `/v1/users/${userAddress}/tuna-positions`;
+};
+var getTunaPositions = async (userAddress, options) => {
+  return customFetch(
+    getGetTunaPositionsUrl(userAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetTunaPositionUrl = (userAddress, positionAddress) => {
+  return `/v1/users/${userAddress}/tuna-positions/${positionAddress}`;
+};
+var getTunaPosition = async (userAddress, positionAddress, options) => {
+  return customFetch(
+    getGetTunaPositionUrl(userAddress, positionAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetVaultsUrl = () => {
+  return `/v1/vaults`;
+};
+var getVaults = async (options) => {
+  return customFetch(
+    getGetVaultsUrl(),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetVaultUrl = (vaultAddress) => {
+  return `/v1/vaults/${vaultAddress}`;
+};
+var getVault = async (vaultAddress, options) => {
+  return customFetch(
+    getGetVaultUrl(vaultAddress),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+var getGetVaultHistoryUrl = (vaultAddress, params) => {
+  const normalizedParams = new URLSearchParams();
+  Object.entries(params || {}).forEach(([key, value]) => {
+    if (value !== void 0) {
+      normalizedParams.append(key, value === null ? "null" : value.toString());
+    }
+  });
+  const stringifiedParams = normalizedParams.toString();
+  return stringifiedParams.length > 0 ? `/v1/vaults/${vaultAddress}/history?${stringifiedParams}` : `/v1/vaults/${vaultAddress}/history`;
+};
+var getVaultHistory = async (vaultAddress, params, options) => {
+  return customFetch(
+    getGetVaultHistoryUrl(vaultAddress, params),
+    {
+      ...options,
+      method: "GET"
+    }
+  );
+};
+
+// src/unwrap.ts
+function unwrapData(data) {
+  if (data && typeof data === "object" && "data" in data && Object.keys(data).length === 1) {
+    return data.data;
+  }
+  return data;
+}
+async function unwrap(promise) {
+  const res = await promise;
+  if (res.status != 200) {
+    throw {
+      status: res.status
+    };
+  }
+  return unwrapData(res.data);
+}
+
+// ../../node_modules/.pnpm/eventsource-parser@3.0.2/node_modules/eventsource-parser/dist/index.js
+var ParseError = class extends Error {
+  constructor(message, options) {
+    super(message), this.name = "ParseError", this.type = options.type, this.field = options.field, this.value = options.value, this.line = options.line;
+  }
+};
+function noop(_arg) {
+}
+function createParser(callbacks) {
+  if (typeof callbacks == "function")
+    throw new TypeError(
+      "`callbacks` must be an object, got a function instead. Did you mean `{onEvent: fn}`?"
+    );
+  const { onEvent = noop, onError = noop, onRetry = noop, onComment } = callbacks;
+  let incompleteLine = "", isFirstChunk = true, id, data = "", eventType = "";
+  function feed(newChunk) {
+    const chunk = isFirstChunk ? newChunk.replace(/^\xEF\xBB\xBF/, "") : newChunk, [complete, incomplete] = splitLines(`${incompleteLine}${chunk}`);
+    for (const line of complete)
+      parseLine(line);
+    incompleteLine = incomplete, isFirstChunk = false;
+  }
+  function parseLine(line) {
+    if (line === "") {
+      dispatchEvent();
+      return;
+    }
+    if (line.startsWith(":")) {
+      onComment && onComment(line.slice(line.startsWith(": ") ? 2 : 1));
+      return;
+    }
+    const fieldSeparatorIndex = line.indexOf(":");
+    if (fieldSeparatorIndex !== -1) {
+      const field = line.slice(0, fieldSeparatorIndex), offset = line[fieldSeparatorIndex + 1] === " " ? 2 : 1, value = line.slice(fieldSeparatorIndex + offset);
+      processField(field, value, line);
+      return;
+    }
+    processField(line, "", line);
+  }
+  function processField(field, value, line) {
+    switch (field) {
+      case "event":
+        eventType = value;
+        break;
+      case "data":
+        data = `${data}${value}
+`;
+        break;
+      case "id":
+        id = value.includes("\0") ? void 0 : value;
+        break;
+      case "retry":
+        /^\d+$/.test(value) ? onRetry(parseInt(value, 10)) : onError(
+          new ParseError(`Invalid \`retry\` value: "${value}"`, {
+            type: "invalid-retry",
+            value,
+            line
+          })
+        );
+        break;
+      default:
+        onError(
+          new ParseError(
+            `Unknown field "${field.length > 20 ? `${field.slice(0, 20)}\u2026` : field}"`,
+            { type: "unknown-field", field, value, line }
+          )
+        );
+        break;
+    }
+  }
+  function dispatchEvent() {
+    data.length > 0 && onEvent({
+      id,
+      event: eventType || void 0,
+      // If the data buffer's last character is a U+000A LINE FEED (LF) character,
+      // then remove the last character from the data buffer.
+      data: data.endsWith(`
+`) ? data.slice(0, -1) : data
+    }), id = void 0, data = "", eventType = "";
+  }
+  function reset(options = {}) {
+    incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = void 0, data = "", eventType = "", incompleteLine = "";
+  }
+  return { feed, reset };
+}
+function splitLines(chunk) {
+  const lines = [];
+  let incompleteLine = "", searchIndex = 0;
+  for (; searchIndex < chunk.length; ) {
+    const crIndex = chunk.indexOf("\r", searchIndex), lfIndex = chunk.indexOf(`
+`, searchIndex);
+    let lineEnd = -1;
+    if (crIndex !== -1 && lfIndex !== -1 ? lineEnd = Math.min(crIndex, lfIndex) : crIndex !== -1 ? lineEnd = crIndex : lfIndex !== -1 && (lineEnd = lfIndex), lineEnd === -1) {
+      incompleteLine = chunk.slice(searchIndex);
+      break;
+    } else {
+      const line = chunk.slice(searchIndex, lineEnd);
+      lines.push(line), searchIndex = lineEnd + 1, chunk[searchIndex - 1] === "\r" && chunk[searchIndex] === `
+` && searchIndex++;
+    }
+  }
+  return [lines, incompleteLine];
+}
+
+// ../../node_modules/.pnpm/eventsource@3.0.7/node_modules/eventsource/dist/index.js
+var ErrorEvent = class extends Event {
+  /**
+   * Constructs a new `ErrorEvent` instance. This is typically not called directly,
+   * but rather emitted by the `EventSource` object when an error occurs.
+   *
+   * @param type - The type of the event (should be "error")
+   * @param errorEventInitDict - Optional properties to include in the error event
+   */
+  constructor(type, errorEventInitDict) {
+    var _a, _b;
+    super(type), this.code = (_a = errorEventInitDict == null ? void 0 : errorEventInitDict.code) != null ? _a : void 0, this.message = (_b = errorEventInitDict == null ? void 0 : errorEventInitDict.message) != null ? _b : void 0;
+  }
+  /**
+   * Node.js "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Node.js when you `console.log` an instance of this class.
+   *
+   * @param _depth - The current depth
+   * @param options - The options passed to `util.inspect`
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @returns A string representation of the error
+   */
+  [Symbol.for("nodejs.util.inspect.custom")](_depth, options, inspect) {
+    return inspect(inspectableError(this), options);
+  }
+  /**
+   * Deno "hides" the `message` and `code` properties of the `ErrorEvent` instance,
+   * when it is `console.log`'ed. This makes it harder to debug errors. To ease debugging,
+   * we explicitly include the properties in the `inspect` method.
+   *
+   * This is automatically called by Deno when you `console.log` an instance of this class.
+   *
+   * @param inspect - The inspect function to use (prevents having to import it from `util`)
+   * @param options - The options passed to `Deno.inspect`
+   * @returns A string representation of the error
+   */
+  [Symbol.for("Deno.customInspect")](inspect, options) {
+    return inspect(inspectableError(this), options);
+  }
+};
+function syntaxError(message) {
+  const DomException = globalThis.DOMException;
+  return typeof DomException == "function" ? new DomException(message, "SyntaxError") : new SyntaxError(message);
+}
+function flattenError(err) {
+  return err instanceof Error ? "errors" in err && Array.isArray(err.errors) ? err.errors.map(flattenError).join(", ") : "cause" in err && err.cause instanceof Error ? `${err}: ${flattenError(err.cause)}` : err.message : `${err}`;
+}
+function inspectableError(err) {
+  return {
+    type: err.type,
+    message: err.message,
+    code: err.code,
+    defaultPrevented: err.defaultPrevented,
+    cancelable: err.cancelable,
+    timeStamp: err.timeStamp
+  };
+}
+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);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _readyState;
+var _url;
+var _redirectUrl;
+var _withCredentials;
+var _fetch;
+var _reconnectInterval;
+var _reconnectTimer;
+var _lastEventId;
+var _controller;
+var _parser;
+var _onError;
+var _onMessage;
+var _onOpen;
+var _EventSource_instances;
+var connect_fn;
+var _onFetchResponse;
+var _onFetchError;
+var getRequestOptions_fn;
+var _onEvent;
+var _onRetryChange;
+var failConnection_fn;
+var scheduleReconnect_fn;
+var _reconnect;
+var EventSource = class extends EventTarget {
+  constructor(url, eventSourceInitDict) {
+    var _a, _b;
+    super(), __privateAdd(this, _EventSource_instances), this.CONNECTING = 0, this.OPEN = 1, this.CLOSED = 2, __privateAdd(this, _readyState), __privateAdd(this, _url), __privateAdd(this, _redirectUrl), __privateAdd(this, _withCredentials), __privateAdd(this, _fetch), __privateAdd(this, _reconnectInterval), __privateAdd(this, _reconnectTimer), __privateAdd(this, _lastEventId, null), __privateAdd(this, _controller), __privateAdd(this, _parser), __privateAdd(this, _onError, null), __privateAdd(this, _onMessage, null), __privateAdd(this, _onOpen, null), __privateAdd(this, _onFetchResponse, async (response) => {
+      var _a2;
+      __privateGet(this, _parser).reset();
+      const { body, redirected, status, headers } = response;
+      if (status === 204) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Server sent HTTP 204, not reconnecting", 204), this.close();
+        return;
+      }
+      if (redirected ? __privateSet(this, _redirectUrl, new URL(response.url)) : __privateSet(this, _redirectUrl, void 0), status !== 200) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, `Non-200 status code (${status})`, status);
+        return;
+      }
+      if (!(headers.get("content-type") || "").startsWith("text/event-stream")) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, 'Invalid content type, expected "text/event-stream"', status);
+        return;
+      }
+      if (__privateGet(this, _readyState) === this.CLOSED)
+        return;
+      __privateSet(this, _readyState, this.OPEN);
+      const openEvent = new Event("open");
+      if ((_a2 = __privateGet(this, _onOpen)) == null || _a2.call(this, openEvent), this.dispatchEvent(openEvent), typeof body != "object" || !body || !("getReader" in body)) {
+        __privateMethod(this, _EventSource_instances, failConnection_fn).call(this, "Invalid response body, expected a web ReadableStream", status), this.close();
+        return;
+      }
+      const decoder = new TextDecoder(), reader = body.getReader();
+      let open = true;
+      do {
+        const { done, value } = await reader.read();
+        value && __privateGet(this, _parser).feed(decoder.decode(value, { stream: !done })), done && (open = false, __privateGet(this, _parser).reset(), __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this));
+      } while (open);
+    }), __privateAdd(this, _onFetchError, (err) => {
+      __privateSet(this, _controller, void 0), !(err.name === "AbortError" || err.type === "aborted") && __privateMethod(this, _EventSource_instances, scheduleReconnect_fn).call(this, flattenError(err));
+    }), __privateAdd(this, _onEvent, (event) => {
+      typeof event.id == "string" && __privateSet(this, _lastEventId, event.id);
+      const messageEvent = new MessageEvent(event.event || "message", {
+        data: event.data,
+        origin: __privateGet(this, _redirectUrl) ? __privateGet(this, _redirectUrl).origin : __privateGet(this, _url).origin,
+        lastEventId: event.id || ""
+      });
+      __privateGet(this, _onMessage) && (!event.event || event.event === "message") && __privateGet(this, _onMessage).call(this, messageEvent), this.dispatchEvent(messageEvent);
+    }), __privateAdd(this, _onRetryChange, (value) => {
+      __privateSet(this, _reconnectInterval, value);
+    }), __privateAdd(this, _reconnect, () => {
+      __privateSet(this, _reconnectTimer, void 0), __privateGet(this, _readyState) === this.CONNECTING && __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+    });
+    try {
+      if (url instanceof URL)
+        __privateSet(this, _url, url);
+      else if (typeof url == "string")
+        __privateSet(this, _url, new URL(url, getBaseURL()));
+      else
+        throw new Error("Invalid URL");
+    } catch {
+      throw syntaxError("An invalid or illegal string was specified");
+    }
+    __privateSet(this, _parser, createParser({
+      onEvent: __privateGet(this, _onEvent),
+      onRetry: __privateGet(this, _onRetryChange)
+    })), __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _reconnectInterval, 3e3), __privateSet(this, _fetch, (_a = eventSourceInitDict == null ? void 0 : eventSourceInitDict.fetch) != null ? _a : globalThis.fetch), __privateSet(this, _withCredentials, (_b = eventSourceInitDict == null ? void 0 : eventSourceInitDict.withCredentials) != null ? _b : false), __privateMethod(this, _EventSource_instances, connect_fn).call(this);
+  }
+  /**
+   * Returns the state of this EventSource object's connection. It can have the values described below.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/readyState)
+   *
+   * Note: typed as `number` instead of `0 | 1 | 2` for compatibility with the `EventSource` interface,
+   * defined in the TypeScript `dom` library.
+   *
+   * @public
+   */
+  get readyState() {
+    return __privateGet(this, _readyState);
+  }
+  /**
+   * Returns the URL providing the event stream.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/url)
+   *
+   * @public
+   */
+  get url() {
+    return __privateGet(this, _url).href;
+  }
+  /**
+   * Returns true if the credentials mode for connection requests to the URL providing the event stream is set to "include", and false otherwise.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/withCredentials)
+   */
+  get withCredentials() {
+    return __privateGet(this, _withCredentials);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */
+  get onerror() {
+    return __privateGet(this, _onError);
+  }
+  set onerror(value) {
+    __privateSet(this, _onError, value);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */
+  get onmessage() {
+    return __privateGet(this, _onMessage);
+  }
+  set onmessage(value) {
+    __privateSet(this, _onMessage, value);
+  }
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */
+  get onopen() {
+    return __privateGet(this, _onOpen);
+  }
+  set onopen(value) {
+    __privateSet(this, _onOpen, value);
+  }
+  addEventListener(type, listener, options) {
+    const listen = listener;
+    super.addEventListener(type, listen, options);
+  }
+  removeEventListener(type, listener, options) {
+    const listen = listener;
+    super.removeEventListener(type, listen, options);
+  }
+  /**
+   * Aborts any instances of the fetch algorithm started for this EventSource object, and sets the readyState attribute to CLOSED.
+   *
+   * [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/close)
+   *
+   * @public
+   */
+  close() {
+    __privateGet(this, _reconnectTimer) && clearTimeout(__privateGet(this, _reconnectTimer)), __privateGet(this, _readyState) !== this.CLOSED && (__privateGet(this, _controller) && __privateGet(this, _controller).abort(), __privateSet(this, _readyState, this.CLOSED), __privateSet(this, _controller, void 0));
+  }
+};
+_readyState = /* @__PURE__ */ new WeakMap(), _url = /* @__PURE__ */ new WeakMap(), _redirectUrl = /* @__PURE__ */ new WeakMap(), _withCredentials = /* @__PURE__ */ new WeakMap(), _fetch = /* @__PURE__ */ new WeakMap(), _reconnectInterval = /* @__PURE__ */ new WeakMap(), _reconnectTimer = /* @__PURE__ */ new WeakMap(), _lastEventId = /* @__PURE__ */ new WeakMap(), _controller = /* @__PURE__ */ new WeakMap(), _parser = /* @__PURE__ */ new WeakMap(), _onError = /* @__PURE__ */ new WeakMap(), _onMessage = /* @__PURE__ */ new WeakMap(), _onOpen = /* @__PURE__ */ new WeakMap(), _EventSource_instances = /* @__PURE__ */ new WeakSet(), /**
+* Connect to the given URL and start receiving events
+*
+* @internal
+*/
+connect_fn = function() {
+  __privateSet(this, _readyState, this.CONNECTING), __privateSet(this, _controller, new AbortController()), __privateGet(this, _fetch)(__privateGet(this, _url), __privateMethod(this, _EventSource_instances, getRequestOptions_fn).call(this)).then(__privateGet(this, _onFetchResponse)).catch(__privateGet(this, _onFetchError));
+}, _onFetchResponse = /* @__PURE__ */ new WeakMap(), _onFetchError = /* @__PURE__ */ new WeakMap(), /**
+* Get request options for the `fetch()` request
+*
+* @returns The request options
+* @internal
+*/
+getRequestOptions_fn = function() {
+  var _a;
+  const init = {
+    // [spec] Let `corsAttributeState` be `Anonymous`…
+    // [spec] …will have their mode set to "cors"…
+    mode: "cors",
+    redirect: "follow",
+    headers: { Accept: "text/event-stream", ...__privateGet(this, _lastEventId) ? { "Last-Event-ID": __privateGet(this, _lastEventId) } : void 0 },
+    cache: "no-store",
+    signal: (_a = __privateGet(this, _controller)) == null ? void 0 : _a.signal
+  };
+  return "window" in globalThis && (init.credentials = this.withCredentials ? "include" : "same-origin"), init;
+}, _onEvent = /* @__PURE__ */ new WeakMap(), _onRetryChange = /* @__PURE__ */ new WeakMap(), /**
+* Handles the process referred to in the EventSource specification as "failing a connection".
+*
+* @param error - The error causing the connection to fail
+* @param code - The HTTP status code, if available
+* @internal
+*/
+failConnection_fn = function(message, code) {
+  var _a;
+  __privateGet(this, _readyState) !== this.CLOSED && __privateSet(this, _readyState, this.CLOSED);
+  const errorEvent = new ErrorEvent("error", { code, message });
+  (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent);
+}, /**
+* Schedules a reconnection attempt against the EventSource endpoint.
+*
+* @param message - The error causing the connection to fail
+* @param code - The HTTP status code, if available
+* @internal
+*/
+scheduleReconnect_fn = function(message, code) {
+  var _a;
+  if (__privateGet(this, _readyState) === this.CLOSED)
+    return;
+  __privateSet(this, _readyState, this.CONNECTING);
+  const errorEvent = new ErrorEvent("error", { code, message });
+  (_a = __privateGet(this, _onError)) == null || _a.call(this, errorEvent), this.dispatchEvent(errorEvent), __privateSet(this, _reconnectTimer, setTimeout(__privateGet(this, _reconnect), __privateGet(this, _reconnectInterval)));
+}, _reconnect = /* @__PURE__ */ new WeakMap(), /**
+* ReadyState representing an EventSource currently trying to connect
+*
+* @public
+*/
+EventSource.CONNECTING = 0, /**
+* ReadyState representing an EventSource connection that is open (eg connected)
+*
+* @public
+*/
+EventSource.OPEN = 1, /**
+* ReadyState representing an EventSource connection that is closed (eg disconnected)
+*
+* @public
+*/
+EventSource.CLOSED = 2;
+function getBaseURL() {
+  const doc = "document" in globalThis ? globalThis.document : void 0;
+  return doc && typeof doc == "object" && "baseURI" in doc && typeof doc.baseURI == "string" ? doc.baseURI : void 0;
+}
+
+// src/sse.ts
+var getSseUpdatesStream = async () => {
+  const url = resolveTunaUrl(getSseUrl());
+  return new EventSource(url);
+};
+function eventIsInitialMessage(event) {
+  return !("entity" in event) || "entity" in event && event.entity === NotificationEntity.initialMessage;
+}
+function eventIsPoolSwap(event) {
+  return "entity" in event && event.entity === NotificationEntity.poolSwap;
+}
+function eventIsStakingPosition(event) {
+  return "entity" in event && event.entity === NotificationEntity.stakingPosition;
+}
+function eventIsLendingPosition(event) {
+  return "entity" in event && event.entity === NotificationEntity.lendingPosition;
+}
+function eventIsTradeHistory(event) {
+  return "entity" in event && event.entity === NotificationEntity.tradeHistoryEntry;
+}
+function eventIsOrderHistory(event) {
+  return "entity" in event && event.entity === NotificationEntity.orderHistoryEntry;
+}
+function eventIsStateSnapshot(event) {
+  return "entity" in event && event.entity === NotificationEntity.stateSnapshot;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LeaderboardPeriod,
+  LeaderboardSortBy,
+  LimitOrderStatus,
+  LpPositionsHistoryQueryFilter,
+  NotificationAction,
+  NotificationEntity,
+  OrderHistoryStatus,
+  OrderHistoryType,
+  OrderHistoryUIDirection,
+  PoolProvider,
+  PoolSubscriptionTopic,
+  StakingPositionActionType,
+  TradeHistoryAction,
+  TradeHistoryUIDirection,
+  TunaLpPositionAutoCompound,
+  TunaLpPositionAutoCompounding,
+  TunaLpPositionLimitOrderSwap,
+  TunaLpPositionRebalance,
+  TunaLpPositionsActionType,
+  TunaPositionDtoState,
+  TunaPositionMarketMaker,
+  TunaPositionPoolToken,
+  TunaSpotPositionDtoState,
+  WalletSubscriptionTopic,
+  eventIsInitialMessage,
+  eventIsLendingPosition,
+  eventIsOrderHistory,
+  eventIsPoolSwap,
+  eventIsStakingPosition,
+  eventIsStateSnapshot,
+  eventIsTradeHistory,
+  getCloseSpotPositionQuote,
+  getDecreaseSpotPositionQuote,
+  getFeesStats,
+  getFusionFeesStats,
+  getGetCloseSpotPositionQuoteUrl,
+  getGetDecreaseSpotPositionQuoteUrl,
+  getGetFeesStatsUrl,
+  getGetFusionFeesStatsUrl,
+  getGetIncreaseSpotPositionQuoteUrl,
+  getGetLendingPositionUrl,
+  getGetLendingPositionsUrl,
+  getGetLimitOrderQuoteByInputUrl,
+  getGetLimitOrderQuoteByOutputUrl,
+  getGetLimitOrderUrl,
+  getGetLimitOrdersUrl,
+  getGetLpPositionActionsUrl,
+  getGetLpPositionsUrl,
+  getGetLpSpotLeaderboardUrl,
+  getGetMarketUrl,
+  getGetMarketsUrl,
+  getGetMintUrl,
+  getGetMintsUrl,
+  getGetOraclePriceUrl,
+  getGetOraclePricesUrl,
+  getGetOrderHistoryUrl,
+  getGetPoolCandlesUrl,
+  getGetPoolOrderBookUrl,
+  getGetPoolSwapsUrl,
+  getGetPoolTicksUrl,
+  getGetPoolUrl,
+  getGetPoolsUrl,
+  getGetPositionsStatsUrl,
+  getGetPositionsTotalUrl,
+  getGetSpotPositionUrl,
+  getGetSpotPositionsUrl,
+  getGetStakingLeaderboardUrl,
+  getGetStakingRevenueStatsUrl,
+  getGetStakingTreasuryUrl,
+  getGetSwapQuoteByInputUrl,
+  getGetSwapQuoteByOutputUrl,
+  getGetTradableAmountUrl,
+  getGetTradeHistoryUrl,
+  getGetTunaPositionUrl,
+  getGetTunaPositionsUrl,
+  getGetUserStakingPositionHistoryUrl,
+  getGetUserStakingPositionUrl,
+  getGetVaultHistoryUrl,
+  getGetVaultUrl,
+  getGetVaultsUrl,
+  getIncreaseSpotPositionQuote,
+  getLendingPosition,
+  getLendingPositions,
+  getLimitOrder,
+  getLimitOrderQuoteByInput,
+  getLimitOrderQuoteByOutput,
+  getLimitOrders,
+  getLpPositionActions,
+  getLpPositions,
+  getLpSpotLeaderboard,
+  getMarket,
+  getMarkets,
+  getMint,
+  getMints,
+  getOraclePrice,
+  getOraclePrices,
+  getOrderHistory,
+  getPool,
+  getPoolCandles,
+  getPoolOrderBook,
+  getPoolSwaps,
+  getPoolTicks,
+  getPools,
+  getPositionsStats,
+  getPositionsTotal,
+  getSpotPosition,
+  getSpotPositions,
+  getSseUpdatesStream,
+  getSseUrl,
+  getStakingLeaderboard,
+  getStakingRevenueStats,
+  getStakingTreasury,
+  getSwapQuoteByInput,
+  getSwapQuoteByOutput,
+  getTradableAmount,
+  getTradeHistory,
+  getTunaPosition,
+  getTunaPositions,
+  getUpdateStreamSubscriptionUrl,
+  getUserStakingPosition,
+  getUserStakingPositionHistory,
+  getVault,
+  getVaultHistory,
+  getVaults,
+  setTunaBaseUrl,
+  sse,
+  unwrap,
+  updateStreamSubscription
+});