@crypticdot/defituna-api 1.10.15 → 3.0.0

package/dist/index.mjs

@@ -1,1511 +0,0 @@
-var __defProp = Object.defineProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-
-// src/client/client.ts
-import camelcaseKeys from "camelcase-keys";
-import snakecaseKeys from "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
-});
-import { z as z11 } from "zod";
-
-// src/client/schemas/basic.ts
-import { z } from "zod";
-var AmountWithUsdSchema = z.object({
-  amount: z.coerce.bigint(),
-  usd: z.number()
-});
-var AmountWithoutUsdSchema = z.object({
-  amount: z.coerce.bigint()
-});
-var TokensPnlSchema = z.object({
-  amount: z.coerce.bigint(),
-  rate: z.number()
-});
-var UsdPnlSchema = z.object({
-  amount: z.number(),
-  rate: z.number()
-});
-
-// src/client/schemas/pool.ts
-import z3 from "zod";
-
-// src/client/schemas/mint.ts
-import { z as z2 } from "zod";
-var Mint = z2.object({
-  address: z2.string(),
-  symbol: z2.string(),
-  name: z2.string(),
-  logo: z2.string(),
-  decimals: z2.number()
-});
-
-// src/client/schemas/pool.ts
-var PoolProvider = {
-  ORCA: "orca",
-  FUSION: "fusion"
-};
-var PoolProviderSchema = z3.enum([PoolProvider.ORCA, ...Object.values(PoolProvider)]);
-var Pool = z3.object({
-  address: z3.string(),
-  provider: PoolProviderSchema,
-  mintA: Mint,
-  mintB: Mint,
-  tokenAVault: z3.string(),
-  tokenBVault: z3.string(),
-  tickSpacing: z3.number(),
-  feeRate: z3.number(),
-  protocolFeeRate: z3.number(),
-  olpFeeRate: z3.nullable(z3.number()),
-  liquidity: z3.coerce.bigint(),
-  sqrtPrice: z3.coerce.bigint(),
-  price: z3.number(),
-  tickCurrentIndex: z3.number(),
-  stats: z3.optional(
-    z3.nullable(
-      z3.object({
-        tvlUsd: z3.coerce.number(),
-        groups: z3.object({
-          "24h": z3.optional(
-            z3.nullable(
-              z3.object({
-                volumeUsd: z3.number(),
-                feesUsd: z3.number(),
-                priceChange: z3.number()
-              })
-            )
-          )
-        })
-      })
-    )
-  )
-});
-
-// src/client/schemas/state_snapshot.ts
-import z10 from "zod";
-
-// src/client/schemas/limit_orders.ts
-import { z as z4 } from "zod";
-var LimitOrderState = {
-  OPEN: "open",
-  PARTIALLY_FILLED: "partially_filled",
-  FILLED: "filled",
-  COMPLETE: "complete",
-  CANCELLED: "cancelled"
-};
-var LimitOrderStateSchema = z4.enum([LimitOrderState.OPEN, ...Object.values(LimitOrderState)]);
-var LimitOrder = z4.object({
-  address: z4.string(),
-  orderMint: z4.string(),
-  authority: z4.string(),
-  pool: Pool,
-  state: LimitOrderStateSchema,
-  aToB: z4.boolean(),
-  tickIndex: z4.number(),
-  fillRatio: z4.number(),
-  openTxSignature: z4.string(),
-  closeTxSignature: z4.nullable(z4.string()),
-  amountIn: AmountWithUsdSchema,
-  amountOut: AmountWithUsdSchema,
-  openedAt: z4.coerce.date(),
-  closedAt: z4.nullable(z4.coerce.date())
-});
-
-// src/client/schemas/lp_positions.ts
-import z6 from "zod";
-
-// src/client/schemas/positions_shared.ts
-import z5 from "zod";
-var TunaPositionPoolToken = {
-  A: "a",
-  B: "b"
-};
-var TunaPositionPoolTokenSchema = z5.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 = z6.enum(Object.values(LpPositionLimitOrderSwap));
-var LpPositionAutoCompoundSchema = z6.enum(Object.values(LpPositionAutoCompound));
-var LpPositionRebalanceSchema = z6.enum(Object.values(LpPositionRebalance));
-var LpPositionsActionTypeSchema = z6.enum(Object.values(LpPositionsActionType));
-var TunaPositionState = {
-  OPEN: "open",
-  LIQUIDATED: "liquidated",
-  CLOSED_BY_LIMIT_ORDER: "closed_by_limit_order",
-  CLOSED: "closed"
-};
-var TunaPositionStateSchema = z6.enum([TunaPositionState.OPEN, ...Object.values(TunaPositionState)]);
-var TunaLpPositionAutoCompounding = {
-  WITH_LEVERAGE: "with_leverage",
-  WITHOUT_LEVERAGE: "without_leverage"
-};
-var TunaLpPositionAutoCompoundingSchema = z6.enum(
-  Object.values(TunaLpPositionAutoCompounding)
-);
-var TunaPositionTokenPnlSchema = z6.object({
-  amount: z6.coerce.bigint(),
-  bps: z6.number()
-});
-var TunaLpPositionFlagsSchema = z6.object({
-  lowerLimitOrderSwapToToken: z6.nullable(TunaPositionPoolTokenSchema),
-  upperLimitOrderSwapToToken: z6.nullable(TunaPositionPoolTokenSchema),
-  autoCompounding: z6.nullable(TunaLpPositionAutoCompoundingSchema),
-  autoRebalancing: z6.boolean()
-});
-var TunaLpPositionDtoSchema = z6.object({
-  address: z6.string(),
-  authority: z6.string(),
-  version: z6.number(),
-  state: TunaPositionStateSchema,
-  positionMint: z6.string(),
-  liquidity: z6.coerce.bigint(),
-  tickLowerIndex: z6.number(),
-  tickUpperIndex: z6.number(),
-  lowerLimitOrderPrice: z6.number(),
-  upperLimitOrderPrice: z6.number(),
-  entryPrice: z6.number(),
-  flags: TunaLpPositionFlagsSchema,
-  pool: Pool,
-  marketMaker: PoolProviderSchema,
-  depositedCollateralA: AmountWithUsdSchema,
-  depositedCollateralB: AmountWithUsdSchema,
-  leverage: z6.number(),
-  maxLeverage: z6.number(),
-  liquidationPriceLower: z6.number(),
-  liquidationPriceUpper: z6.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: z6.coerce.date(),
-  closedAt: z6.nullable(z6.coerce.date())
-});
-var TunaLpPositionHistorical = z6.object({
-  positionAddress: z6.string(),
-  authority: z6.string(),
-  pool: z6.string(),
-  state: TunaPositionStateSchema,
-  lowerPrice: z6.number(),
-  upperPrice: z6.number(),
-  lowerLimitOrder: z6.number().nullable(),
-  upperLimitOrder: z6.number().nullable(),
-  marketMaker: PoolProviderSchema,
-  openedAt: z6.coerce.date(),
-  closedAt: z6.coerce.date().nullable(),
-  totalValueUsd: z6.number(),
-  leverage: z6.number(),
-  initialLeverage: z6.number(),
-  totalDepositUsd: z6.number(),
-  totalWithdrawnUsd: z6.number(),
-  feesSumUsd: z6.number(),
-  closedPnlSumUsd: z6.number(),
-  entryPrice: z6.number(),
-  exitPrice: z6.number().nullable()
-});
-var TunaPositionLegacy = z6.object({
-  address: z6.string(),
-  authority: z6.string(),
-  version: z6.number(),
-  state: TunaPositionStateSchema,
-  positionMint: z6.string(),
-  liquidity: z6.coerce.bigint(),
-  tickLowerIndex: z6.number(),
-  tickUpperIndex: z6.number(),
-  entrySqrtPrice: z6.coerce.bigint(),
-  lowerLimitOrderSqrtPrice: z6.coerce.bigint(),
-  upperLimitOrderSqrtPrice: z6.coerce.bigint(),
-  flags: z6.number(),
-  pool: z6.string(),
-  poolSqrtPrice: z6.coerce.bigint(),
-  depositedCollateralA: AmountWithoutUsdSchema,
-  depositedCollateralB: AmountWithoutUsdSchema,
-  depositedCollateralUsd: z6.object({
-    amount: z6.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: z6.coerce.date(),
-  updatedAtSlot: z6.coerce.bigint(),
-  closedAt: z6.nullable(z6.coerce.date())
-});
-var TunaLpPositionParameters = z6.object({
-  lowerPrice: z6.number(),
-  upperPrice: z6.number(),
-  lowerLimitOrder: z6.number().nullable(),
-  upperLimitOrder: z6.number().nullable(),
-  lowerLimitOrderSwap: LpPositionLimitOrderSwapSchema,
-  upperLimitOrderSwap: LpPositionLimitOrderSwapSchema,
-  autoCompound: LpPositionAutoCompoundSchema,
-  rebalance: LpPositionRebalanceSchema,
-  rebalanceThresholdTicks: z6.number()
-});
-var TunaLpPositionValue = z6.object({
-  totalValueA: z6.number(),
-  totalValueB: z6.number(),
-  totalValueUsd: z6.number(),
-  loanFundsA: z6.number(),
-  loanFundsB: z6.number(),
-  loanFundsUsd: z6.number(),
-  leverage: z6.number()
-});
-var TunaLpPositionTransfer = z6.object({
-  amountA: z6.number(),
-  amountB: z6.number(),
-  amountUsd: z6.number()
-});
-var TunaLpPositionTokenPrices = z6.object({
-  tokenPriceA: z6.number(),
-  tokenPriceB: z6.number()
-});
-var TunaLpPositionActionOpen = z6.object({
-  parameters: TunaLpPositionParameters
-});
-var TunaLpPositionActionClose = z6.object({
-  toOwner: TunaLpPositionTransfer.nullable(),
-  prices: TunaLpPositionTokenPrices.nullable()
-});
-var TunaLpPositionActionIncreaseLiquidity = z6.object({
-  fromPosition: TunaLpPositionValue.nullable(),
-  toPosition: TunaLpPositionValue,
-  fromOwner: TunaLpPositionTransfer,
-  fromLending: TunaLpPositionTransfer,
-  protocolFees: TunaLpPositionTransfer,
-  prices: TunaLpPositionTokenPrices
-});
-var TunaLpPositionActionDecreaseLiquidity = z6.object({
-  withdrawPercent: z6.number(),
-  closedPnlUsd: z6.number(),
-  fromPosition: TunaLpPositionValue,
-  toPosition: TunaLpPositionValue.nullable(),
-  toOwner: TunaLpPositionTransfer,
-  toLending: TunaLpPositionTransfer,
-  collectedFees: TunaLpPositionTransfer,
-  prices: TunaLpPositionTokenPrices
-});
-var TunaLpPositionActionLiquidate = z6.object({
-  withdrawPercent: z6.number(),
-  fromPosition: TunaLpPositionValue,
-  toLending: TunaLpPositionTransfer,
-  protocolFees: TunaLpPositionTransfer,
-  prices: TunaLpPositionTokenPrices
-});
-var TunaLpPositionActionRepayDebt = z6.object({
-  fromPosition: TunaLpPositionValue,
-  toPosition: TunaLpPositionValue,
-  fromOwner: TunaLpPositionTransfer,
-  toLending: TunaLpPositionTransfer,
-  prices: TunaLpPositionTokenPrices
-});
-var TunaLpPositionActionCollectFees = z6.object({
-  closedPnlUsd: z6.number(),
-  position: TunaLpPositionValue,
-  collectedFees: TunaLpPositionTransfer,
-  toOwner: TunaLpPositionTransfer,
-  prices: TunaLpPositionTokenPrices
-});
-var TunaLpPositionActionCollectAndCompoundFees = z6.object({
-  fromPosition: TunaLpPositionValue,
-  toPosition: TunaLpPositionValue,
-  collectedFees: TunaLpPositionTransfer,
-  fromLending: TunaLpPositionTransfer,
-  protocolFees: TunaLpPositionTransfer,
-  prices: TunaLpPositionTokenPrices
-});
-var TunaLpPositionActionParametersUpdate = z6.object({
-  fromParameters: TunaLpPositionParameters,
-  toParameters: TunaLpPositionParameters
-});
-var TunaLpPositionAction = z6.object({
-  action: LpPositionsActionTypeSchema,
-  txSignature: z6.string(),
-  txTimestamp: z6.coerce.date(),
-  data: z6.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: z6.number().optional(),
-    /** defined for: DecreaseLiquidity, CollectFees */
-    closedPnlUsd: z6.number().optional()
-  })
-});
-
-// src/client/schemas/market.ts
-import { z as z7 } from "zod";
-var Market = z7.object({
-  address: z7.string(),
-  addressLookupTable: z7.string(),
-  maxLeverage: z7.number(),
-  maxSwapSlippage: z7.number(),
-  protocolFee: z7.number(),
-  protocolFeeOnCollateral: z7.number(),
-  liquidationFee: z7.number(),
-  liquidationThreshold: z7.number(),
-  oraclePriceDeviationThreshold: z7.number(),
-  rebalanceProtocolFee: z7.number(),
-  borrowedFundsA: AmountWithUsdSchema,
-  borrowedFundsB: AmountWithUsdSchema,
-  borrowLimitA: AmountWithUsdSchema,
-  borrowLimitB: AmountWithUsdSchema,
-  maxSpotPositionSizeA: AmountWithUsdSchema,
-  maxSpotPositionSizeB: AmountWithUsdSchema,
-  pool: Pool,
-  disabled: z7.boolean(),
-  createdAt: z7.coerce.date()
-});
-
-// src/client/schemas/order_book.ts
-import z8 from "zod";
-var OrderBookEntry = z8.object({
-  concentratedAmount: z8.coerce.bigint(),
-  concentratedAmountQuote: z8.coerce.bigint(),
-  concentratedTotal: z8.coerce.bigint(),
-  concentratedTotalQuote: z8.coerce.bigint(),
-  limitAmount: z8.coerce.bigint(),
-  limitAmountQuote: z8.coerce.bigint(),
-  limitTotal: z8.coerce.bigint(),
-  limitTotalQuote: z8.coerce.bigint(),
-  price: z8.number(),
-  askSide: z8.boolean()
-});
-var OrderBook = z8.object({
-  entries: OrderBookEntry.array(),
-  poolPrice: z8.number(),
-  poolAddress: z8.string()
-});
-
-// src/client/schemas/spot_positions.ts
-import { z as z9 } from "zod";
-var TunaSpotPositionState = {
-  OPEN: "open",
-  CLOSED: "closed"
-};
-var TunaSpotPositionStateSchema = z9.enum([
-  TunaSpotPositionState.OPEN,
-  ...Object.values(TunaSpotPositionState)
-]);
-var TunaSpotPosition = z9.object({
-  address: z9.string(),
-  authority: z9.string(),
-  version: z9.number(),
-  state: TunaSpotPositionStateSchema,
-  lowerLimitOrderPrice: z9.number(),
-  upperLimitOrderPrice: z9.number(),
-  entryPrice: z9.number(),
-  pool: Pool,
-  positionToken: TunaPositionPoolTokenSchema,
-  collateralToken: TunaPositionPoolTokenSchema,
-  marketMaker: PoolProviderSchema,
-  depositedCollateral: AmountWithUsdSchema,
-  initialDebt: AmountWithUsdSchema,
-  currentDebt: AmountWithUsdSchema,
-  total: AmountWithUsdSchema,
-  leverage: z9.number(),
-  maxLeverage: z9.number(),
-  liquidationPrice: z9.number(),
-  pnlUsd: UsdPnlSchema,
-  openedAt: z9.coerce.date(),
-  closedAt: z9.nullable(z9.coerce.date())
-});
-var IncreaseSpotPositionQuote = z9.object({
-  /** Required collateral amount */
-  collateralAmount: z9.coerce.bigint(),
-  /** Required amount to borrow */
-  borrowAmount: z9.coerce.bigint(),
-  /** Estimated position size in the position token. */
-  estimatedAmount: z9.coerce.bigint(),
-  /** Swap input amount. */
-  swapInputAmount: z9.coerce.bigint(),
-  /** Minimum swap output amount according to the provided slippage. */
-  minSwapOutputAmount: z9.coerce.bigint(),
-  /** Protocol fee in token A */
-  protocolFeeA: z9.coerce.bigint(),
-  /** Protocol fee in token B */
-  protocolFeeB: z9.coerce.bigint(),
-  /** Price impact in percents */
-  priceImpact: z9.number(),
-  /** Liquidation price */
-  liquidationPrice: z9.number()
-});
-var DecreaseSpotPositionQuote = z9.object({
-  /** Confirmed position decrease percentage (100% = 1.0) */
-  decreasePercent: z9.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: z9.coerce.bigint(),
-  /**  Estimated total amount of the adjusted position */
-  estimatedAmount: z9.coerce.bigint(),
-  /** Estimated amount of the withdrawn collateral */
-  estimatedWithdrawnCollateral: z9.coerce.bigint(),
-  /** Price impact in percents */
-  priceImpact: z9.number(),
-  /** Liquidation price */
-  liquidationPrice: z9.number()
-});
-var CloseSpotPositionQuote = z9.object({
-  /** Position decrease percentage */
-  decreasePercent: z9.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: z9.coerce.bigint(),
-  /** Estimated amount of the withdrawn collateral */
-  estimatedWithdrawnCollateral: z9.coerce.bigint(),
-  /** Price impact in percents */
-  priceImpact: z9.number()
-});
-
-// src/client/schemas/state_snapshot.ts
-var StateSnapshot = z10.object({
-  slot: z10.coerce.bigint(),
-  blockTime: z10.coerce.date(),
-  markets: z10.optional(z10.array(Market)),
-  tunaSpotPositions: z10.optional(z10.array(TunaSpotPosition)),
-  tunaLpPositions: z10.optional(z10.array(TunaLpPositionDtoSchema)),
-  fusionLimitOrders: z10.optional(z10.array(LimitOrder)),
-  orderBooks: z10.optional(z10.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 NotificationAction = {
-  CREATE: "create",
-  UPDATE: "update"
-};
-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 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 OrderHistoryStatus = {
-  OPEN: "open",
-  PARTIALLY_FILLED: "partially_filled",
-  FILLED: "filled",
-  CANCELLED: "cancelled",
-  CLAIMED: "claimed",
-  REJECTED: "rejected"
-};
-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"
-};
-var PoolSubscriptionTopic = {
-  ORDER_BOOK: "order_book",
-  POOL_SWAPS: "pool_swaps"
-};
-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 = z11.enum([NotificationEntity.POOL_SWAP, ...Object.values(NotificationEntity)]);
-var NotificationActionSchema = z11.enum([NotificationAction.CREATE, ...Object.values(NotificationAction)]);
-var TradeHistoryActionSchema = z11.enum([TradeHistoryAction.SWAP, ...Object.values(TradeHistoryAction)]);
-var TradeHistoryUIDirectionSchema = z11.enum([
-  TradeHistoryUIDirection.BUY,
-  ...Object.values(TradeHistoryUIDirection)
-]);
-var OrderHistoryOrderTypeSchema = z11.enum([
-  OrderHistoryOrderType.MARKET,
-  ...Object.values(OrderHistoryOrderType)
-]);
-var OrderHistoryStatusSchema = z11.enum([OrderHistoryStatus.OPEN, ...Object.values(OrderHistoryStatus)]);
-var OrderHistoryUIDirectionSchema = z11.enum([
-  OrderHistoryUIDirection.BUY,
-  ...Object.values(OrderHistoryUIDirection)
-]);
-var StakingPositionHistoryActionTypeSchema = z11.enum([
-  StakingPositionHistoryActionType.STAKE,
-  ...Object.values(StakingPositionHistoryActionType)
-]);
-var PoolSubscriptionTopicSchema = z11.enum([
-  PoolSubscriptionTopic.ORDER_BOOK,
-  ...Object.values(PoolSubscriptionTopic)
-]);
-var WalletSubscriptionTopicSchema = z11.enum([
-  WalletSubscriptionTopic.TUNA_POSITIONS,
-  ...Object.values(WalletSubscriptionTopic)
-]);
-var PaginationMeta = z11.object({
-  total: z11.number()
-});
-var TokenOraclePrice = z11.object({
-  mint: z11.string(),
-  price: z11.coerce.bigint(),
-  decimals: z11.number(),
-  time: z11.coerce.date()
-});
-var Vault = z11.object({
-  address: z11.string(),
-  mint: z11.string(),
-  depositedFunds: AmountWithUsdSchema,
-  borrowedFunds: AmountWithUsdSchema,
-  supplyLimit: AmountWithUsdSchema,
-  borrowedShares: z11.coerce.bigint(),
-  depositedShares: z11.coerce.bigint(),
-  supplyApy: z11.number(),
-  borrowApy: z11.number(),
-  interestRate: z11.coerce.bigint(),
-  utilization: z11.number(),
-  pythOracleFeedId: z11.string(),
-  pythOraclePriceUpdate: z11.string()
-});
-var VaultHistoricalStats = z11.object({
-  date: z11.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 z11.NEVER;
-  }, z11.date()),
-  supply: AmountWithUsdSchema,
-  borrow: AmountWithUsdSchema,
-  supplyApy: z11.number(),
-  borrowApr: z11.number()
-});
-var Tick = z11.object({
-  index: z11.number(),
-  liquidity: z11.coerce.bigint()
-});
-var PoolTicks = z11.object({
-  tickSpacing: z11.number(),
-  ticks: Tick.array()
-});
-var LendingPosition = z11.object({
-  address: z11.string(),
-  authority: z11.string(),
-  mint: z11.string(),
-  vault: z11.string(),
-  shares: z11.coerce.bigint(),
-  funds: AmountWithUsdSchema,
-  earned: AmountWithUsdSchema
-});
-var PoolSwap = z11.object({
-  id: z11.string(),
-  amountIn: z11.coerce.bigint(),
-  amountOut: z11.coerce.bigint(),
-  amountUsd: z11.number(),
-  aToB: z11.boolean(),
-  pool: z11.string(),
-  time: z11.coerce.date()
-});
-var TradeHistoryEntry = z11.object({
-  // Internal entry ID
-  id: z11.string(),
-  pool: Pool,
-  authority: z11.string(),
-  aToB: z11.boolean(),
-  // Trade action which created entry
-  action: TradeHistoryActionSchema,
-  // Trade direction formatted for ui display
-  uiDirection: TradeHistoryUIDirectionSchema,
-  // Trade price formatted for ui display
-  uiPrice: z11.number(),
-  baseToken: AmountWithUsdSchema,
-  quoteToken: AmountWithUsdSchema,
-  fee: AmountWithUsdSchema,
-  pnl: z11.nullable(
-    z11.object({
-      usd: z11.number(),
-      bps: z11.number()
-    })
-  ),
-  txSignature: z11.nullable(z11.string()),
-  positionAddress: z11.nullable(z11.string()),
-  slot: z11.coerce.bigint(),
-  ts: z11.coerce.date()
-});
-var OrderHistoryEntry = z11.object({
-  // Internal entry ID
-  id: z11.string(),
-  pool: Pool,
-  authority: z11.string(),
-  orderType: OrderHistoryOrderTypeSchema,
-  isReduceOnly: z11.nullable(z11.boolean()),
-  aToB: z11.boolean(),
-  uiDirection: OrderHistoryUIDirectionSchema,
-  uiPrice: z11.nullable(z11.number()),
-  uiExecutionPrice: z11.nullable(z11.number()),
-  status: OrderHistoryStatusSchema,
-  baseToken: AmountWithUsdSchema,
-  quoteToken: AmountWithUsdSchema,
-  baseTokenConsumedAmount: z11.nullable(AmountWithUsdSchema),
-  quoteTokenFilledAmount: z11.nullable(AmountWithUsdSchema),
-  txSignature: z11.nullable(z11.string()),
-  positionAddress: z11.nullable(z11.string()),
-  slot: z11.coerce.bigint(),
-  ts: z11.coerce.date()
-});
-var StakingTreasury = z11.object({
-  address: z11.string(),
-  stakedTokenMint: z11.string(),
-  rewardTokenMint: z11.string(),
-  apy: z11.number(),
-  uniqueStakers: z11.number(),
-  totalStaked: AmountWithUsdSchema,
-  totalReward: AmountWithUsdSchema,
-  unstakeCooldownSeconds: z11.number(),
-  isStakingEnabled: z11.boolean(),
-  isUnstakingEnabled: z11.boolean(),
-  isWithdrawEnabled: z11.boolean()
-});
-var StakingPosition = z11.object({
-  address: z11.string(),
-  owner: z11.string(),
-  staked: AmountWithUsdSchema,
-  unstaked: AmountWithUsdSchema,
-  claimedReward: AmountWithUsdSchema,
-  unclaimedReward: AmountWithUsdSchema,
-  rank: z11.nullable(z11.number()),
-  vesting: z11.object({
-    locked: AmountWithUsdSchema,
-    unlocked: AmountWithUsdSchema,
-    unlockRate: z11.coerce.bigint(),
-    unlockEverySeconds: z11.number(),
-    unlockCliffSeconds: z11.number(),
-    lockedAt: z11.nullable(z11.coerce.date())
-  }),
-  lastUnstakedAt: z11.nullable(z11.coerce.date()),
-  withdrawAvailableAt: z11.nullable(z11.coerce.date())
-});
-var StakingLeaderboardPosition = z11.object({
-  rank: z11.number(),
-  address: z11.string(),
-  owner: z11.string(),
-  staked: AmountWithUsdSchema
-});
-var StakingLeaderboardPage = z11.object({
-  data: StakingLeaderboardPosition.array(),
-  meta: PaginationMeta
-});
-var StakingPositionHistoryAction = z11.object({
-  position: z11.string(),
-  action: StakingPositionHistoryActionTypeSchema,
-  txSignature: z11.string(),
-  amount: z11.coerce.bigint(),
-  time: z11.coerce.date()
-});
-var PoolPriceCandle = z11.object({
-  time: z11.number(),
-  open: z11.number(),
-  close: z11.number(),
-  high: z11.number(),
-  low: z11.number(),
-  volume: z11.number()
-});
-var FeesStatsGroup = z11.object({
-  time: z11.coerce.date(),
-  addLiquidityFees: z11.number(),
-  limitOrderFees: z11.number(),
-  yieldCompoundingFees: z11.number(),
-  liquidationFees: z11.number(),
-  totalLiquidationsNetworkFees: z11.number(),
-  totalLimitOrdersNetworkFees: z11.number(),
-  totalYieldCompoundingNetworkFees: z11.number(),
-  failedNetworkFees: z11.number(),
-  processedNetworkFees: z11.number(),
-  totalCollectedFees: z11.number(),
-  totalNetworkFees: z11.number(),
-  jitoLiquidationFees: z11.number(),
-  jitoLimitOrderFees: z11.number(),
-  jitoYieldCompoundingFees: z11.number(),
-  runningAddLiquidityFees: z11.number(),
-  runningLimitOrderFees: z11.number(),
-  runningYieldCompoundingFees: z11.number(),
-  runningLiquidationFees: z11.number(),
-  runningTotalLiquidationsNetworkFees: z11.number(),
-  runningTotalLimitOrdersNetworkFees: z11.number(),
-  runningTotalYieldCompoundingNetworkFees: z11.number(),
-  runningFailedNetworkFees: z11.number(),
-  runningProcessedNetworkFees: z11.number(),
-  runningJitoLiquidationFees: z11.number(),
-  runningJitoLimitOrderFees: z11.number(),
-  runningJitoYieldCompoundingFees: z11.number(),
-  runningTotalCollectedFees: z11.number(),
-  runningTotalNetworkFees: z11.number()
-});
-var StakingRevenueStatsGroup = z11.object({
-  time: z11.coerce.date(),
-  totalDepositsUsd: z11.number(),
-  totalDepositsSol: z11.coerce.bigint(),
-  runningTotalDepositsUsd: z11.number(),
-  runningTotalDepositsSol: z11.coerce.bigint()
-});
-var SwapQuoteByInput = z11.object({
-  estimatedAmountOut: z11.coerce.bigint(),
-  minAmountOut: z11.coerce.bigint(),
-  feeAmount: z11.coerce.bigint(),
-  feeUsd: z11.number(),
-  /** Price impact in percents */
-  priceImpact: z11.number()
-});
-var SwapQuoteByOutput = z11.object({
-  estimatedAmountIn: z11.coerce.bigint(),
-  maxAmountIn: z11.coerce.bigint(),
-  feeAmount: z11.coerce.bigint(),
-  feeUsd: z11.number(),
-  /** Price impact in percents */
-  priceImpact: z11.number()
-});
-var LimitOrderQuoteByInput = z11.object({
-  amountOut: z11.coerce.bigint()
-});
-var LimitOrderQuoteByOutput = z11.object({
-  amountIn: z11.coerce.bigint()
-});
-var TradableAmount = AmountWithUsdSchema;
-var UpdateStreamSubscriptionResult = z11.object({
-  status: z11.string()
-});
-var createNotificationSchema = (dataSchema, metaSchema) => z11.object({
-  entity: NotificationEntitySchema,
-  action: NotificationActionSchema,
-  data: dataSchema,
-  id: z11.string(),
-  authority: z11.nullish(z11.string()),
-  ...metaSchema ? { meta: metaSchema } : { meta: z11.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;
-    }
-    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 }
-      });
-      clearTimeout(abort);
-      if (!response.ok) {
-        const errorBody = await response.json();
-        throw errorBody;
-      }
-      const data = await response.json();
-      const transformed = camelcaseKeys(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;
-    }
-  }
-  /* Endpoints */
-  async getMints() {
-    const url = this.buildURL("mints");
-    return await this.httpRequest(url, Mint.array());
-  }
-  async getMint(mintAddress) {
-    const url = this.buildURL(`mints/${mintAddress}`);
-    return await this.httpRequest(url, Mint);
-  }
-  async getMarkets() {
-    const url = this.buildURL("markets");
-    return await this.httpRequest(url, Market.array());
-  }
-  async getMarket(marketAddress) {
-    const url = this.buildURL(`markets/${marketAddress}`);
-    return await this.httpRequest(url, Market);
-  }
-  async getOraclePrices() {
-    const url = this.buildURL("oracle-prices");
-    return await this.httpRequest(url, TokenOraclePrice.array());
-  }
-  async getOraclePrice(mintAddress) {
-    const url = this.buildURL(`oracle-prices/${mintAddress}`);
-    return await this.httpRequest(url, TokenOraclePrice);
-  }
-  async getVaults() {
-    const url = this.buildURL("vaults");
-    return await this.httpRequest(url, Vault.array());
-  }
-  async getVault(vaultAddress) {
-    const url = this.buildURL(`vaults/${vaultAddress}`);
-    return await this.httpRequest(url, Vault);
-  }
-  /**
-   *  Returns vault historical data for selected time interval.
-   *
-   *  Example usage: getVaultHistory('H3ifgix98vzi3yCPbmZDLTheeTRf2jykXx8FpY5L7Sfd', '2025-03-10', '2025-04-10')
-   */
-  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);
-  }
-  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);
-  }
-  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());
-  }
-  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(",");
-      }
-      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}/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]
-    });
-    return await this.httpRequest(url, StakingRevenueStatsGroup.array());
-  }
-  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
-    });
-  }
-  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
-    });
-  }
-  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
-    });
-  }
-  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
-    });
-  }
-  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
-    });
-  }
-  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
-    });
-  }
-  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
-    });
-  }
-  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
-    });
-  }
-  async getUpdatesStream() {
-    const url = this.buildURL(`streams/sse`);
-    return new EventSource(url);
-  }
-  async updateStreamSubscription(streamId, subscription) {
-    const url = this.buildURL(`streams/${streamId}/subscription`);
-    const body = JSON.stringify(snakecaseKeys(subscription, { deep: true }));
-    return await this.httpRequest(url, UpdateStreamSubscriptionResult, { method: "PUT", body });
-  }
-  /* Utility functions */
-  buildURL(endpoint) {
-    return `${this.baseURL}${this.baseURL.endsWith("/") ? "" : "/"}v1/${endpoint}`;
-  }
-  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;
-  }
-};
-export {
-  NotificationAction,
-  NotificationEntity,
-  PoolProvider,
-  PoolSubscriptionTopic,
-  ProviderFilter,
-  TunaApiClient,
-  TunaPositionState,
-  WalletSubscriptionTopic,
-  schemas_exports as schemas
-};