@crypticdot/defituna-api 1.10.16 → 3.0.0

package/dist/index.js

@@ -1,1545 +1,1565 @@
-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 __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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  NotificationAction: () => NotificationAction,
-  NotificationEntity: () => NotificationEntity,
-  PoolProvider: () => PoolProvider,
-  PoolSubscriptionTopic: () => PoolSubscriptionTopic,
-  ProviderFilter: () => ProviderFilter,
-  TunaApiClient: () => TunaApiClient,
-  TunaPositionState: () => TunaPositionState,
-  WalletSubscriptionTopic: () => WalletSubscriptionTopic,
-  schemas: () => schemas_exports
-});
-module.exports = __toCommonJS(index_exports);
-
-// src/client/client.ts
-var import_camelcase_keys = __toESM(require("camelcase-keys"));
-var import_snakecase_keys = __toESM(require("snakecase-keys"));
-
-// src/client/schemas.ts
-var schemas_exports = {};
-__export(schemas_exports, {
-  AmountWithUsdSchema: () => AmountWithUsdSchema,
-  AmountWithoutUsdSchema: () => AmountWithoutUsdSchema,
-  CloseSpotPositionQuote: () => CloseSpotPositionQuote,
-  DecreaseSpotPositionQuote: () => DecreaseSpotPositionQuote,
-  FeesStatsGroup: () => FeesStatsGroup,
-  IncreaseSpotPositionQuote: () => IncreaseSpotPositionQuote,
-  LendingPosition: () => LendingPosition,
-  LendingPositionNotification: () => LendingPositionNotification,
-  LimitOrder: () => LimitOrder,
-  LimitOrderQuoteByInput: () => LimitOrderQuoteByInput,
-  LimitOrderQuoteByOutput: () => LimitOrderQuoteByOutput,
-  LimitOrderState: () => LimitOrderState,
-  LimitOrderStateSchema: () => LimitOrderStateSchema,
-  LpPositionAutoCompound: () => LpPositionAutoCompound,
-  LpPositionAutoCompoundSchema: () => LpPositionAutoCompoundSchema,
-  LpPositionLimitOrderSwap: () => LpPositionLimitOrderSwap,
-  LpPositionLimitOrderSwapSchema: () => LpPositionLimitOrderSwapSchema,
-  LpPositionRebalance: () => LpPositionRebalance,
-  LpPositionRebalanceSchema: () => LpPositionRebalanceSchema,
-  LpPositionsActionType: () => LpPositionsActionType,
-  LpPositionsActionTypeSchema: () => LpPositionsActionTypeSchema,
-  Market: () => Market,
-  Mint: () => Mint,
-  NotificationAction: () => NotificationAction,
-  NotificationActionSchema: () => NotificationActionSchema,
-  NotificationEntity: () => NotificationEntity,
-  NotificationEntitySchema: () => NotificationEntitySchema,
-  OrderBook: () => OrderBook,
-  OrderBookEntry: () => OrderBookEntry,
-  OrderHistoryEntry: () => OrderHistoryEntry,
-  OrderHistoryEntryNotification: () => OrderHistoryEntryNotification,
-  OrderHistoryOrderType: () => OrderHistoryOrderType,
-  OrderHistoryOrderTypeSchema: () => OrderHistoryOrderTypeSchema,
-  OrderHistoryStatus: () => OrderHistoryStatus,
-  OrderHistoryStatusSchema: () => OrderHistoryStatusSchema,
-  OrderHistoryUIDirection: () => OrderHistoryUIDirection,
-  OrderHistoryUIDirectionSchema: () => OrderHistoryUIDirectionSchema,
-  PaginationMeta: () => PaginationMeta,
-  Pool: () => Pool,
-  PoolPriceCandle: () => PoolPriceCandle,
-  PoolProvider: () => PoolProvider,
-  PoolProviderSchema: () => PoolProviderSchema,
-  PoolSubscriptionTopic: () => PoolSubscriptionTopic,
-  PoolSubscriptionTopicSchema: () => PoolSubscriptionTopicSchema,
-  PoolSwap: () => PoolSwap,
-  PoolSwapNotification: () => PoolSwapNotification,
-  PoolTicks: () => PoolTicks,
-  StakingLeaderboardPage: () => StakingLeaderboardPage,
-  StakingLeaderboardPosition: () => StakingLeaderboardPosition,
-  StakingPosition: () => StakingPosition,
-  StakingPositionHistoryAction: () => StakingPositionHistoryAction,
-  StakingPositionHistoryActionType: () => StakingPositionHistoryActionType,
-  StakingPositionHistoryActionTypeSchema: () => StakingPositionHistoryActionTypeSchema,
-  StakingPositionNotification: () => StakingPositionNotification,
-  StakingRevenueStatsGroup: () => StakingRevenueStatsGroup,
-  StakingTreasury: () => StakingTreasury,
-  StateSnapshot: () => StateSnapshot,
-  StateSnapshotNotification: () => StateSnapshotNotification,
-  SwapQuoteByInput: () => SwapQuoteByInput,
-  SwapQuoteByOutput: () => SwapQuoteByOutput,
-  Tick: () => Tick,
-  TokenOraclePrice: () => TokenOraclePrice,
-  TokensPnlSchema: () => TokensPnlSchema,
-  TradableAmount: () => TradableAmount,
-  TradeHistoryAction: () => TradeHistoryAction,
-  TradeHistoryActionSchema: () => TradeHistoryActionSchema,
-  TradeHistoryEntry: () => TradeHistoryEntry,
-  TradeHistoryEntryNotification: () => TradeHistoryEntryNotification,
-  TradeHistoryUIDirection: () => TradeHistoryUIDirection,
-  TradeHistoryUIDirectionSchema: () => TradeHistoryUIDirectionSchema,
-  TunaLpPositionAction: () => TunaLpPositionAction,
-  TunaLpPositionActionClose: () => TunaLpPositionActionClose,
-  TunaLpPositionActionCollectAndCompoundFees: () => TunaLpPositionActionCollectAndCompoundFees,
-  TunaLpPositionActionCollectFees: () => TunaLpPositionActionCollectFees,
-  TunaLpPositionActionDecreaseLiquidity: () => TunaLpPositionActionDecreaseLiquidity,
-  TunaLpPositionActionIncreaseLiquidity: () => TunaLpPositionActionIncreaseLiquidity,
-  TunaLpPositionActionLiquidate: () => TunaLpPositionActionLiquidate,
-  TunaLpPositionActionOpen: () => TunaLpPositionActionOpen,
-  TunaLpPositionActionParametersUpdate: () => TunaLpPositionActionParametersUpdate,
-  TunaLpPositionActionRepayDebt: () => TunaLpPositionActionRepayDebt,
-  TunaLpPositionAutoCompounding: () => TunaLpPositionAutoCompounding,
-  TunaLpPositionAutoCompoundingSchema: () => TunaLpPositionAutoCompoundingSchema,
-  TunaLpPositionDtoSchema: () => TunaLpPositionDtoSchema,
-  TunaLpPositionFlagsSchema: () => TunaLpPositionFlagsSchema,
-  TunaLpPositionHistorical: () => TunaLpPositionHistorical,
-  TunaLpPositionParameters: () => TunaLpPositionParameters,
-  TunaLpPositionTokenPrices: () => TunaLpPositionTokenPrices,
-  TunaLpPositionTransfer: () => TunaLpPositionTransfer,
-  TunaLpPositionValue: () => TunaLpPositionValue,
-  TunaPositionLegacy: () => TunaPositionLegacy,
-  TunaPositionPoolToken: () => TunaPositionPoolToken,
-  TunaPositionPoolTokenSchema: () => TunaPositionPoolTokenSchema,
-  TunaPositionState: () => TunaPositionState,
-  TunaPositionStateSchema: () => TunaPositionStateSchema,
-  TunaPositionTokenPnlSchema: () => TunaPositionTokenPnlSchema,
-  TunaSpotPosition: () => TunaSpotPosition,
-  TunaSpotPositionState: () => TunaSpotPositionState,
-  TunaSpotPositionStateSchema: () => TunaSpotPositionStateSchema,
-  UpdateStreamSubscriptionResult: () => UpdateStreamSubscriptionResult,
-  UsdPnlSchema: () => UsdPnlSchema,
-  Vault: () => Vault,
-  VaultHistoricalStats: () => VaultHistoricalStats,
-  WalletSubscriptionTopic: () => WalletSubscriptionTopic,
-  WalletSubscriptionTopicSchema: () => WalletSubscriptionTopicSchema
-});
-var import_zod11 = require("zod");
-
-// src/client/schemas/basic.ts
-var import_zod = require("zod");
-var AmountWithUsdSchema = import_zod.z.object({
-  amount: import_zod.z.coerce.bigint(),
-  usd: import_zod.z.number()
-});
-var AmountWithoutUsdSchema = import_zod.z.object({
-  amount: import_zod.z.coerce.bigint()
-});
-var TokensPnlSchema = import_zod.z.object({
-  amount: import_zod.z.coerce.bigint(),
-  rate: import_zod.z.number()
-});
-var UsdPnlSchema = import_zod.z.object({
-  amount: import_zod.z.number(),
-  rate: import_zod.z.number()
-});
-
-// src/client/schemas/pool.ts
-var import_zod3 = __toESM(require("zod"));
-
-// src/client/schemas/mint.ts
-var import_zod2 = require("zod");
-var Mint = import_zod2.z.object({
-  address: import_zod2.z.string(),
-  symbol: import_zod2.z.string(),
-  name: import_zod2.z.string(),
-  logo: import_zod2.z.string(),
-  decimals: import_zod2.z.number()
-});
-
-// src/client/schemas/pool.ts
-var PoolProvider = {
-  ORCA: "orca",
-  FUSION: "fusion"
-};
-var PoolProviderSchema = import_zod3.default.enum([PoolProvider.ORCA, ...Object.values(PoolProvider)]);
-var Pool = import_zod3.default.object({
-  address: import_zod3.default.string(),
-  provider: PoolProviderSchema,
-  mintA: Mint,
-  mintB: Mint,
-  tokenAVault: import_zod3.default.string(),
-  tokenBVault: import_zod3.default.string(),
-  tickSpacing: import_zod3.default.number(),
-  feeRate: import_zod3.default.number(),
-  protocolFeeRate: import_zod3.default.number(),
-  olpFeeRate: import_zod3.default.nullable(import_zod3.default.number()),
-  liquidity: import_zod3.default.coerce.bigint(),
-  sqrtPrice: import_zod3.default.coerce.bigint(),
-  price: import_zod3.default.number(),
-  tickCurrentIndex: import_zod3.default.number(),
-  stats: import_zod3.default.optional(
-    import_zod3.default.nullable(
-      import_zod3.default.object({
-        tvlUsd: import_zod3.default.coerce.number(),
-        groups: import_zod3.default.object({
-          "24h": import_zod3.default.object({
-            volumeUsd: import_zod3.default.number(),
-            feesUsd: import_zod3.default.number(),
-            priceChange: import_zod3.default.number()
-          })
-        })
-      })
-    )
-  )
-});
-
-// src/client/schemas/state_snapshot.ts
-var import_zod10 = __toESM(require("zod"));
-
-// src/client/schemas/limit_orders.ts
-var import_zod4 = require("zod");
-var LimitOrderState = {
-  OPEN: "open",
-  PARTIALLY_FILLED: "partially_filled",
-  FILLED: "filled",
-  COMPLETE: "complete",
-  CANCELLED: "cancelled"
-};
-var LimitOrderStateSchema = import_zod4.z.enum([LimitOrderState.OPEN, ...Object.values(LimitOrderState)]);
-var LimitOrder = import_zod4.z.object({
-  address: import_zod4.z.string(),
-  orderMint: import_zod4.z.string(),
-  authority: import_zod4.z.string(),
-  pool: Pool,
-  state: LimitOrderStateSchema,
-  aToB: import_zod4.z.boolean(),
-  tickIndex: import_zod4.z.number(),
-  fillRatio: import_zod4.z.number(),
-  openTxSignature: import_zod4.z.string(),
-  closeTxSignature: import_zod4.z.nullable(import_zod4.z.string()),
-  amountIn: AmountWithUsdSchema,
-  amountOut: AmountWithUsdSchema,
-  openedAt: import_zod4.z.coerce.date(),
-  closedAt: import_zod4.z.nullable(import_zod4.z.coerce.date())
-});
+// 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/client/schemas/lp_positions.ts
-var import_zod6 = __toESM(require("zod"));
+// 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/client/schemas/positions_shared.ts
-var import_zod5 = __toESM(require("zod"));
-var TunaPositionPoolToken = {
-  A: "a",
-  B: "b"
+// src/gen/defiTunaAPI.ts
+var LeaderboardPeriod = {
+  week: "week"
 };
-var TunaPositionPoolTokenSchema = import_zod5.default.enum(Object.values(TunaPositionPoolToken));
-
-// src/client/schemas/lp_positions.ts
-var LpPositionLimitOrderSwap = {
-  NO_SWAP: "no_swap",
-  SWAP_TO_TOKEN_A: "swap_to_token_a",
-  SWAP_TO_TOKEN_B: "swap_to_token_b"
-};
-var LpPositionAutoCompound = {
-  NO_AUTO_COMPOUND: "no_auto_compound",
-  AUTO_COMPOUND: "auto_compound",
-  AUTO_COMPOUND_WITH_LEVERAGE: "auto_compound_with_leverage"
-};
-var LpPositionRebalance = {
-  NO_REBALANCE: "no_rebalance",
-  AUTO_REBALANCE: "auto_rebalance"
-};
-var LpPositionsActionType = {
-  OPEN_POSITION: "open_position",
-  CLOSE_POSITION: "close_position",
-  INCREASE_LIQUIDITY: "increase_liquidity",
-  DECREASE_LIQUIDITY: "decrease_liquidity",
-  REPAY_DEBT: "repay_debt",
-  LIQUIDATE: "liquidate",
-  EXECUTE_LIMIT_ORDER: "execute_limit_order",
-  COLLECT_FEES: "collect_fees",
-  COLLECT_REWARDS: "collect_rewards",
-  COLLECT_AND_COMPOUND_FEES: "collect_and_compound_fees",
-  REBALANCE_POSITION: "rebalance_position",
-  SET_LIMIT_ORDERS: "set_limit_orders",
-  SET_FLAGS: "set_flags",
-  SET_REBALANCE_THRESHOLD: "set_rebalance_threshold"
-};
-var LpPositionLimitOrderSwapSchema = import_zod6.default.enum(Object.values(LpPositionLimitOrderSwap));
-var LpPositionAutoCompoundSchema = import_zod6.default.enum(Object.values(LpPositionAutoCompound));
-var LpPositionRebalanceSchema = import_zod6.default.enum(Object.values(LpPositionRebalance));
-var LpPositionsActionTypeSchema = import_zod6.default.enum(Object.values(LpPositionsActionType));
-var TunaPositionState = {
-  OPEN: "open",
-  LIQUIDATED: "liquidated",
-  CLOSED_BY_LIMIT_ORDER: "closed_by_limit_order",
-  CLOSED: "closed"
-};
-var TunaPositionStateSchema = import_zod6.default.enum([TunaPositionState.OPEN, ...Object.values(TunaPositionState)]);
-var TunaLpPositionAutoCompounding = {
-  WITH_LEVERAGE: "with_leverage",
-  WITHOUT_LEVERAGE: "without_leverage"
-};
-var TunaLpPositionAutoCompoundingSchema = import_zod6.default.enum(
-  Object.values(TunaLpPositionAutoCompounding)
-);
-var TunaPositionTokenPnlSchema = import_zod6.default.object({
-  amount: import_zod6.default.coerce.bigint(),
-  bps: import_zod6.default.number()
-});
-var TunaLpPositionFlagsSchema = import_zod6.default.object({
-  lowerLimitOrderSwapToToken: import_zod6.default.nullable(TunaPositionPoolTokenSchema),
-  upperLimitOrderSwapToToken: import_zod6.default.nullable(TunaPositionPoolTokenSchema),
-  autoCompounding: import_zod6.default.nullable(TunaLpPositionAutoCompoundingSchema),
-  autoRebalancing: import_zod6.default.boolean()
-});
-var TunaLpPositionDtoSchema = import_zod6.default.object({
-  address: import_zod6.default.string(),
-  authority: import_zod6.default.string(),
-  version: import_zod6.default.number(),
-  state: TunaPositionStateSchema,
-  positionMint: import_zod6.default.string(),
-  liquidity: import_zod6.default.coerce.bigint(),
-  tickLowerIndex: import_zod6.default.number(),
-  tickUpperIndex: import_zod6.default.number(),
-  lowerLimitOrderPrice: import_zod6.default.number(),
-  upperLimitOrderPrice: import_zod6.default.number(),
-  entryPrice: import_zod6.default.number(),
-  flags: TunaLpPositionFlagsSchema,
-  pool: Pool,
-  marketMaker: PoolProviderSchema,
-  depositedCollateralA: AmountWithUsdSchema,
-  depositedCollateralB: AmountWithUsdSchema,
-  leverage: import_zod6.default.number(),
-  maxLeverage: import_zod6.default.number(),
-  liquidationPriceLower: import_zod6.default.number(),
-  liquidationPriceUpper: import_zod6.default.number(),
-  initialDebtA: AmountWithUsdSchema,
-  initialDebtB: AmountWithUsdSchema,
-  currentDebtA: AmountWithUsdSchema,
-  currentDebtB: AmountWithUsdSchema,
-  leftoversA: AmountWithUsdSchema,
-  leftoversB: AmountWithUsdSchema,
-  yieldA: AmountWithUsdSchema,
-  yieldB: AmountWithUsdSchema,
-  compoundedYieldA: AmountWithUsdSchema,
-  compoundedYieldB: AmountWithUsdSchema,
-  totalA: AmountWithUsdSchema,
-  totalB: AmountWithUsdSchema,
-  pnlA: TokensPnlSchema,
-  pnlB: TokensPnlSchema,
-  pnlUsd: UsdPnlSchema,
-  openedAt: import_zod6.default.coerce.date(),
-  closedAt: import_zod6.default.nullable(import_zod6.default.coerce.date())
-});
-var TunaLpPositionHistorical = import_zod6.default.object({
-  positionAddress: import_zod6.default.string(),
-  authority: import_zod6.default.string(),
-  pool: import_zod6.default.string(),
-  state: TunaPositionStateSchema,
-  lowerPrice: import_zod6.default.number(),
-  upperPrice: import_zod6.default.number(),
-  lowerLimitOrder: import_zod6.default.number().nullable(),
-  upperLimitOrder: import_zod6.default.number().nullable(),
-  marketMaker: PoolProviderSchema,
-  openedAt: import_zod6.default.coerce.date(),
-  closedAt: import_zod6.default.coerce.date().nullable(),
-  totalValueUsd: import_zod6.default.number(),
-  leverage: import_zod6.default.number(),
-  initialLeverage: import_zod6.default.number(),
-  totalDepositUsd: import_zod6.default.number(),
-  totalWithdrawnUsd: import_zod6.default.number(),
-  feesSumUsd: import_zod6.default.number(),
-  closedPnlSumUsd: import_zod6.default.number(),
-  entryPrice: import_zod6.default.number(),
-  exitPrice: import_zod6.default.number().nullable()
-});
-var TunaPositionLegacy = import_zod6.default.object({
-  address: import_zod6.default.string(),
-  authority: import_zod6.default.string(),
-  version: import_zod6.default.number(),
-  state: TunaPositionStateSchema,
-  positionMint: import_zod6.default.string(),
-  liquidity: import_zod6.default.coerce.bigint(),
-  tickLowerIndex: import_zod6.default.number(),
-  tickUpperIndex: import_zod6.default.number(),
-  entrySqrtPrice: import_zod6.default.coerce.bigint(),
-  lowerLimitOrderSqrtPrice: import_zod6.default.coerce.bigint(),
-  upperLimitOrderSqrtPrice: import_zod6.default.coerce.bigint(),
-  flags: import_zod6.default.number(),
-  pool: import_zod6.default.string(),
-  poolSqrtPrice: import_zod6.default.coerce.bigint(),
-  depositedCollateralA: AmountWithoutUsdSchema,
-  depositedCollateralB: AmountWithoutUsdSchema,
-  depositedCollateralUsd: import_zod6.default.object({
-    amount: import_zod6.default.number()
-  }),
-  loanFundsA: AmountWithUsdSchema,
-  loanFundsB: AmountWithUsdSchema,
-  currentLoanA: AmountWithUsdSchema,
-  currentLoanB: AmountWithUsdSchema,
-  leftoversA: AmountWithUsdSchema,
-  leftoversB: AmountWithUsdSchema,
-  yieldA: AmountWithUsdSchema,
-  yieldB: AmountWithUsdSchema,
-  compoundedYieldA: AmountWithUsdSchema,
-  compoundedYieldB: AmountWithUsdSchema,
-  totalA: AmountWithUsdSchema,
-  totalB: AmountWithUsdSchema,
-  pnlA: TokensPnlSchema,
-  pnlB: TokensPnlSchema,
-  pnlUsd: UsdPnlSchema,
-  openedAt: import_zod6.default.coerce.date(),
-  updatedAtSlot: import_zod6.default.coerce.bigint(),
-  closedAt: import_zod6.default.nullable(import_zod6.default.coerce.date())
-});
-var TunaLpPositionParameters = import_zod6.default.object({
-  lowerPrice: import_zod6.default.number(),
-  upperPrice: import_zod6.default.number(),
-  lowerLimitOrder: import_zod6.default.number().nullable(),
-  upperLimitOrder: import_zod6.default.number().nullable(),
-  lowerLimitOrderSwap: LpPositionLimitOrderSwapSchema,
-  upperLimitOrderSwap: LpPositionLimitOrderSwapSchema,
-  autoCompound: LpPositionAutoCompoundSchema,
-  rebalance: LpPositionRebalanceSchema,
-  rebalanceThresholdTicks: import_zod6.default.number()
-});
-var TunaLpPositionValue = import_zod6.default.object({
-  totalValueA: import_zod6.default.number(),
-  totalValueB: import_zod6.default.number(),
-  totalValueUsd: import_zod6.default.number(),
-  loanFundsA: import_zod6.default.number(),
-  loanFundsB: import_zod6.default.number(),
-  loanFundsUsd: import_zod6.default.number(),
-  leverage: import_zod6.default.number()
-});
-var TunaLpPositionTransfer = import_zod6.default.object({
-  amountA: import_zod6.default.number(),
-  amountB: import_zod6.default.number(),
-  amountUsd: import_zod6.default.number()
-});
-var TunaLpPositionTokenPrices = import_zod6.default.object({
-  tokenPriceA: import_zod6.default.number(),
-  tokenPriceB: import_zod6.default.number()
-});
-var TunaLpPositionActionOpen = import_zod6.default.object({
-  parameters: TunaLpPositionParameters
-});
-var TunaLpPositionActionClose = import_zod6.default.object({
-  toOwner: TunaLpPositionTransfer.nullable(),
-  prices: TunaLpPositionTokenPrices.nullable()
-});
-var TunaLpPositionActionIncreaseLiquidity = import_zod6.default.object({
-  fromPosition: TunaLpPositionValue.nullable(),
-  toPosition: TunaLpPositionValue,
-  fromOwner: TunaLpPositionTransfer,
-  fromLending: TunaLpPositionTransfer,
-  protocolFees: TunaLpPositionTransfer,
-  prices: TunaLpPositionTokenPrices
-});
-var TunaLpPositionActionDecreaseLiquidity = import_zod6.default.object({
-  withdrawPercent: import_zod6.default.number(),
-  closedPnlUsd: import_zod6.default.number(),
-  fromPosition: TunaLpPositionValue,
-  toPosition: TunaLpPositionValue.nullable(),
-  toOwner: TunaLpPositionTransfer,
-  toLending: TunaLpPositionTransfer,
-  collectedFees: TunaLpPositionTransfer,
-  prices: TunaLpPositionTokenPrices
-});
-var TunaLpPositionActionLiquidate = import_zod6.default.object({
-  withdrawPercent: import_zod6.default.number(),
-  fromPosition: TunaLpPositionValue,
-  toLending: TunaLpPositionTransfer,
-  protocolFees: TunaLpPositionTransfer,
-  prices: TunaLpPositionTokenPrices
-});
-var TunaLpPositionActionRepayDebt = import_zod6.default.object({
-  fromPosition: TunaLpPositionValue,
-  toPosition: TunaLpPositionValue,
-  fromOwner: TunaLpPositionTransfer,
-  toLending: TunaLpPositionTransfer,
-  prices: TunaLpPositionTokenPrices
-});
-var TunaLpPositionActionCollectFees = import_zod6.default.object({
-  closedPnlUsd: import_zod6.default.number(),
-  position: TunaLpPositionValue,
-  collectedFees: TunaLpPositionTransfer,
-  toOwner: TunaLpPositionTransfer,
-  prices: TunaLpPositionTokenPrices
-});
-var TunaLpPositionActionCollectAndCompoundFees = import_zod6.default.object({
-  fromPosition: TunaLpPositionValue,
-  toPosition: TunaLpPositionValue,
-  collectedFees: TunaLpPositionTransfer,
-  fromLending: TunaLpPositionTransfer,
-  protocolFees: TunaLpPositionTransfer,
-  prices: TunaLpPositionTokenPrices
-});
-var TunaLpPositionActionParametersUpdate = import_zod6.default.object({
-  fromParameters: TunaLpPositionParameters,
-  toParameters: TunaLpPositionParameters
-});
-var TunaLpPositionAction = import_zod6.default.object({
-  action: LpPositionsActionTypeSchema,
-  txSignature: import_zod6.default.string(),
-  txTimestamp: import_zod6.default.coerce.date(),
-  data: import_zod6.default.object({
-    /** defined for: IncreaseLiquidity, DecreaseLiquidity, Liquidate, ExecuteLimitOrder, RepayDebt, CollectAndCompoundFees */
-    fromPosition: TunaLpPositionValue.optional().nullable(),
-    /** defined for: IncreaseLiquidity, DecreaseLiquidity, Liquidate, ExecuteLimitOrder, RepayDebt, CollectAndCompoundFees */
-    toPosition: TunaLpPositionValue.optional().nullable(),
-    /** defined for: CollectFees */
-    position: TunaLpPositionValue.optional().nullable(),
-    /** defined for: IncreaseLiquidity, RepayDebt */
-    fromOwner: TunaLpPositionTransfer.optional(),
-    /** defined for: DecreaseLiquidity, CollectFees, ClosePosition; nullable for: ClosePosition */
-    toOwner: TunaLpPositionTransfer.optional().nullable(),
-    /** defined for: IncreaseLiquidity, CollectAndCompoundFees */
-    fromLending: TunaLpPositionTransfer.optional(),
-    /** defined for: DecreaseLiquidity, Liquidate, ExecuteLimitOrder, RepayDebt */
-    toLending: TunaLpPositionTransfer.optional(),
-    /** defined for: CollectFees, CollectAndCompoundFees */
-    collectedFees: TunaLpPositionTransfer.optional(),
-    /** defined for: IncreaseLiquidity, Liquidate, ExecuteLimitOrder, CollectAndCompoundFees */
-    protocolFees: TunaLpPositionTransfer.optional(),
-    /** defined for: IncreaseLiquidity, DecreaseLiquidity, Liquidate, ExecuteLimitOrder, RepayDebt, CollectFees, CollectAndCompoundFees, ClosePosition; nullable for: ClosePosition */
-    prices: TunaLpPositionTokenPrices.optional().nullable(),
-    /** defined for: OpenPosition */
-    parameters: TunaLpPositionParameters.optional(),
-    /** defined for: ParametersUpdate */
-    fromParameters: TunaLpPositionParameters.optional(),
-    /** defined for: ParametersUpdate */
-    toParameters: TunaLpPositionParameters.optional(),
-    /** defined for: DecreaseLiquidity */
-    withdrawPercent: import_zod6.default.number().optional(),
-    /** defined for: DecreaseLiquidity, CollectFees */
-    closedPnlUsd: import_zod6.default.number().optional()
-  })
-});
-
-// src/client/schemas/market.ts
-var import_zod7 = require("zod");
-var Market = import_zod7.z.object({
-  address: import_zod7.z.string(),
-  addressLookupTable: import_zod7.z.string(),
-  maxLeverage: import_zod7.z.number(),
-  maxSwapSlippage: import_zod7.z.number(),
-  protocolFee: import_zod7.z.number(),
-  protocolFeeOnCollateral: import_zod7.z.number(),
-  liquidationFee: import_zod7.z.number(),
-  liquidationThreshold: import_zod7.z.number(),
-  oraclePriceDeviationThreshold: import_zod7.z.number(),
-  rebalanceProtocolFee: import_zod7.z.number(),
-  borrowedFundsA: AmountWithUsdSchema,
-  borrowedFundsB: AmountWithUsdSchema,
-  borrowLimitA: AmountWithUsdSchema,
-  borrowLimitB: AmountWithUsdSchema,
-  maxSpotPositionSizeA: AmountWithUsdSchema,
-  maxSpotPositionSizeB: AmountWithUsdSchema,
-  pool: Pool,
-  disabled: import_zod7.z.boolean(),
-  createdAt: import_zod7.z.coerce.date()
-});
-
-// src/client/schemas/order_book.ts
-var import_zod8 = __toESM(require("zod"));
-var OrderBookEntry = import_zod8.default.object({
-  concentratedAmount: import_zod8.default.coerce.bigint(),
-  concentratedAmountQuote: import_zod8.default.coerce.bigint(),
-  concentratedTotal: import_zod8.default.coerce.bigint(),
-  concentratedTotalQuote: import_zod8.default.coerce.bigint(),
-  limitAmount: import_zod8.default.coerce.bigint(),
-  limitAmountQuote: import_zod8.default.coerce.bigint(),
-  limitTotal: import_zod8.default.coerce.bigint(),
-  limitTotalQuote: import_zod8.default.coerce.bigint(),
-  price: import_zod8.default.number(),
-  askSide: import_zod8.default.boolean()
-});
-var OrderBook = import_zod8.default.object({
-  entries: OrderBookEntry.array(),
-  poolPrice: import_zod8.default.number(),
-  poolAddress: import_zod8.default.string()
-});
-
-// src/client/schemas/spot_positions.ts
-var import_zod9 = require("zod");
-var TunaSpotPositionState = {
-  OPEN: "open",
-  CLOSED: "closed"
-};
-var TunaSpotPositionStateSchema = import_zod9.z.enum([
-  TunaSpotPositionState.OPEN,
-  ...Object.values(TunaSpotPositionState)
-]);
-var TunaSpotPosition = import_zod9.z.object({
-  address: import_zod9.z.string(),
-  authority: import_zod9.z.string(),
-  version: import_zod9.z.number(),
-  state: TunaSpotPositionStateSchema,
-  lowerLimitOrderPrice: import_zod9.z.number(),
-  upperLimitOrderPrice: import_zod9.z.number(),
-  entryPrice: import_zod9.z.number(),
-  pool: Pool,
-  positionToken: TunaPositionPoolTokenSchema,
-  collateralToken: TunaPositionPoolTokenSchema,
-  marketMaker: PoolProviderSchema,
-  depositedCollateral: AmountWithUsdSchema,
-  initialDebt: AmountWithUsdSchema,
-  currentDebt: AmountWithUsdSchema,
-  total: AmountWithUsdSchema,
-  leverage: import_zod9.z.number(),
-  maxLeverage: import_zod9.z.number(),
-  liquidationPrice: import_zod9.z.number(),
-  pnlUsd: UsdPnlSchema,
-  openedAt: import_zod9.z.coerce.date(),
-  closedAt: import_zod9.z.nullable(import_zod9.z.coerce.date())
-});
-var IncreaseSpotPositionQuote = import_zod9.z.object({
-  /** Required collateral amount */
-  collateralAmount: import_zod9.z.coerce.bigint(),
-  /** Required amount to borrow */
-  borrowAmount: import_zod9.z.coerce.bigint(),
-  /** Estimated position size in the position token. */
-  estimatedAmount: import_zod9.z.coerce.bigint(),
-  /** Swap input amount. */
-  swapInputAmount: import_zod9.z.coerce.bigint(),
-  /** Minimum swap output amount according to the provided slippage. */
-  minSwapOutputAmount: import_zod9.z.coerce.bigint(),
-  /** Protocol fee in token A */
-  protocolFeeA: import_zod9.z.coerce.bigint(),
-  /** Protocol fee in token B */
-  protocolFeeB: import_zod9.z.coerce.bigint(),
-  /** Price impact in percents */
-  priceImpact: import_zod9.z.number(),
-  /** Liquidation price */
-  liquidationPrice: import_zod9.z.number()
-});
-var DecreaseSpotPositionQuote = import_zod9.z.object({
-  /** Confirmed position decrease percentage (100% = 1.0) */
-  decreasePercent: import_zod9.z.number(),
-  /** The maximum acceptable swap input amount for position decrease according to the provided slippage
-   * (if collateral_token == position_token) OR the minimum swap output amount (if collateral_token != position_token).
-   */
-  requiredSwapAmount: import_zod9.z.coerce.bigint(),
-  /**  Estimated total amount of the adjusted position */
-  estimatedAmount: import_zod9.z.coerce.bigint(),
-  /** Estimated amount of the withdrawn collateral */
-  estimatedWithdrawnCollateral: import_zod9.z.coerce.bigint(),
-  /** Price impact in percents */
-  priceImpact: import_zod9.z.number(),
-  /** Liquidation price */
-  liquidationPrice: import_zod9.z.number()
-});
-var CloseSpotPositionQuote = import_zod9.z.object({
-  /** Position decrease percentage */
-  decreasePercent: import_zod9.z.number(),
-  /** The maximum acceptable swap input amount for position decrease according to the provided slippage
-   * (if collateral_token == position_token) OR the minimum swap output amount (if collateral_token != position_token).
-   */
-  requiredSwapAmount: import_zod9.z.coerce.bigint(),
-  /** Estimated amount of the withdrawn collateral */
-  estimatedWithdrawnCollateral: import_zod9.z.coerce.bigint(),
-  /** Price impact in percents */
-  priceImpact: import_zod9.z.number()
-});
-
-// src/client/schemas/state_snapshot.ts
-var StateSnapshot = import_zod10.default.object({
-  slot: import_zod10.default.coerce.bigint(),
-  blockTime: import_zod10.default.coerce.date(),
-  markets: import_zod10.default.optional(import_zod10.default.array(Market)),
-  tunaSpotPositions: import_zod10.default.optional(import_zod10.default.array(TunaSpotPosition)),
-  tunaLpPositions: import_zod10.default.optional(import_zod10.default.array(TunaLpPositionDtoSchema)),
-  fusionLimitOrders: import_zod10.default.optional(import_zod10.default.array(LimitOrder)),
-  orderBooks: import_zod10.default.optional(import_zod10.default.array(OrderBook))
-});
-
-// src/client/schemas.ts
-var NotificationEntity = {
-  POOL_SWAP: "pool_swap",
-  LENDING_POSITION: "lending_position",
-  STAKING_POSITION: "staking_position",
-  MARKET: "market",
-  TRADE_HISTORY_ENTRY: "trade_history_entry",
-  ORDER_HISTORY_ENTRY: "order_history_entry",
-  STATE_SNAPSHOT: "state_snapshot"
+var LeaderboardSortBy = {
+  profit: "profit",
+  percent: "percent"
 };
-var NotificationAction = {
-  CREATE: "create",
-  UPDATE: "update"
+var LimitOrderStatus = {
+  open: "open",
+  partiallyFilled: "partially_filled",
+  filled: "filled",
+  complete: "complete",
+  cancelled: "cancelled"
 };
-var TradeHistoryAction = {
-  SWAP: "swap",
-  LIMIT_ORDER_FILL: "limit_order_fill",
-  POSITION_INCREASE: "position_increase",
-  POSITION_DECREASE: "position_decrease",
-  TAKE_PROFIT: "take_profit",
-  STOP_LOSS: "stop_loss",
-  LIQUIDATION: "liquidation"
+var LpPositionsHistoryQueryFilter = {
+  opened: "opened",
+  closed: "closed",
+  all: "all"
 };
-var TradeHistoryUIDirection = {
-  BUY: "buy",
-  SELL: "sell",
-  OPEN_LONG: "open_long",
-  CLOSE_LONG: "close_long",
-  OPEN_SHORT: "open_short",
-  CLOSE_SHORT: "close_short"
-};
-var OrderHistoryOrderType = {
-  MARKET: "market",
-  LIMIT: "limit",
-  TAKE_PROFIT_MARKET: "take_profit_market",
-  STOP_LOSS_MARKET: "stop_loss_market",
-  LIQUIDATION_MARKET: "liquidation_market"
+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",
-  PARTIALLY_FILLED: "partially_filled",
-  FILLED: "filled",
-  CANCELLED: "cancelled",
-  CLAIMED: "claimed",
-  REJECTED: "rejected"
+  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 StakingPositionHistoryActionType = {
-  STAKE: "stake",
-  UNSTAKE: "unstake",
-  WITHDRAW: "withdraw",
-  CLAIM_REWARDS: "claim_rewards",
-  COMPOUND_REWARDS: "compound_rewards"
+  buy: "buy",
+  sell: "sell",
+  long: "long",
+  short: "short"
+};
+var PoolProvider = {
+  orca: "orca",
+  fusion: "fusion"
 };
 var PoolSubscriptionTopic = {
-  ORDER_BOOK: "order_book",
-  POOL_SWAPS: "pool_swaps"
+  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 = {
-  TUNA_POSITIONS: "tuna_positions",
-  TUNA_SPOT_POSITIONS: "tuna_spot_positions",
-  LENDING_POSITIONS: "lending_positions",
-  FUSION_LIMIT_ORDERS: "fusion_limit_orders",
-  STAKING_POSITION: "staking_position",
-  TRADE_HISTORY: "trade_history",
-  ORDER_HISTORY: "order_history"
-};
-var NotificationEntitySchema = import_zod11.z.enum([NotificationEntity.POOL_SWAP, ...Object.values(NotificationEntity)]);
-var NotificationActionSchema = import_zod11.z.enum([NotificationAction.CREATE, ...Object.values(NotificationAction)]);
-var TradeHistoryActionSchema = import_zod11.z.enum([TradeHistoryAction.SWAP, ...Object.values(TradeHistoryAction)]);
-var TradeHistoryUIDirectionSchema = import_zod11.z.enum([
-  TradeHistoryUIDirection.BUY,
-  ...Object.values(TradeHistoryUIDirection)
-]);
-var OrderHistoryOrderTypeSchema = import_zod11.z.enum([
-  OrderHistoryOrderType.MARKET,
-  ...Object.values(OrderHistoryOrderType)
-]);
-var OrderHistoryStatusSchema = import_zod11.z.enum([OrderHistoryStatus.OPEN, ...Object.values(OrderHistoryStatus)]);
-var OrderHistoryUIDirectionSchema = import_zod11.z.enum([
-  OrderHistoryUIDirection.BUY,
-  ...Object.values(OrderHistoryUIDirection)
-]);
-var StakingPositionHistoryActionTypeSchema = import_zod11.z.enum([
-  StakingPositionHistoryActionType.STAKE,
-  ...Object.values(StakingPositionHistoryActionType)
-]);
-var PoolSubscriptionTopicSchema = import_zod11.z.enum([
-  PoolSubscriptionTopic.ORDER_BOOK,
-  ...Object.values(PoolSubscriptionTopic)
-]);
-var WalletSubscriptionTopicSchema = import_zod11.z.enum([
-  WalletSubscriptionTopic.TUNA_POSITIONS,
-  ...Object.values(WalletSubscriptionTopic)
-]);
-var PaginationMeta = import_zod11.z.object({
-  total: import_zod11.z.number()
-});
-var TokenOraclePrice = import_zod11.z.object({
-  mint: import_zod11.z.string(),
-  price: import_zod11.z.coerce.bigint(),
-  decimals: import_zod11.z.number(),
-  time: import_zod11.z.coerce.date()
-});
-var Vault = import_zod11.z.object({
-  address: import_zod11.z.string(),
-  mint: import_zod11.z.string(),
-  depositedFunds: AmountWithUsdSchema,
-  borrowedFunds: AmountWithUsdSchema,
-  supplyLimit: AmountWithUsdSchema,
-  borrowedShares: import_zod11.z.coerce.bigint(),
-  depositedShares: import_zod11.z.coerce.bigint(),
-  supplyApy: import_zod11.z.number(),
-  borrowApy: import_zod11.z.number(),
-  interestRate: import_zod11.z.coerce.bigint(),
-  utilization: import_zod11.z.number(),
-  pythOracleFeedId: import_zod11.z.string(),
-  pythOraclePriceUpdate: import_zod11.z.string()
-});
-var VaultHistoricalStats = import_zod11.z.object({
-  date: import_zod11.z.preprocess((val, ctx) => {
-    if (typeof val === "string") {
-      const [year, month, day] = val.split("-").map(Number);
-      return new Date(year, month - 1, day);
-    }
-    ctx.addIssue({
-      code: "custom",
-      message: "Not a valid date string"
-    });
-    return import_zod11.z.NEVER;
-  }, import_zod11.z.date()),
-  supply: AmountWithUsdSchema,
-  borrow: AmountWithUsdSchema,
-  supplyApy: import_zod11.z.number(),
-  borrowApr: import_zod11.z.number()
-});
-var Tick = import_zod11.z.object({
-  index: import_zod11.z.number(),
-  liquidity: import_zod11.z.coerce.bigint()
-});
-var PoolTicks = import_zod11.z.object({
-  tickSpacing: import_zod11.z.number(),
-  ticks: Tick.array()
-});
-var LendingPosition = import_zod11.z.object({
-  address: import_zod11.z.string(),
-  authority: import_zod11.z.string(),
-  mint: import_zod11.z.string(),
-  vault: import_zod11.z.string(),
-  shares: import_zod11.z.coerce.bigint(),
-  funds: AmountWithUsdSchema,
-  earned: AmountWithUsdSchema
-});
-var PoolSwap = import_zod11.z.object({
-  id: import_zod11.z.string(),
-  amountIn: import_zod11.z.coerce.bigint(),
-  amountOut: import_zod11.z.coerce.bigint(),
-  amountUsd: import_zod11.z.number(),
-  aToB: import_zod11.z.boolean(),
-  pool: import_zod11.z.string(),
-  time: import_zod11.z.coerce.date()
-});
-var TradeHistoryEntry = import_zod11.z.object({
-  // Internal entry ID
-  id: import_zod11.z.string(),
-  pool: Pool,
-  authority: import_zod11.z.string(),
-  aToB: import_zod11.z.boolean(),
-  // Trade action which created entry
-  action: TradeHistoryActionSchema,
-  // Trade direction formatted for ui display
-  uiDirection: TradeHistoryUIDirectionSchema,
-  // Trade price formatted for ui display
-  uiPrice: import_zod11.z.number(),
-  baseToken: AmountWithUsdSchema,
-  quoteToken: AmountWithUsdSchema,
-  fee: AmountWithUsdSchema,
-  pnl: import_zod11.z.nullable(
-    import_zod11.z.object({
-      usd: import_zod11.z.number(),
-      bps: import_zod11.z.number()
-    })
-  ),
-  txSignature: import_zod11.z.nullable(import_zod11.z.string()),
-  positionAddress: import_zod11.z.nullable(import_zod11.z.string()),
-  slot: import_zod11.z.coerce.bigint(),
-  ts: import_zod11.z.coerce.date()
-});
-var OrderHistoryEntry = import_zod11.z.object({
-  // Internal entry ID
-  id: import_zod11.z.string(),
-  pool: Pool,
-  authority: import_zod11.z.string(),
-  orderType: OrderHistoryOrderTypeSchema,
-  isReduceOnly: import_zod11.z.nullable(import_zod11.z.boolean()),
-  aToB: import_zod11.z.boolean(),
-  uiDirection: OrderHistoryUIDirectionSchema,
-  uiPrice: import_zod11.z.nullable(import_zod11.z.number()),
-  uiExecutionPrice: import_zod11.z.nullable(import_zod11.z.number()),
-  status: OrderHistoryStatusSchema,
-  baseToken: AmountWithUsdSchema,
-  quoteToken: AmountWithUsdSchema,
-  baseTokenConsumedAmount: import_zod11.z.nullable(AmountWithUsdSchema),
-  quoteTokenFilledAmount: import_zod11.z.nullable(AmountWithUsdSchema),
-  txSignature: import_zod11.z.nullable(import_zod11.z.string()),
-  positionAddress: import_zod11.z.nullable(import_zod11.z.string()),
-  slot: import_zod11.z.coerce.bigint(),
-  ts: import_zod11.z.coerce.date()
-});
-var StakingTreasury = import_zod11.z.object({
-  address: import_zod11.z.string(),
-  stakedTokenMint: import_zod11.z.string(),
-  rewardTokenMint: import_zod11.z.string(),
-  apy: import_zod11.z.number(),
-  uniqueStakers: import_zod11.z.number(),
-  totalStaked: AmountWithUsdSchema,
-  totalReward: AmountWithUsdSchema,
-  unstakeCooldownSeconds: import_zod11.z.number(),
-  isStakingEnabled: import_zod11.z.boolean(),
-  isUnstakingEnabled: import_zod11.z.boolean(),
-  isWithdrawEnabled: import_zod11.z.boolean()
-});
-var StakingPosition = import_zod11.z.object({
-  address: import_zod11.z.string(),
-  owner: import_zod11.z.string(),
-  staked: AmountWithUsdSchema,
-  unstaked: AmountWithUsdSchema,
-  claimedReward: AmountWithUsdSchema,
-  unclaimedReward: AmountWithUsdSchema,
-  rank: import_zod11.z.nullable(import_zod11.z.number()),
-  vesting: import_zod11.z.object({
-    locked: AmountWithUsdSchema,
-    unlocked: AmountWithUsdSchema,
-    unlockRate: import_zod11.z.coerce.bigint(),
-    unlockEverySeconds: import_zod11.z.number(),
-    unlockCliffSeconds: import_zod11.z.number(),
-    lockedAt: import_zod11.z.nullable(import_zod11.z.coerce.date())
-  }),
-  lastUnstakedAt: import_zod11.z.nullable(import_zod11.z.coerce.date()),
-  withdrawAvailableAt: import_zod11.z.nullable(import_zod11.z.coerce.date())
-});
-var StakingLeaderboardPosition = import_zod11.z.object({
-  rank: import_zod11.z.number(),
-  address: import_zod11.z.string(),
-  owner: import_zod11.z.string(),
-  staked: AmountWithUsdSchema
-});
-var StakingLeaderboardPage = import_zod11.z.object({
-  data: StakingLeaderboardPosition.array(),
-  meta: PaginationMeta
-});
-var StakingPositionHistoryAction = import_zod11.z.object({
-  position: import_zod11.z.string(),
-  action: StakingPositionHistoryActionTypeSchema,
-  txSignature: import_zod11.z.string(),
-  amount: import_zod11.z.coerce.bigint(),
-  time: import_zod11.z.coerce.date()
-});
-var PoolPriceCandle = import_zod11.z.object({
-  time: import_zod11.z.number(),
-  open: import_zod11.z.number(),
-  close: import_zod11.z.number(),
-  high: import_zod11.z.number(),
-  low: import_zod11.z.number(),
-  volume: import_zod11.z.number()
-});
-var FeesStatsGroup = import_zod11.z.object({
-  time: import_zod11.z.coerce.date(),
-  addLiquidityFees: import_zod11.z.number(),
-  limitOrderFees: import_zod11.z.number(),
-  yieldCompoundingFees: import_zod11.z.number(),
-  liquidationFees: import_zod11.z.number(),
-  totalLiquidationsNetworkFees: import_zod11.z.number(),
-  totalLimitOrdersNetworkFees: import_zod11.z.number(),
-  totalYieldCompoundingNetworkFees: import_zod11.z.number(),
-  failedNetworkFees: import_zod11.z.number(),
-  processedNetworkFees: import_zod11.z.number(),
-  totalCollectedFees: import_zod11.z.number(),
-  totalNetworkFees: import_zod11.z.number(),
-  jitoLiquidationFees: import_zod11.z.number(),
-  jitoLimitOrderFees: import_zod11.z.number(),
-  jitoYieldCompoundingFees: import_zod11.z.number(),
-  runningAddLiquidityFees: import_zod11.z.number(),
-  runningLimitOrderFees: import_zod11.z.number(),
-  runningYieldCompoundingFees: import_zod11.z.number(),
-  runningLiquidationFees: import_zod11.z.number(),
-  runningTotalLiquidationsNetworkFees: import_zod11.z.number(),
-  runningTotalLimitOrdersNetworkFees: import_zod11.z.number(),
-  runningTotalYieldCompoundingNetworkFees: import_zod11.z.number(),
-  runningFailedNetworkFees: import_zod11.z.number(),
-  runningProcessedNetworkFees: import_zod11.z.number(),
-  runningJitoLiquidationFees: import_zod11.z.number(),
-  runningJitoLimitOrderFees: import_zod11.z.number(),
-  runningJitoYieldCompoundingFees: import_zod11.z.number(),
-  runningTotalCollectedFees: import_zod11.z.number(),
-  runningTotalNetworkFees: import_zod11.z.number()
-});
-var StakingRevenueStatsGroup = import_zod11.z.object({
-  time: import_zod11.z.coerce.date(),
-  totalDepositsUsd: import_zod11.z.number(),
-  totalDepositsSol: import_zod11.z.coerce.bigint(),
-  runningTotalDepositsUsd: import_zod11.z.number(),
-  runningTotalDepositsSol: import_zod11.z.coerce.bigint()
-});
-var SwapQuoteByInput = import_zod11.z.object({
-  estimatedAmountOut: import_zod11.z.coerce.bigint(),
-  minAmountOut: import_zod11.z.coerce.bigint(),
-  feeAmount: import_zod11.z.coerce.bigint(),
-  feeUsd: import_zod11.z.number(),
-  /** Price impact in percents */
-  priceImpact: import_zod11.z.number()
-});
-var SwapQuoteByOutput = import_zod11.z.object({
-  estimatedAmountIn: import_zod11.z.coerce.bigint(),
-  maxAmountIn: import_zod11.z.coerce.bigint(),
-  feeAmount: import_zod11.z.coerce.bigint(),
-  feeUsd: import_zod11.z.number(),
-  /** Price impact in percents */
-  priceImpact: import_zod11.z.number()
-});
-var LimitOrderQuoteByInput = import_zod11.z.object({
-  amountOut: import_zod11.z.coerce.bigint()
-});
-var LimitOrderQuoteByOutput = import_zod11.z.object({
-  amountIn: import_zod11.z.coerce.bigint()
-});
-var TradableAmount = AmountWithUsdSchema;
-var UpdateStreamSubscriptionResult = import_zod11.z.object({
-  status: import_zod11.z.string()
-});
-var createNotificationSchema = (dataSchema, metaSchema) => import_zod11.z.object({
-  entity: NotificationEntitySchema,
-  action: NotificationActionSchema,
-  data: dataSchema,
-  id: import_zod11.z.string(),
-  authority: import_zod11.z.nullish(import_zod11.z.string()),
-  ...metaSchema ? { meta: metaSchema } : { meta: import_zod11.z.undefined().nullable() }
-});
-var PoolSwapNotification = createNotificationSchema(PoolSwap);
-var LendingPositionNotification = createNotificationSchema(LendingPosition);
-var TradeHistoryEntryNotification = createNotificationSchema(TradeHistoryEntry);
-var OrderHistoryEntryNotification = createNotificationSchema(OrderHistoryEntry);
-var StakingPositionNotification = createNotificationSchema(StakingPosition);
-var StateSnapshotNotification = createNotificationSchema(StateSnapshot);
-
-// src/client/client.ts
-var DEFAULT_TIMEOUT = 5e3;
-var DEFAULT_HTTP_RETRIES = 3;
-var ProviderFilter = /* @__PURE__ */ ((ProviderFilter2) => {
-  ProviderFilter2["ORCA"] = "orca";
-  ProviderFilter2["FUSION"] = "fusion";
-  ProviderFilter2["ALL"] = "all";
-  return ProviderFilter2;
-})(ProviderFilter || {});
-var TunaApiClient = class {
-  get baseURL() {
-    return this._baseURL;
-  }
-  get timeout() {
-    return this._timeout;
-  }
-  get httpRetries() {
-    return this._httpRetries;
-  }
-  get headers() {
-    return this._headers;
-  }
-  constructor(baseURL, config) {
-    this._baseURL = baseURL;
-    this._timeout = config?.timeout ?? DEFAULT_TIMEOUT;
-    this._httpRetries = config?.httpRetries ?? DEFAULT_HTTP_RETRIES;
-    this._headers = config?.headers ?? {};
-  }
-  setConfig(config) {
-    if (config.baseURL) {
-      this._baseURL = config.baseURL;
+  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());
     }
-    this._timeout = config?.timeout ?? DEFAULT_TIMEOUT;
-    this._httpRetries = config?.httpRetries ?? DEFAULT_HTTP_RETRIES;
-    this._headers = config?.headers ?? {};
-  }
-  async httpRequest(url, schema, options, retries = this.httpRetries, backoff = 100 + Math.floor(Math.random() * 100)) {
-    try {
-      const controller = new AbortController();
-      const abort = setTimeout(() => {
-        controller.abort();
-      }, this.timeout);
-      const signal = options?.signal || controller.signal;
-      const response = await fetch(url, {
-        ...options,
-        signal,
-        headers: { "Content-Type": "application/json", ...this.headers, ...options?.headers }
+  });
+  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());
       });
-      clearTimeout(abort);
-      if (!response.ok) {
-        const errorBody = await response.json();
-        throw errorBody;
-      }
-      const data = await response.json();
-      const transformed = (0, import_camelcase_keys.default)(data, { deep: true, exclude: ["24h", "7d", "30d"] });
-      if (options?.parseRoot) {
-        return schema.parse(transformed);
-      }
-      return schema.parse(transformed.data);
-    } catch (error) {
-      if (retries > 0 && !(error instanceof Error && error.name === "AbortError")) {
-        await new Promise((resolve) => setTimeout(resolve, backoff));
-        return this.httpRequest(url, schema, options, retries - 1, backoff * 2);
-      }
-      throw error;
+      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;
   }
-  /* Endpoints */
-  async getMints() {
-    const url = this.buildURL("mints");
-    return await this.httpRequest(url, Mint.array());
+  return data;
+}
+async function unwrap(promise) {
+  const res = await promise;
+  if (res.status != 200) {
+    throw {
+      status: res.status
+    };
   }
-  async getMint(mintAddress) {
-    const url = this.buildURL(`mints/${mintAddress}`);
-    return await this.httpRequest(url, Mint);
+  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;
   }
-  async getMarkets() {
-    const url = this.buildURL("markets");
-    return await this.httpRequest(url, Market.array());
+};
+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;
   }
-  async getMarket(marketAddress) {
-    const url = this.buildURL(`markets/${marketAddress}`);
-    return await this.httpRequest(url, Market);
+  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);
   }
-  async getOraclePrices() {
-    const url = this.buildURL("oracle-prices");
-    return await this.httpRequest(url, TokenOraclePrice.array());
+  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;
+    }
   }
-  async getOraclePrice(mintAddress) {
-    const url = this.buildURL(`oracle-prices/${mintAddress}`);
-    return await this.httpRequest(url, TokenOraclePrice);
+  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 = "";
   }
-  async getVaults() {
-    const url = this.buildURL("vaults");
-    return await this.httpRequest(url, Vault.array());
+  function reset(options = {}) {
+    incompleteLine && options.consume && parseLine(incompleteLine), isFirstChunk = true, id = void 0, data = "", eventType = "", incompleteLine = "";
   }
-  async getVault(vaultAddress) {
-    const url = this.buildURL(`vaults/${vaultAddress}`);
-    return await this.httpRequest(url, Vault);
+  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 {
   /**
-   *  Returns vault historical data for selected time interval.
+   * Constructs a new `ErrorEvent` instance. This is typically not called directly,
+   * but rather emitted by the `EventSource` object when an error occurs.
    *
-   *  Example usage: getVaultHistory('H3ifgix98vzi3yCPbmZDLTheeTRf2jykXx8FpY5L7Sfd', '2025-03-10', '2025-04-10')
+   * @param type - The type of the event (should be "error")
+   * @param errorEventInitDict - Optional properties to include in the error event
    */
-  async getVaultHistory(vaultAddress, from, to) {
-    const url = this.appendUrlSearchParams(this.buildURL(`vaults/${vaultAddress}/history`), {
-      from: from.toISOString().slice(0, 10),
-      to: to.toISOString().slice(0, 10)
-    });
-    return await this.httpRequest(url, VaultHistoricalStats.array());
-  }
-  async getPools(providerFilter) {
-    const url = this.appendUrlSearchParams(this.buildURL("pools"), {
-      provider: providerFilter && providerFilter !== "all" /* ALL */ ? providerFilter : void 0
-    });
-    return await this.httpRequest(url, Pool.array());
-  }
-  async getPool(address) {
-    const url = this.buildURL(`pools/${address}`);
-    return await this.httpRequest(url, Pool);
-  }
-  async getPoolTicks(poolAddress) {
-    const url = this.buildURL(`pools/${poolAddress}/ticks`);
-    return await this.httpRequest(url, PoolTicks);
-  }
-  async getPoolSwaps(poolAddress) {
-    const url = this.buildURL(`pools/${poolAddress}/swaps`);
-    return await this.httpRequest(url, PoolSwap.array());
-  }
-  async getPoolOrderBook(poolAddress, priceStep, inverted) {
-    const url = this.appendUrlSearchParams(this.buildURL(`pools/${poolAddress}/order-book`), {
-      price_step: priceStep,
-      inverted: inverted || void 0
-    });
-    return await this.httpRequest(url, OrderBook);
+  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;
   }
-  async getPoolPriceCandles(poolAddress, options) {
-    const { from, to, interval, candles } = options;
-    const url = this.appendUrlSearchParams(this.buildURL(`pools/${poolAddress}/candles`), {
-      from: from.toISOString(),
-      to: to.toISOString(),
-      candles,
-      interval
-    });
-    return await this.httpRequest(url, PoolPriceCandle.array());
-  }
-  async getStakingTreasury() {
-    const url = this.buildURL(`staking/treasury`);
-    return await this.httpRequest(url, StakingTreasury);
-  }
-  async getStakingLeaderboard(page, pageSize, search) {
-    const url = this.appendUrlSearchParams(this.buildURL(`staking/leaderboard`), {
-      page,
-      page_size: pageSize,
-      search: search || void 0
-    });
-    return await this.httpRequest(url, StakingLeaderboardPage, { parseRoot: true });
-  }
-  async getUserLendingPositions(userAddress) {
-    const url = this.buildURL(`users/${userAddress}/lending-positions`);
-    return await this.httpRequest(url, LendingPosition.array());
-  }
-  async getUserLendingPositionByAddress(userAddress, lendingPositionAddress) {
-    const url = this.buildURL(`users/${userAddress}/lending-positions/${lendingPositionAddress}`);
-    return await this.httpRequest(url, LendingPosition);
-  }
-  async getUserTunaPositions(userAddress) {
-    const url = this.buildURL(`users/${userAddress}/tuna-positions`);
-    return await this.httpRequest(url, TunaLpPositionDtoSchema.array());
-  }
-  async getUserTunaPositionByAddress(userAddress, tunaPositionAddress) {
-    const url = this.buildURL(`users/${userAddress}/tuna-positions/${tunaPositionAddress}`);
-    return await this.httpRequest(url, TunaLpPositionDtoSchema);
-  }
-  async getUserLpPositions(userAddress, options) {
-    const query = {};
-    if (options) {
-      if (options.filter) {
-        query.filter = options.filter;
-      }
-      if (options.afterPosition) {
-        query.after_position = options.afterPosition;
-      }
-      if (options.openedAt) {
-        if (options.openedAt.from) {
-          query.opened_at_min = options.openedAt.from.toISOString();
-        }
-        if (options.openedAt.to) {
-          query.opened_at_max = options.openedAt.to.toISOString();
-        }
-      }
-      if (options.closedAt) {
-        if (options.closedAt.from) {
-          query.closed_at_min = options.closedAt.from.toISOString();
-        }
-        if (options.closedAt.to) {
-          query.closed_at_max = options.closedAt.to.toISOString();
-        }
-      }
-    }
-    const url = this.appendUrlSearchParams(this.buildURL(`users/${userAddress}/lp-positions`), query);
-    return await this.httpRequest(url, TunaLpPositionHistorical.array());
-  }
-  async getUserLpPositionActions(userAddress, positionAddress) {
-    const url = this.buildURL(`users/${userAddress}/lp-positions/${positionAddress}/actions`);
-    return await this.httpRequest(url, TunaLpPositionAction.array());
-  }
-  async getUserTunaSpotPositions(userAddress) {
-    const url = this.buildURL(`users/${userAddress}/spot-positions`);
-    return await this.httpRequest(url, TunaSpotPosition.array());
-  }
-  async getUserTunaSpotPositionByAddress(userAddress, tunaSpotPositionAddress) {
-    const url = this.buildURL(`users/${userAddress}/spot-positions/${tunaSpotPositionAddress}`);
-    return await this.httpRequest(url, TunaSpotPosition);
-  }
-  async getUserLimitOrders(userAddress, options) {
-    const query = {};
-    if (options) {
-      if (options.pool?.length) {
-        query.pool = options.pool.join(",");
-      }
-      if (options.status?.length) {
-        query.status = options.status.join(",");
-      }
-      if (options.openedAt?.from) {
-        query.opened_at_from = options.openedAt.from.toISOString();
-      }
-      if (options.openedAt?.to) {
-        query.opened_at_from = options.openedAt.to.toISOString();
-      }
-      if (options.limit) {
-        query.limit = options.limit;
-      }
-      if (options.cursor) {
-        query.cursor = options.cursor;
-      }
-      if (options.desc !== void 0) {
-        query.desc = options.desc;
-      }
-    }
-    const url = this.appendUrlSearchParams(this.buildURL(`users/${userAddress}/limit-orders`), query);
-    return await this.httpRequest(url, LimitOrder.array());
-  }
-  async getUserLimitOrderByAddress(userAddress, limitOrderAddress) {
-    const url = this.buildURL(`users/${userAddress}/limit-orders/${limitOrderAddress}`);
-    return await this.httpRequest(url, LimitOrder);
+  /**
+   * 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);
   }
-  async getUserTradeHistory(userAddress, options) {
-    const query = {};
-    if (options) {
-      if (options.pool?.length) {
-        query.pool = options.pool.join(",");
-      }
-      if (options.action?.length) {
-        query.action = options.action.join(",");
-      }
-      if (options.uiDirection?.length) {
-        query.ui_direction = options.uiDirection.join(",");
-      }
-      if (options.limit) {
-        query.limit = options.limit;
-      }
-      if (options.cursor) {
-        query.cursor = options.cursor;
-      }
-      if (options.desc !== void 0) {
-        query.desc = options.desc;
-      }
-    }
-    const url = this.appendUrlSearchParams(this.buildURL(`users/${userAddress}/trade-history`), query);
-    return await this.httpRequest(url, TradeHistoryEntry.array());
+  /**
+   * 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);
   }
-  async getUserOrderHistory(userAddress, options) {
-    const query = {};
-    if (options) {
-      if (options.pool?.length) {
-        query.pool = options.pool.join(",");
-      }
-      if (options.orderType?.length) {
-        query.order_type = options.orderType.join(",");
-      }
-      if (options.uiDiretion?.length) {
-        query.ui_direction = options.uiDiretion.join(",");
+};
+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 (options.limit) {
-        query.limit = options.limit;
+      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 (options.cursor) {
-        query.cursor = options.cursor;
+      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 (options.desc !== void 0) {
-        query.desc = options.desc;
+      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 url = this.appendUrlSearchParams(this.buildURL(`users/${userAddress}/order-history`), query);
-    return await this.httpRequest(url, OrderHistoryEntry.array());
-  }
-  async getUserStakingPosition(userAddress) {
-    const url = this.buildURL(`users/${userAddress}/staking-position`);
-    return await this.httpRequest(url, StakingPosition);
-  }
-  async getUserStakingPositionHistory(userAddress) {
-    const url = this.buildURL(`users/${userAddress}/staking-position/history`);
-    return await this.httpRequest(url, StakingPositionHistoryAction.array());
-  }
-  async getFeesStats(from, to, interval) {
-    const url = this.appendUrlSearchParams(this.buildURL(`stats/fees`), {
-      from: from.toISOString(),
-      to: to.toISOString(),
-      interval
-    });
-    return await this.httpRequest(url, FeesStatsGroup.array());
-  }
-  async getStakingRevenueStats(from, to) {
-    const url = this.appendUrlSearchParams(this.buildURL(`stats/staking/revenue`), {
-      from: from.toISOString().split("T")[0],
-      to: to.toISOString().split("T")[0]
+      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);
     });
-    return await this.httpRequest(url, StakingRevenueStatsGroup.array());
+    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);
   }
-  async getLimitOrderQuoteByInput(args, config) {
-    const { pool, amountIn, aToB, tickIndex } = args;
-    const query = {
-      pool,
-      amount_in: amountIn.toString(),
-      a_to_b: aToB,
-      tick_index: tickIndex
-    };
-    const url = this.appendUrlSearchParams(this.buildURL(`quotes/limit-order-by-input`), query);
-    return await this.httpRequest(url, LimitOrderQuoteByInput, {
-      signal: config?.abortSignal
-    });
+  /**
+   * 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);
   }
-  async getLimitOrderQuoteByOutput(args, config) {
-    const { pool, amountOut, aToB, tickIndex } = args;
-    const query = {
-      pool,
-      amount_out: amountOut.toString(),
-      a_to_b: aToB,
-      tick_index: tickIndex
-    };
-    const url = this.appendUrlSearchParams(this.buildURL(`quotes/limit-order-by-output`), query);
-    return await this.httpRequest(url, LimitOrderQuoteByOutput, {
-      signal: config?.abortSignal
-    });
+  /**
+   * 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;
   }
-  async getSwapQuoteByInput(args, config) {
-    const { pool, amountIn, aToB, slippageToleranceBps } = args;
-    const query = {
-      pool,
-      amount_in: amountIn.toString(),
-      a_to_b: aToB
-    };
-    if (slippageToleranceBps) {
-      query.slippage_tolerance = slippageToleranceBps;
-    }
-    const url = this.appendUrlSearchParams(this.buildURL(`quotes/swap-by-input`), query);
-    return await this.httpRequest(url, SwapQuoteByInput, {
-      signal: config?.abortSignal
-    });
+  /**
+   * 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);
   }
-  async getSwapQuoteByOutput(args, config) {
-    const { pool, amountOut, aToB, slippageToleranceBps } = args;
-    const query = {
-      pool,
-      amount_out: amountOut.toString(),
-      a_to_b: aToB
-    };
-    if (slippageToleranceBps) {
-      query.slippage_tolerance = slippageToleranceBps;
-    }
-    const url = this.appendUrlSearchParams(this.buildURL(`quotes/swap-by-output`), query);
-    return await this.httpRequest(url, SwapQuoteByOutput, {
-      signal: config?.abortSignal
-    });
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/error_event) */
+  get onerror() {
+    return __privateGet(this, _onError);
   }
-  async getIncreaseSpotPositionQuote(args, config) {
-    const {
-      market,
-      increaseAmount,
-      collateralToken,
-      positionToken,
-      leverage,
-      positionAmount,
-      positionDebt,
-      slippageTolerance
-    } = args;
-    const query = {
-      market,
-      increase_amount: increaseAmount.toString(),
-      collateral_token: collateralToken,
-      position_token: positionToken,
-      leverage
-    };
-    if (slippageTolerance) {
-      query.slippage_tolerance = slippageTolerance;
-    }
-    if (positionAmount) {
-      query.position_amount = positionAmount.toString();
-    }
-    if (positionDebt) {
-      query.position_debt = positionDebt.toString();
-    }
-    const url = this.appendUrlSearchParams(this.buildURL(`quotes/increase-spot-position`), query);
-    return await this.httpRequest(url, IncreaseSpotPositionQuote, {
-      signal: config?.abortSignal
-    });
+  set onerror(value) {
+    __privateSet(this, _onError, value);
   }
-  async getDecreaseSpotPositionQuote(args, config) {
-    const {
-      market,
-      decreaseAmount,
-      collateralToken,
-      positionToken,
-      leverage,
-      positionAmount,
-      positionDebt,
-      slippageTolerance
-    } = args;
-    const query = {
-      market,
-      decrease_amount: decreaseAmount.toString(),
-      collateral_token: collateralToken,
-      position_token: positionToken,
-      leverage,
-      position_amount: positionAmount.toString(),
-      position_debt: positionDebt.toString()
-    };
-    if (slippageTolerance) {
-      query.slippage_tolerance = slippageTolerance;
-    }
-    const url = this.appendUrlSearchParams(this.buildURL(`quotes/decrease-spot-position`), query);
-    return await this.httpRequest(url, DecreaseSpotPositionQuote, {
-      signal: config?.abortSignal
-    });
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/message_event) */
+  get onmessage() {
+    return __privateGet(this, _onMessage);
   }
-  async getCloseSpotPositionQuote(args, config) {
-    const { market, decreasePercent, collateralToken, positionToken, positionAmount, positionDebt, slippageTolerance } = args;
-    const query = {
-      market,
-      decrease_percent: decreasePercent,
-      collateral_token: collateralToken,
-      position_token: positionToken,
-      position_amount: positionAmount.toString(),
-      position_debt: positionDebt.toString()
-    };
-    if (slippageTolerance) {
-      query.slippage_tolerance = slippageTolerance;
-    }
-    const url = this.appendUrlSearchParams(this.buildURL(`quotes/close-spot-position`), query);
-    return await this.httpRequest(url, CloseSpotPositionQuote, {
-      signal: config?.abortSignal
-    });
+  set onmessage(value) {
+    __privateSet(this, _onMessage, value);
   }
-  async getTradableAmount(args, config) {
-    const { market, collateralToken, positionToken, availableBalance, leverage, positionAmount, increase } = args;
-    const url = this.appendUrlSearchParams(this.buildURL(`quotes/tradable-amount`), {
-      market,
-      collateral_token: collateralToken,
-      position_token: positionToken,
-      available_balance: availableBalance.toString(),
-      leverage,
-      position_amount: positionAmount.toString(),
-      increase
-    });
-    return await this.httpRequest(url, TradableAmount, {
-      signal: config?.abortSignal
-    });
+  /** [MDN Reference](https://developer.mozilla.org/docs/Web/API/EventSource/open_event) */
+  get onopen() {
+    return __privateGet(this, _onOpen);
   }
-  async getUpdatesStream() {
-    const url = this.buildURL(`streams/sse`);
-    return new EventSource(url);
+  set onopen(value) {
+    __privateSet(this, _onOpen, value);
   }
-  async updateStreamSubscription(streamId, subscription) {
-    const url = this.buildURL(`streams/${streamId}/subscription`);
-    const body = JSON.stringify((0, import_snakecase_keys.default)(subscription, { deep: true }));
-    return await this.httpRequest(url, UpdateStreamSubscriptionResult, { method: "PUT", body });
+  addEventListener(type, listener, options) {
+    const listen = listener;
+    super.addEventListener(type, listen, options);
   }
-  /* Utility functions */
-  buildURL(endpoint) {
-    return `${this.baseURL}${this.baseURL.endsWith("/") ? "" : "/"}v1/${endpoint}`;
+  removeEventListener(type, listener, options) {
+    const listen = listener;
+    super.removeEventListener(type, listen, options);
   }
-  appendUrlSearchParams(url, params) {
-    const urlSearchParams = new URLSearchParams();
-    Object.entries(params).forEach(([key, value]) => {
-      if (value !== void 0) {
-        urlSearchParams.append(key, String(value));
-      }
-    });
-    if (urlSearchParams.size > 0) {
-      return `${url}?${urlSearchParams.toString()}`;
-    }
-    return url;
+  /**
+   * 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));
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+_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;
+}
+export {
+  LeaderboardPeriod,
+  LeaderboardSortBy,
+  LimitOrderStatus,
+  LpPositionsHistoryQueryFilter,
   NotificationAction,
   NotificationEntity,
+  OrderHistoryStatus,
+  OrderHistoryType,
+  OrderHistoryUIDirection,
   PoolProvider,
   PoolSubscriptionTopic,
-  ProviderFilter,
-  TunaApiClient,
-  TunaPositionState,
+  StakingPositionActionType,
+  TradeHistoryAction,
+  TradeHistoryUIDirection,
+  TunaLpPositionAutoCompound,
+  TunaLpPositionAutoCompounding,
+  TunaLpPositionLimitOrderSwap,
+  TunaLpPositionRebalance,
+  TunaLpPositionsActionType,
+  TunaPositionDtoState,
+  TunaPositionMarketMaker,
+  TunaPositionPoolToken,
+  TunaSpotPositionDtoState,
   WalletSubscriptionTopic,
-  schemas
-});
+  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
+};