@crypticdot/defituna-api 1.9.0 → 1.10.1

package/dist/index.mjs

@@ -11,6 +11,8 @@ 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,
@@ -23,6 +25,14 @@ __export(schemas_exports, {
   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,
@@ -68,6 +78,7 @@ __export(schemas_exports, {
   SwapQuoteByOutput: () => SwapQuoteByOutput,
   Tick: () => Tick,
   TokenOraclePrice: () => TokenOraclePrice,
+  TokensPnlSchema: () => TokensPnlSchema,
   TradableAmount: () => TradableAmount,
   TradeHistoryAction: () => TradeHistoryAction,
   TradeHistoryActionSchema: () => TradeHistoryActionSchema,
@@ -75,36 +86,505 @@ __export(schemas_exports, {
   TradeHistoryEntryNotification: () => TradeHistoryEntryNotification,
   TradeHistoryUIDirection: () => TradeHistoryUIDirection,
   TradeHistoryUIDirectionSchema: () => TradeHistoryUIDirectionSchema,
-  TunaPosition: () => TunaPosition,
+  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,
+  TunaPositionMintSchema: () => TunaPositionMintSchema,
   TunaPositionNotification: () => TunaPositionNotification,
+  TunaPositionPoolSchema: () => TunaPositionPoolSchema,
+  TunaPositionPoolToken: () => TunaPositionPoolToken,
+  TunaPositionPoolTokenSchema: () => TunaPositionPoolTokenSchema,
   TunaPositionState: () => TunaPositionState,
   TunaPositionStateSchema: () => TunaPositionStateSchema,
+  TunaPositionTokenPnlSchema: () => TunaPositionTokenPnlSchema,
   TunaSpotPosition: () => TunaSpotPosition,
   TunaSpotPositionNotification: () => TunaSpotPositionNotification,
   TunaSpotPositionState: () => TunaSpotPositionState,
   TunaSpotPositionStateSchema: () => TunaSpotPositionStateSchema,
   UpdateStreamSubscriptionResult: () => UpdateStreamSubscriptionResult,
+  UsdPnlSchema: () => UsdPnlSchema,
   Vault: () => Vault,
   VaultHistoricalStats: () => VaultHistoricalStats,
   WalletSubscriptionTopic: () => WalletSubscriptionTopic,
   WalletSubscriptionTopicSchema: () => WalletSubscriptionTopicSchema
 });
+import { z as z7 } from "zod";
+
+// src/client/schemas/basic.ts
 import { z } from "zod";
-var amountWithoutUsd = z.object({
-  amount: z.coerce.bigint()
-});
-var amountWithUsd = z.object({
+var AmountWithUsdSchema = z.object({
   amount: z.coerce.bigint(),
   usd: z.number()
 });
-var tokensPnl = z.object({
+var AmountWithoutUsdSchema = z.object({
+  amount: z.coerce.bigint()
+});
+var TokensPnlSchema = z.object({
   amount: z.coerce.bigint(),
-  bps: z.number()
+  rate: z.number()
 });
-var usdPnl = z.object({
+var UsdPnlSchema = z.object({
   amount: z.number(),
-  bps: z.number()
+  rate: z.number()
+});
+var PoolProvider = {
+  ORCA: "orca",
+  FUSION: "fusion"
+};
+var PoolProviderSchema = z.enum([PoolProvider.ORCA, ...Object.values(PoolProvider)]);
+
+// src/client/schemas/limit_orders.ts
+import { z as z2 } from "zod";
+var LimitOrderState = {
+  OPEN: "open",
+  PARTIALLY_FILLED: "partially_filled",
+  FILLED: "filled",
+  COMPLETE: "complete",
+  CANCELLED: "cancelled"
+};
+var LimitOrderStateSchema = z2.enum([LimitOrderState.OPEN, ...Object.values(LimitOrderState)]);
+var LimitOrder = z2.object({
+  address: z2.string(),
+  mint: z2.string(),
+  pool: z2.string(),
+  state: LimitOrderStateSchema,
+  aToB: z2.boolean(),
+  tickIndex: z2.number(),
+  fillRatio: z2.number(),
+  openTxSignature: z2.string(),
+  closeTxSignature: z2.nullable(z2.string()),
+  amountIn: AmountWithUsdSchema,
+  amountOut: AmountWithUsdSchema,
+  openedAt: z2.coerce.date(),
+  closedAt: z2.nullable(z2.coerce.date())
+});
+
+// src/client/schemas/lp_positions.ts
+import z4 from "zod";
+
+// src/client/schemas/positions_shared.ts
+import z3 from "zod";
+var TunaPositionMintSchema = z3.object({
+  addr: z3.string(),
+  symbol: z3.string(),
+  decimals: z3.number()
+});
+var TunaPositionPoolSchema = z3.object({
+  addr: z3.string(),
+  price: z3.number(),
+  tickSpacing: z3.number()
+});
+var TunaPositionPoolToken = {
+  A: "a",
+  B: "b"
+};
+var TunaPositionPoolTokenSchema = z3.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 = z4.enum(Object.values(LpPositionLimitOrderSwap));
+var LpPositionAutoCompoundSchema = z4.enum(Object.values(LpPositionAutoCompound));
+var LpPositionRebalanceSchema = z4.enum(Object.values(LpPositionRebalance));
+var LpPositionsActionTypeSchema = z4.enum(Object.values(LpPositionsActionType));
+var TunaPositionState = {
+  OPEN: "open",
+  LIQUIDATED: "liquidated",
+  CLOSED_BY_LIMIT_ORDER: "closed_by_limit_order",
+  CLOSED: "closed"
+};
+var TunaPositionStateSchema = z4.enum([TunaPositionState.OPEN, ...Object.values(TunaPositionState)]);
+var TunaLpPositionAutoCompounding = {
+  WITH_LEVERAGE: "with_leverage",
+  WITHOUT_LEVERAGE: "without_leverage"
+};
+var TunaLpPositionAutoCompoundingSchema = z4.enum(
+  Object.values(TunaLpPositionAutoCompounding)
+);
+var TunaPositionTokenPnlSchema = z4.object({
+  amount: z4.coerce.bigint(),
+  bps: z4.number()
+});
+var TunaLpPositionFlagsSchema = z4.object({
+  lowerLimitOrderSwapToToken: z4.nullable(TunaPositionPoolTokenSchema),
+  upperLimitOrderSwapToToken: z4.nullable(TunaPositionPoolTokenSchema),
+  autoCompounding: z4.nullable(TunaLpPositionAutoCompoundingSchema),
+  autoRebalancing: z4.boolean()
+});
+var TunaLpPositionDtoSchema = z4.object({
+  address: z4.string(),
+  authority: z4.string(),
+  version: z4.number(),
+  state: TunaPositionStateSchema,
+  positionMint: z4.string(),
+  liquidity: z4.coerce.bigint(),
+  lowerPrice: z4.number(),
+  upperPrice: z4.number(),
+  lowerLimitOrderPrice: z4.number(),
+  upperLimitOrderPrice: z4.number(),
+  entryPrice: z4.number(),
+  flags: TunaLpPositionFlagsSchema,
+  mintA: TunaPositionMintSchema,
+  mintB: TunaPositionMintSchema,
+  pool: TunaPositionPoolSchema,
+  marketMaker: PoolProviderSchema,
+  depositedCollateralA: AmountWithUsdSchema,
+  depositedCollateralB: AmountWithUsdSchema,
+  leverage: z4.number(),
+  maxLeverage: z4.number(),
+  liquidationPriceLower: z4.number(),
+  liquidationPriceUpper: z4.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: z4.coerce.date(),
+  closedAt: z4.nullable(z4.coerce.date())
+});
+var TunaLpPositionHistorical = z4.object({
+  positionAddress: z4.string(),
+  authority: z4.string(),
+  pool: z4.string(),
+  state: TunaPositionStateSchema,
+  lowerPrice: z4.number(),
+  upperPrice: z4.number(),
+  lowerLimitOrder: z4.number().nullable(),
+  upperLimitOrder: z4.number().nullable(),
+  marketMaker: PoolProviderSchema,
+  openedAt: z4.coerce.date(),
+  closedAt: z4.coerce.date().nullable(),
+  totalValueUsd: z4.number(),
+  leverage: z4.number(),
+  initialLeverage: z4.number(),
+  totalDepositUsd: z4.number(),
+  totalWithdrawnUsd: z4.number(),
+  feesSumUsd: z4.number(),
+  closedPnlSumUsd: z4.number(),
+  entryPrice: z4.number(),
+  exitPrice: z4.number().nullable()
 });
+var TunaPositionLegacy = z4.object({
+  address: z4.string(),
+  authority: z4.string(),
+  version: z4.number(),
+  state: TunaPositionStateSchema,
+  positionMint: z4.string(),
+  liquidity: z4.coerce.bigint(),
+  tickLowerIndex: z4.number(),
+  tickUpperIndex: z4.number(),
+  entrySqrtPrice: z4.coerce.bigint(),
+  lowerLimitOrderSqrtPrice: z4.coerce.bigint(),
+  upperLimitOrderSqrtPrice: z4.coerce.bigint(),
+  flags: z4.number(),
+  pool: z4.string(),
+  poolSqrtPrice: z4.coerce.bigint(),
+  depositedCollateralA: AmountWithoutUsdSchema,
+  depositedCollateralB: AmountWithoutUsdSchema,
+  depositedCollateralUsd: z4.object({
+    amount: z4.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: z4.coerce.date(),
+  updatedAtSlot: z4.coerce.bigint(),
+  closedAt: z4.nullable(z4.coerce.date())
+});
+var TunaLpPositionParameters = z4.object({
+  lowerPrice: z4.number(),
+  upperPrice: z4.number(),
+  lowerLimitOrder: z4.number().nullable(),
+  upperLimitOrder: z4.number().nullable(),
+  lowerLimitOrderSwap: LpPositionLimitOrderSwapSchema,
+  upperLimitOrderSwap: LpPositionLimitOrderSwapSchema,
+  autoCompound: LpPositionAutoCompoundSchema,
+  rebalance: LpPositionRebalanceSchema,
+  rebalanceThresholdTicks: z4.number()
+});
+var TunaLpPositionValue = z4.object({
+  totalValueA: z4.number(),
+  totalValueB: z4.number(),
+  totalValueUsd: z4.number(),
+  loanFundsA: z4.number(),
+  loanFundsB: z4.number(),
+  loanFundsUsd: z4.number(),
+  leverage: z4.number()
+});
+var TunaLpPositionTransfer = z4.object({
+  amountA: z4.number(),
+  amountB: z4.number(),
+  amountUsd: z4.number()
+});
+var TunaLpPositionTokenPrices = z4.object({
+  tokenPriceA: z4.number(),
+  tokenPriceB: z4.number()
+});
+var TunaLpPositionActionOpen = z4.object({
+  parameters: TunaLpPositionParameters
+});
+var TunaLpPositionActionClose = z4.object({
+  toOwner: TunaLpPositionTransfer.nullable(),
+  prices: TunaLpPositionTokenPrices.nullable()
+});
+var TunaLpPositionActionIncreaseLiquidity = z4.object({
+  fromPosition: TunaLpPositionValue.nullable(),
+  toPosition: TunaLpPositionValue,
+  fromOwner: TunaLpPositionTransfer,
+  fromLending: TunaLpPositionTransfer,
+  protocolFees: TunaLpPositionTransfer,
+  prices: TunaLpPositionTokenPrices
+});
+var TunaLpPositionActionDecreaseLiquidity = z4.object({
+  withdrawPercent: z4.number(),
+  closedPnlUsd: z4.number(),
+  fromPosition: TunaLpPositionValue,
+  toPosition: TunaLpPositionValue.nullable(),
+  toOwner: TunaLpPositionTransfer,
+  toLending: TunaLpPositionTransfer,
+  collectedFees: TunaLpPositionTransfer,
+  prices: TunaLpPositionTokenPrices
+});
+var TunaLpPositionActionLiquidate = z4.object({
+  withdrawPercent: z4.number(),
+  fromPosition: TunaLpPositionValue,
+  toLending: TunaLpPositionTransfer,
+  protocolFees: TunaLpPositionTransfer,
+  prices: TunaLpPositionTokenPrices
+});
+var TunaLpPositionActionRepayDebt = z4.object({
+  fromPosition: TunaLpPositionValue,
+  toPosition: TunaLpPositionValue,
+  fromOwner: TunaLpPositionTransfer,
+  toLending: TunaLpPositionTransfer,
+  prices: TunaLpPositionTokenPrices
+});
+var TunaLpPositionActionCollectFees = z4.object({
+  closedPnlUsd: z4.number(),
+  position: TunaLpPositionValue,
+  collectedFees: TunaLpPositionTransfer,
+  toOwner: TunaLpPositionTransfer,
+  prices: TunaLpPositionTokenPrices
+});
+var TunaLpPositionActionCollectAndCompoundFees = z4.object({
+  fromPosition: TunaLpPositionValue,
+  toPosition: TunaLpPositionValue,
+  collectedFees: TunaLpPositionTransfer,
+  fromLending: TunaLpPositionTransfer,
+  protocolFees: TunaLpPositionTransfer,
+  prices: TunaLpPositionTokenPrices
+});
+var TunaLpPositionActionParametersUpdate = z4.object({
+  fromParameters: TunaLpPositionParameters,
+  toParameters: TunaLpPositionParameters
+});
+var TunaLpPositionAction = z4.object({
+  action: LpPositionsActionTypeSchema,
+  txSignature: z4.string(),
+  txTimestamp: z4.coerce.date(),
+  data: z4.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: z4.number().optional(),
+    /** defined for: DecreaseLiquidity, CollectFees */
+    closedPnlUsd: z4.number().optional()
+  })
+});
+
+// src/client/schemas/spot_positions.ts
+import { z as z5 } from "zod";
+var TunaSpotPositionState = {
+  OPEN: "open",
+  CLOSED: "closed"
+};
+var TunaSpotPositionStateSchema = z5.enum([
+  TunaSpotPositionState.OPEN,
+  ...Object.values(TunaSpotPositionState)
+]);
+var TunaSpotPosition = z5.object({
+  address: z5.string(),
+  authority: z5.string(),
+  version: z5.number(),
+  state: TunaSpotPositionStateSchema,
+  lowerLimitOrderPrice: z5.number(),
+  upperLimitOrderPrice: z5.number(),
+  entryPrice: z5.number(),
+  mintA: TunaPositionMintSchema,
+  mintB: TunaPositionMintSchema,
+  pool: TunaPositionPoolSchema,
+  positionToken: TunaPositionPoolToken,
+  collateralToken: TunaPositionPoolToken,
+  marketMaker: PoolProviderSchema,
+  depositedCollateral: AmountWithUsdSchema,
+  initialDebt: AmountWithUsdSchema,
+  currentDebt: AmountWithUsdSchema,
+  total: AmountWithUsdSchema,
+  leverage: z5.number(),
+  maxLeverage: z5.number(),
+  liquidationPrice: z5.number(),
+  pnlUsd: UsdPnlSchema,
+  openedAt: z5.coerce.date(),
+  closedAt: z5.nullable(z5.coerce.date())
+});
+var IncreaseSpotPositionQuote = z5.object({
+  /** Required collateral amount */
+  collateralAmount: z5.coerce.bigint(),
+  /** Required amount to borrow */
+  borrowAmount: z5.coerce.bigint(),
+  /** Estimated position size in the position token. */
+  estimatedAmount: z5.coerce.bigint(),
+  /** Swap input amount. */
+  swapInputAmount: z5.coerce.bigint(),
+  /** Minimum swap output amount according to the provided slippage. */
+  minSwapOutputAmount: z5.coerce.bigint(),
+  /** Protocol fee in token A */
+  protocolFeeA: z5.coerce.bigint(),
+  /** Protocol fee in token B */
+  protocolFeeB: z5.coerce.bigint(),
+  /** Price impact in percents */
+  priceImpact: z5.number(),
+  /** Liquidation price */
+  liquidationPrice: z5.number()
+});
+var DecreaseSpotPositionQuote = z5.object({
+  /** Confirmed position decrease percentage (100% = 1.0) */
+  decreasePercent: z5.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: z5.coerce.bigint(),
+  /**  Estimated total amount of the adjusted position */
+  estimatedAmount: z5.coerce.bigint(),
+  /** Estimated amount of the withdrawn collateral */
+  estimatedWithdrawnCollateral: z5.coerce.bigint(),
+  /** Price impact in percents */
+  priceImpact: z5.number(),
+  /** Liquidation price */
+  liquidationPrice: z5.number()
+});
+var CloseSpotPositionQuote = z5.object({
+  /** Position decrease percentage */
+  decreasePercent: z5.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: z5.coerce.bigint(),
+  /** Estimated amount of the withdrawn collateral */
+  estimatedWithdrawnCollateral: z5.coerce.bigint(),
+  /** Price impact in percents */
+  priceImpact: z5.number()
+});
+
+// src/client/schemas/state_snapshot.ts
+import z6 from "zod";
+var PoolPriceUpdate = z6.object({
+  pool: z6.string(),
+  price: z6.number(),
+  sqrtPrice: z6.coerce.bigint(),
+  time: z6.coerce.date()
+});
+var StateSnapshot = z6.object({
+  slot: z6.coerce.bigint(),
+  blockTime: z6.coerce.date(),
+  poolPrices: z6.optional(z6.record(z6.string(), PoolPriceUpdate)),
+  tunaSpotPositions: z6.optional(z6.array(TunaSpotPosition)),
+  tunaLpPositions: z6.optional(z6.array(TunaLpPositionDtoSchema)),
+  fusionLimitOrders: z6.optional(z6.array(LimitOrder))
+});
+
+// src/client/schemas.ts
 var NotificationEntity = {
   POOL_SWAP: "pool_swap",
   POOL_PRICE: "pool_price",
@@ -122,27 +602,6 @@ var NotificationAction = {
   CREATE: "create",
   UPDATE: "update"
 };
-var PoolProvider = {
-  ORCA: "orca",
-  FUSION: "fusion"
-};
-var TunaPositionState = {
-  OPEN: "open",
-  LIQUIDATED: "liquidated",
-  CLOSED_BY_LIMIT_ORDER: "closed_by_limit_order",
-  CLOSED: "closed"
-};
-var TunaSpotPositionState = {
-  OPEN: "open",
-  CLOSED: "closed"
-};
-var LimitOrderState = {
-  OPEN: "open",
-  PARTIALLY_FILLED: "partially_filled",
-  FILLED: "filled",
-  COMPLETE: "complete",
-  CANCELLED: "cancelled"
-};
 var TradeHistoryAction = {
   SWAP: "swap",
   LIMIT_ORDER_FILL: "limit_order_fill",
@@ -202,99 +661,91 @@ var WalletSubscriptionTopic = {
   TRADE_HISTORY: "trade_history",
   ORDER_HISTORY: "order_history"
 };
-var NotificationEntitySchema = z.enum([NotificationEntity.POOL_SWAP, ...Object.values(NotificationEntity)]);
-var NotificationActionSchema = z.enum([NotificationAction.CREATE, ...Object.values(NotificationAction)]);
-var PoolProviderSchema = z.enum([PoolProvider.ORCA, ...Object.values(PoolProvider)]);
-var TunaPositionStateSchema = z.enum([TunaPositionState.OPEN, ...Object.values(TunaPositionState)]);
-var TunaSpotPositionStateSchema = z.enum([
-  TunaSpotPositionState.OPEN,
-  ...Object.values(TunaSpotPositionState)
-]);
-var LimitOrderStateSchema = z.enum([LimitOrderState.OPEN, ...Object.values(LimitOrderState)]);
-var TradeHistoryActionSchema = z.enum([TradeHistoryAction.SWAP, ...Object.values(TradeHistoryAction)]);
-var TradeHistoryUIDirectionSchema = z.enum([
+var NotificationEntitySchema = z7.enum([NotificationEntity.POOL_SWAP, ...Object.values(NotificationEntity)]);
+var NotificationActionSchema = z7.enum([NotificationAction.CREATE, ...Object.values(NotificationAction)]);
+var TradeHistoryActionSchema = z7.enum([TradeHistoryAction.SWAP, ...Object.values(TradeHistoryAction)]);
+var TradeHistoryUIDirectionSchema = z7.enum([
   TradeHistoryUIDirection.BUY,
   ...Object.values(TradeHistoryUIDirection)
 ]);
-var OrderHistoryOrderTypeSchema = z.enum([
+var OrderHistoryOrderTypeSchema = z7.enum([
   OrderHistoryOrderType.MARKET,
   ...Object.values(OrderHistoryOrderType)
 ]);
-var OrderHistoryStatusSchema = z.enum([OrderHistoryStatus.OPEN, ...Object.values(OrderHistoryStatus)]);
-var OrderHistoryUIDirectionSchema = z.enum([
+var OrderHistoryStatusSchema = z7.enum([OrderHistoryStatus.OPEN, ...Object.values(OrderHistoryStatus)]);
+var OrderHistoryUIDirectionSchema = z7.enum([
   OrderHistoryUIDirection.BUY,
   ...Object.values(OrderHistoryUIDirection)
 ]);
-var StakingPositionHistoryActionTypeSchema = z.enum([
+var StakingPositionHistoryActionTypeSchema = z7.enum([
   StakingPositionHistoryActionType.STAKE,
   ...Object.values(StakingPositionHistoryActionType)
 ]);
-var PoolSubscriptionTopicSchema = z.enum([
+var PoolSubscriptionTopicSchema = z7.enum([
   PoolSubscriptionTopic.ORDER_BOOK,
   ...Object.values(PoolSubscriptionTopic)
 ]);
-var WalletSubscriptionTopicSchema = z.enum([
+var WalletSubscriptionTopicSchema = z7.enum([
   WalletSubscriptionTopic.TUNA_POSITIONS,
   ...Object.values(WalletSubscriptionTopic)
 ]);
-var PaginationMeta = z.object({
-  total: z.number()
+var PaginationMeta = z7.object({
+  total: z7.number()
 });
-var Mint = z.object({
-  symbol: z.string(),
-  mint: z.string(),
-  logo: z.string(),
-  decimals: z.number()
+var Mint = z7.object({
+  symbol: z7.string(),
+  mint: z7.string(),
+  logo: z7.string(),
+  decimals: z7.number()
 });
-var Market = z.object({
-  address: z.string(),
-  addressLookupTable: z.string(),
-  poolAddress: z.string(),
-  poolFeeRate: z.number(),
+var Market = z7.object({
+  address: z7.string(),
+  addressLookupTable: z7.string(),
+  poolAddress: z7.string(),
+  poolFeeRate: z7.number(),
   provider: PoolProviderSchema,
-  maxLeverage: z.number(),
-  maxSwapSlippage: z.number(),
-  protocolFee: z.number(),
-  rebalanceProtocolFee: z.number(),
-  protocolFeeOnCollateral: z.number(),
-  liquidationFee: z.number(),
-  liquidationThreshold: z.number(),
-  oraclePriceDeviationThreshold: z.number(),
-  limitOrderExecutionFee: z.number(),
-  maxSpotPositionSizeA: amountWithUsd,
-  maxSpotPositionSizeB: amountWithUsd,
-  borrowedFundsA: amountWithUsd,
-  borrowedFundsB: amountWithUsd,
-  availableBorrowA: amountWithUsd,
-  availableBorrowB: amountWithUsd,
-  borrowLimitA: amountWithUsd,
-  borrowLimitB: amountWithUsd,
-  disabled: z.boolean(),
-  createdAt: z.coerce.date()
+  maxLeverage: z7.number(),
+  maxSwapSlippage: z7.number(),
+  protocolFee: z7.number(),
+  rebalanceProtocolFee: z7.number(),
+  protocolFeeOnCollateral: z7.number(),
+  liquidationFee: z7.number(),
+  liquidationThreshold: z7.number(),
+  oraclePriceDeviationThreshold: z7.number(),
+  maxSpotPositionSizeA: AmountWithUsdSchema,
+  maxSpotPositionSizeB: AmountWithUsdSchema,
+  borrowedFundsA: AmountWithUsdSchema,
+  borrowedFundsB: AmountWithUsdSchema,
+  availableBorrowA: AmountWithUsdSchema,
+  availableBorrowB: AmountWithUsdSchema,
+  borrowLimitA: AmountWithUsdSchema,
+  borrowLimitB: AmountWithUsdSchema,
+  disabled: z7.boolean(),
+  createdAt: z7.coerce.date()
 });
-var TokenOraclePrice = z.object({
-  mint: z.string(),
-  price: z.coerce.bigint(),
-  decimals: z.number(),
-  time: z.coerce.date()
+var TokenOraclePrice = z7.object({
+  mint: z7.string(),
+  price: z7.coerce.bigint(),
+  decimals: z7.number(),
+  time: z7.coerce.date()
 });
-var Vault = z.object({
-  address: z.string(),
-  mint: z.string(),
-  depositedFunds: amountWithUsd,
-  borrowedFunds: amountWithUsd,
-  supplyLimit: amountWithUsd,
-  borrowedShares: z.coerce.bigint(),
-  depositedShares: z.coerce.bigint(),
-  supplyApy: z.number(),
-  borrowApy: z.number(),
-  interestRate: z.coerce.bigint(),
-  utilization: z.number(),
-  pythOracleFeedId: z.string(),
-  pythOraclePriceUpdate: z.string()
+var Vault = z7.object({
+  address: z7.string(),
+  mint: z7.string(),
+  depositedFunds: AmountWithUsdSchema,
+  borrowedFunds: AmountWithUsdSchema,
+  supplyLimit: AmountWithUsdSchema,
+  borrowedShares: z7.coerce.bigint(),
+  depositedShares: z7.coerce.bigint(),
+  supplyApy: z7.number(),
+  borrowApy: z7.number(),
+  interestRate: z7.coerce.bigint(),
+  utilization: z7.number(),
+  pythOracleFeedId: z7.string(),
+  pythOraclePriceUpdate: z7.string()
 });
-var VaultHistoricalStats = z.object({
-  date: z.preprocess((val, ctx) => {
+var VaultHistoricalStats = z7.object({
+  date: z7.preprocess((val, ctx) => {
     if (typeof val === "string") {
       const [year, month, day] = val.split("-").map(Number);
       return new Date(year, month - 1, day);
@@ -303,419 +754,277 @@ var VaultHistoricalStats = z.object({
       code: "custom",
       message: "Not a valid date string"
     });
-    return z.NEVER;
-  }, z.date()),
-  supply: amountWithUsd,
-  borrow: amountWithUsd,
-  supplyApy: z.number(),
-  borrowApr: z.number()
+    return z7.NEVER;
+  }, z7.date()),
+  supply: AmountWithUsdSchema,
+  borrow: AmountWithUsdSchema,
+  supplyApy: z7.number(),
+  borrowApr: z7.number()
 });
-var Pool = z.object({
-  address: z.string(),
+var Pool = z7.object({
+  address: z7.string(),
   provider: PoolProviderSchema,
-  tokenAMint: z.string(),
-  tokenBMint: z.string(),
-  tokenAVault: z.string(),
-  tokenBVault: z.string(),
-  tvlUsdc: z.coerce.number(),
-  priceChange24H: z.number(),
-  tickSpacing: z.number(),
-  feeRate: z.number(),
-  olpFeeRate: z.nullable(z.number()),
-  protocolFeeRate: z.number(),
-  liquidity: z.coerce.bigint(),
-  sqrtPrice: z.coerce.bigint(),
-  tickCurrentIndex: z.number(),
-  stats: z.object({
-    "24h": z.object({
-      volume: z.coerce.number(),
-      fees: z.coerce.number(),
-      rewards: z.coerce.number(),
-      yieldOverTvl: z.coerce.number()
+  tokenAMint: z7.string(),
+  tokenBMint: z7.string(),
+  tokenAVault: z7.string(),
+  tokenBVault: z7.string(),
+  tvlUsdc: z7.coerce.number(),
+  priceChange24H: z7.number(),
+  tickSpacing: z7.number(),
+  feeRate: z7.number(),
+  olpFeeRate: z7.nullable(z7.number()),
+  protocolFeeRate: z7.number(),
+  liquidity: z7.coerce.bigint(),
+  sqrtPrice: z7.coerce.bigint(),
+  tickCurrentIndex: z7.number(),
+  stats: z7.object({
+    "24h": z7.object({
+      volume: z7.coerce.number(),
+      fees: z7.coerce.number(),
+      rewards: z7.coerce.number(),
+      yieldOverTvl: z7.coerce.number()
     }),
-    "7d": z.object({
-      volume: z.coerce.number(),
-      fees: z.coerce.number(),
-      rewards: z.coerce.number(),
-      yieldOverTvl: z.coerce.number()
+    "7d": z7.object({
+      volume: z7.coerce.number(),
+      fees: z7.coerce.number(),
+      rewards: z7.coerce.number(),
+      yieldOverTvl: z7.coerce.number()
     }),
-    "30d": z.object({
-      volume: z.coerce.number(),
-      fees: z.coerce.number(),
-      rewards: z.coerce.number(),
-      yieldOverTvl: z.coerce.number()
+    "30d": z7.object({
+      volume: z7.coerce.number(),
+      fees: z7.coerce.number(),
+      rewards: z7.coerce.number(),
+      yieldOverTvl: z7.coerce.number()
     })
   })
 });
-var Tick = z.object({
-  index: z.number(),
-  liquidity: z.coerce.bigint()
+var Tick = z7.object({
+  index: z7.number(),
+  liquidity: z7.coerce.bigint()
 });
-var PoolTicks = z.object({
-  tickSpacing: z.number(),
+var PoolTicks = z7.object({
+  tickSpacing: z7.number(),
   ticks: Tick.array()
 });
-var LendingPosition = z.object({
-  address: z.string(),
-  authority: z.string(),
-  mint: z.string(),
-  vault: z.string(),
-  shares: z.coerce.bigint(),
-  funds: amountWithUsd,
-  earned: amountWithUsd
+var LendingPosition = z7.object({
+  address: z7.string(),
+  authority: z7.string(),
+  mint: z7.string(),
+  vault: z7.string(),
+  shares: z7.coerce.bigint(),
+  funds: AmountWithUsdSchema,
+  earned: AmountWithUsdSchema
 });
-var TunaPosition = z.object({
-  address: z.string(),
-  authority: z.string(),
-  version: z.number(),
-  state: TunaPositionStateSchema,
-  positionMint: z.string(),
-  liquidity: z.coerce.bigint(),
-  tickLowerIndex: z.number(),
-  tickUpperIndex: z.number(),
-  entrySqrtPrice: z.coerce.bigint(),
-  lowerLimitOrderSqrtPrice: z.coerce.bigint(),
-  upperLimitOrderSqrtPrice: z.coerce.bigint(),
-  flags: z.number(),
-  pool: z.string(),
-  poolSqrtPrice: z.coerce.bigint(),
-  depositedCollateralA: amountWithoutUsd,
-  depositedCollateralB: amountWithoutUsd,
-  depositedCollateralUsd: z.object({
-    amount: z.number()
-  }),
-  loanFundsA: amountWithUsd,
-  loanFundsB: amountWithUsd,
-  currentLoanA: amountWithUsd,
-  currentLoanB: amountWithUsd,
-  leftoversA: amountWithUsd,
-  leftoversB: amountWithUsd,
-  yieldA: amountWithUsd,
-  yieldB: amountWithUsd,
-  compoundedYieldA: amountWithUsd,
-  compoundedYieldB: amountWithUsd,
-  totalA: amountWithUsd,
-  totalB: amountWithUsd,
-  pnlA: tokensPnl,
-  pnlB: tokensPnl,
-  pnlUsd: usdPnl,
-  openedAt: z.coerce.date(),
-  updatedAtSlot: z.coerce.bigint(),
-  closedAt: z.nullable(z.coerce.date())
+var PoolSwap = z7.object({
+  id: z7.string(),
+  amountIn: z7.coerce.bigint(),
+  amountOut: z7.coerce.bigint(),
+  amountUsd: z7.number(),
+  aToB: z7.boolean(),
+  pool: z7.string(),
+  time: z7.coerce.date()
 });
-var TunaSpotPosition = z.object({
-  address: z.string(),
-  authority: z.string(),
-  version: z.number(),
-  state: TunaSpotPositionStateSchema,
-  entrySqrtPrice: z.coerce.bigint(),
-  lowerLimitOrderSqrtPrice: z.coerce.bigint(),
-  upperLimitOrderSqrtPrice: z.coerce.bigint(),
-  flags: z.number(),
-  pool: z.string(),
-  poolSqrtPrice: z.coerce.bigint(),
-  collateralToken: z.string(),
-  borrowToken: z.string(),
-  positionToken: z.string(),
-  collateral: amountWithUsd,
-  loanFunds: amountWithUsd,
-  currentLoan: amountWithUsd,
-  total: amountWithUsd,
-  uiLiquidationPrice: z.nullable(z.number()),
-  pnlUsd: usdPnl,
-  leverage: z.number(),
-  openedAt: z.coerce.date(),
-  openedAtSlot: z.coerce.bigint(),
-  updatedAtSlot: z.coerce.bigint(),
-  closedAt: z.nullable(z.coerce.date())
-});
-var PoolSwap = z.object({
-  id: z.string(),
-  amountIn: z.coerce.bigint(),
-  amountOut: z.coerce.bigint(),
-  amountUsd: z.number(),
-  aToB: z.boolean(),
-  pool: z.string(),
-  time: z.coerce.date()
-});
-var OrderBookEntry = z.object({
-  concentratedAmount: z.coerce.bigint(),
-  concentratedAmountQuote: z.coerce.bigint(),
-  concentratedTotal: z.coerce.bigint(),
-  concentratedTotalQuote: z.coerce.bigint(),
-  limitAmount: z.coerce.bigint(),
-  limitAmountQuote: z.coerce.bigint(),
-  limitTotal: z.coerce.bigint(),
-  limitTotalQuote: z.coerce.bigint(),
-  price: z.number(),
-  askSide: z.boolean()
+var OrderBookEntry = z7.object({
+  concentratedAmount: z7.coerce.bigint(),
+  concentratedAmountQuote: z7.coerce.bigint(),
+  concentratedTotal: z7.coerce.bigint(),
+  concentratedTotalQuote: z7.coerce.bigint(),
+  limitAmount: z7.coerce.bigint(),
+  limitAmountQuote: z7.coerce.bigint(),
+  limitTotal: z7.coerce.bigint(),
+  limitTotalQuote: z7.coerce.bigint(),
+  price: z7.number(),
+  askSide: z7.boolean()
 });
-var PoolPriceUpdate = z.object({
-  pool: z.string(),
-  price: z.number(),
-  sqrtPrice: z.coerce.bigint(),
-  time: z.coerce.date()
-});
-var OrderBook = z.object({
+var OrderBook = z7.object({
   entries: OrderBookEntry.array(),
-  poolPrice: z.number()
-});
-var LimitOrder = z.object({
-  address: z.string(),
-  mint: z.string(),
-  pool: z.string(),
-  state: LimitOrderStateSchema,
-  aToB: z.boolean(),
-  tickIndex: z.number(),
-  fillRatio: z.number(),
-  openTxSignature: z.string(),
-  closeTxSignature: z.nullable(z.string()),
-  amountIn: amountWithUsd,
-  amountOut: amountWithUsd,
-  openedAt: z.coerce.date(),
-  closedAt: z.nullable(z.coerce.date())
+  poolPrice: z7.number()
 });
-var TradeHistoryEntry = z.object({
+var TradeHistoryEntry = z7.object({
   // Internal entry ID
-  id: z.string(),
-  pool: z.string(),
-  authority: z.string(),
-  aToB: z.boolean(),
+  id: z7.string(),
+  pool: z7.string(),
+  authority: z7.string(),
+  aToB: z7.boolean(),
   // Trade action which created entry
   action: TradeHistoryActionSchema,
   // Trade direction formatted for ui display
   uiDirection: TradeHistoryUIDirectionSchema,
   // Trade price formatted for ui display
-  uiPrice: z.number(),
-  baseToken: amountWithUsd,
-  quoteToken: amountWithUsd,
-  fee: amountWithUsd,
-  pnl: z.nullable(
-    z.object({
-      usd: z.number(),
-      bps: z.number()
+  uiPrice: z7.number(),
+  baseToken: AmountWithUsdSchema,
+  quoteToken: AmountWithUsdSchema,
+  fee: AmountWithUsdSchema,
+  pnl: z7.nullable(
+    z7.object({
+      usd: z7.number(),
+      bps: z7.number()
     })
   ),
-  txSignature: z.nullable(z.string()),
-  positionAddress: z.nullable(z.string()),
-  slot: z.coerce.bigint(),
-  ts: z.coerce.date()
+  txSignature: z7.nullable(z7.string()),
+  positionAddress: z7.nullable(z7.string()),
+  slot: z7.coerce.bigint(),
+  ts: z7.coerce.date()
 });
-var OrderHistoryEntry = z.object({
+var OrderHistoryEntry = z7.object({
   // Internal entry ID
-  id: z.string(),
-  pool: z.string(),
-  authority: z.string(),
+  id: z7.string(),
+  pool: z7.string(),
+  authority: z7.string(),
   orderType: OrderHistoryOrderTypeSchema,
-  isReduceOnly: z.nullable(z.boolean()),
-  aToB: z.boolean(),
+  isReduceOnly: z7.nullable(z7.boolean()),
+  aToB: z7.boolean(),
   uiDirection: OrderHistoryUIDirectionSchema,
-  uiPrice: z.nullable(z.number()),
-  uiExecutionPrice: z.nullable(z.number()),
+  uiPrice: z7.nullable(z7.number()),
+  uiExecutionPrice: z7.nullable(z7.number()),
   status: OrderHistoryStatusSchema,
-  baseToken: amountWithUsd,
-  quoteToken: amountWithUsd,
-  baseTokenConsumedAmount: z.nullable(amountWithUsd),
-  quoteTokenFilledAmount: z.nullable(amountWithUsd),
-  txSignature: z.nullable(z.string()),
-  positionAddress: z.nullable(z.string()),
-  slot: z.coerce.bigint(),
-  ts: z.coerce.date()
+  baseToken: AmountWithUsdSchema,
+  quoteToken: AmountWithUsdSchema,
+  baseTokenConsumedAmount: z7.nullable(AmountWithUsdSchema),
+  quoteTokenFilledAmount: z7.nullable(AmountWithUsdSchema),
+  txSignature: z7.nullable(z7.string()),
+  positionAddress: z7.nullable(z7.string()),
+  slot: z7.coerce.bigint(),
+  ts: z7.coerce.date()
 });
-var StakingTreasury = z.object({
-  address: z.string(),
-  stakedTokenMint: z.string(),
-  rewardTokenMint: z.string(),
-  apy: z.number(),
-  uniqueStakers: z.number(),
-  totalStaked: amountWithUsd,
-  totalReward: amountWithUsd,
-  unstakeCooldownSeconds: z.number(),
-  isStakingEnabled: z.boolean(),
-  isUnstakingEnabled: z.boolean(),
-  isWithdrawEnabled: z.boolean()
+var StakingTreasury = z7.object({
+  address: z7.string(),
+  stakedTokenMint: z7.string(),
+  rewardTokenMint: z7.string(),
+  apy: z7.number(),
+  uniqueStakers: z7.number(),
+  totalStaked: AmountWithUsdSchema,
+  totalReward: AmountWithUsdSchema,
+  unstakeCooldownSeconds: z7.number(),
+  isStakingEnabled: z7.boolean(),
+  isUnstakingEnabled: z7.boolean(),
+  isWithdrawEnabled: z7.boolean()
 });
-var StakingPosition = z.object({
-  address: z.string(),
-  owner: z.string(),
-  staked: amountWithUsd,
-  unstaked: amountWithUsd,
-  claimedReward: amountWithUsd,
-  unclaimedReward: amountWithUsd,
-  rank: z.nullable(z.number()),
-  vesting: z.object({
-    locked: amountWithUsd,
-    unlocked: amountWithUsd,
-    unlockRate: z.coerce.bigint(),
-    unlockEverySeconds: z.number(),
-    unlockCliffSeconds: z.number(),
-    lockedAt: z.nullable(z.coerce.date())
+var StakingPosition = z7.object({
+  address: z7.string(),
+  owner: z7.string(),
+  staked: AmountWithUsdSchema,
+  unstaked: AmountWithUsdSchema,
+  claimedReward: AmountWithUsdSchema,
+  unclaimedReward: AmountWithUsdSchema,
+  rank: z7.nullable(z7.number()),
+  vesting: z7.object({
+    locked: AmountWithUsdSchema,
+    unlocked: AmountWithUsdSchema,
+    unlockRate: z7.coerce.bigint(),
+    unlockEverySeconds: z7.number(),
+    unlockCliffSeconds: z7.number(),
+    lockedAt: z7.nullable(z7.coerce.date())
   }),
-  lastUnstakedAt: z.nullable(z.coerce.date()),
-  withdrawAvailableAt: z.nullable(z.coerce.date())
+  lastUnstakedAt: z7.nullable(z7.coerce.date()),
+  withdrawAvailableAt: z7.nullable(z7.coerce.date())
 });
-var StakingLeaderboardPosition = z.object({
-  rank: z.number(),
-  address: z.string(),
-  owner: z.string(),
-  staked: amountWithUsd
+var StakingLeaderboardPosition = z7.object({
+  rank: z7.number(),
+  address: z7.string(),
+  owner: z7.string(),
+  staked: AmountWithUsdSchema
 });
-var StakingLeaderboardPage = z.object({
+var StakingLeaderboardPage = z7.object({
   data: StakingLeaderboardPosition.array(),
   meta: PaginationMeta
 });
-var StakingPositionHistoryAction = z.object({
-  position: z.string(),
+var StakingPositionHistoryAction = z7.object({
+  position: z7.string(),
   action: StakingPositionHistoryActionTypeSchema,
-  txSignature: z.string(),
-  amount: z.coerce.bigint(),
-  time: z.coerce.date()
-});
-var PoolPriceCandle = z.object({
-  time: z.number(),
-  open: z.number(),
-  close: z.number(),
-  high: z.number(),
-  low: z.number(),
-  volume: z.number()
-});
-var FeesStatsGroup = z.object({
-  time: z.coerce.date(),
-  addLiquidityFees: z.number(),
-  limitOrderFees: z.number(),
-  yieldCompoundingFees: z.number(),
-  liquidationFees: z.number(),
-  totalLiquidationsNetworkFees: z.number(),
-  totalLimitOrdersNetworkFees: z.number(),
-  totalYieldCompoundingNetworkFees: z.number(),
-  failedNetworkFees: z.number(),
-  processedNetworkFees: z.number(),
-  totalCollectedFees: z.number(),
-  totalNetworkFees: z.number(),
-  jitoLiquidationFees: z.number(),
-  jitoLimitOrderFees: z.number(),
-  jitoYieldCompoundingFees: z.number(),
-  runningAddLiquidityFees: z.number(),
-  runningLimitOrderFees: z.number(),
-  runningYieldCompoundingFees: z.number(),
-  runningLiquidationFees: z.number(),
-  runningTotalLiquidationsNetworkFees: z.number(),
-  runningTotalLimitOrdersNetworkFees: z.number(),
-  runningTotalYieldCompoundingNetworkFees: z.number(),
-  runningFailedNetworkFees: z.number(),
-  runningProcessedNetworkFees: z.number(),
-  runningJitoLiquidationFees: z.number(),
-  runningJitoLimitOrderFees: z.number(),
-  runningJitoYieldCompoundingFees: z.number(),
-  runningTotalCollectedFees: z.number(),
-  runningTotalNetworkFees: z.number()
+  txSignature: z7.string(),
+  amount: z7.coerce.bigint(),
+  time: z7.coerce.date()
 });
-var StakingRevenueStatsGroup = z.object({
-  time: z.coerce.date(),
-  totalDepositsUsd: z.number(),
-  totalDepositsSol: z.coerce.bigint(),
-  runningTotalDepositsUsd: z.number(),
-  runningTotalDepositsSol: z.coerce.bigint()
+var PoolPriceCandle = z7.object({
+  time: z7.number(),
+  open: z7.number(),
+  close: z7.number(),
+  high: z7.number(),
+  low: z7.number(),
+  volume: z7.number()
 });
-var IncreaseSpotPositionQuote = z.object({
-  /** Required collateral amount */
-  collateralAmount: z.coerce.bigint(),
-  /** Required amount to borrow */
-  borrowAmount: z.coerce.bigint(),
-  /** Estimated position size in the position token. */
-  estimatedAmount: z.coerce.bigint(),
-  /** Swap input amount. */
-  swapInputAmount: z.coerce.bigint(),
-  /** Minimum swap output amount according to the provided slippage. */
-  minSwapOutputAmount: z.coerce.bigint(),
-  /** Protocol fee in token A */
-  protocolFeeA: z.coerce.bigint(),
-  /** Protocol fee in token B */
-  protocolFeeB: z.coerce.bigint(),
-  /** Price impact in percents */
-  priceImpact: z.number(),
-  /** Liquidation price */
-  uiLiquidationPrice: z.nullable(z.number())
-});
-var DecreaseSpotPositionQuote = z.object({
-  /** Confirmed position decrease percentage (100% = 1.0) */
-  decreasePercent: 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: z.coerce.bigint(),
-  /**  Estimated total amount of the adjusted position */
-  estimatedAmount: z.coerce.bigint(),
-  /** Estimated amount of the withdrawn collateral */
-  estimatedWithdrawnCollateral: z.coerce.bigint(),
-  /** Price impact in percents */
-  priceImpact: z.number(),
-  /** Liquidation price */
-  uiLiquidationPrice: z.nullable(z.number())
+var FeesStatsGroup = z7.object({
+  time: z7.coerce.date(),
+  addLiquidityFees: z7.number(),
+  limitOrderFees: z7.number(),
+  yieldCompoundingFees: z7.number(),
+  liquidationFees: z7.number(),
+  totalLiquidationsNetworkFees: z7.number(),
+  totalLimitOrdersNetworkFees: z7.number(),
+  totalYieldCompoundingNetworkFees: z7.number(),
+  failedNetworkFees: z7.number(),
+  processedNetworkFees: z7.number(),
+  totalCollectedFees: z7.number(),
+  totalNetworkFees: z7.number(),
+  jitoLiquidationFees: z7.number(),
+  jitoLimitOrderFees: z7.number(),
+  jitoYieldCompoundingFees: z7.number(),
+  runningAddLiquidityFees: z7.number(),
+  runningLimitOrderFees: z7.number(),
+  runningYieldCompoundingFees: z7.number(),
+  runningLiquidationFees: z7.number(),
+  runningTotalLiquidationsNetworkFees: z7.number(),
+  runningTotalLimitOrdersNetworkFees: z7.number(),
+  runningTotalYieldCompoundingNetworkFees: z7.number(),
+  runningFailedNetworkFees: z7.number(),
+  runningProcessedNetworkFees: z7.number(),
+  runningJitoLiquidationFees: z7.number(),
+  runningJitoLimitOrderFees: z7.number(),
+  runningJitoYieldCompoundingFees: z7.number(),
+  runningTotalCollectedFees: z7.number(),
+  runningTotalNetworkFees: z7.number()
 });
-var CloseSpotPositionQuote = z.object({
-  /** Position decrease percentage */
-  decreasePercent: 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: z.coerce.bigint(),
-  /** Estimated amount of the withdrawn collateral */
-  estimatedWithdrawnCollateral: z.coerce.bigint(),
-  /** Price impact in percents */
-  priceImpact: z.number()
+var StakingRevenueStatsGroup = z7.object({
+  time: z7.coerce.date(),
+  totalDepositsUsd: z7.number(),
+  totalDepositsSol: z7.coerce.bigint(),
+  runningTotalDepositsUsd: z7.number(),
+  runningTotalDepositsSol: z7.coerce.bigint()
 });
-var SwapQuoteByInput = z.object({
-  estimatedAmountOut: z.coerce.bigint(),
-  minAmountOut: z.coerce.bigint(),
-  feeAmount: z.coerce.bigint(),
-  feeUsd: z.number(),
+var SwapQuoteByInput = z7.object({
+  estimatedAmountOut: z7.coerce.bigint(),
+  minAmountOut: z7.coerce.bigint(),
+  feeAmount: z7.coerce.bigint(),
+  feeUsd: z7.number(),
   /** Price impact in percents */
-  priceImpact: z.number()
+  priceImpact: z7.number()
 });
-var SwapQuoteByOutput = z.object({
-  estimatedAmountIn: z.coerce.bigint(),
-  maxAmountIn: z.coerce.bigint(),
-  feeAmount: z.coerce.bigint(),
-  feeUsd: z.number(),
+var SwapQuoteByOutput = z7.object({
+  estimatedAmountIn: z7.coerce.bigint(),
+  maxAmountIn: z7.coerce.bigint(),
+  feeAmount: z7.coerce.bigint(),
+  feeUsd: z7.number(),
   /** Price impact in percents */
-  priceImpact: z.number()
-});
-var StateSnapshot = z.object({
-  slot: z.coerce.bigint(),
-  blockTime: z.coerce.date(),
-  poolPrices: z.optional(z.record(z.string(), PoolPriceUpdate)),
-  tunaSpotPositions: z.optional(z.array(TunaSpotPosition)),
-  tunaLpPositions: z.optional(z.array(TunaPosition)),
-  fusionLimitOrders: z.optional(z.array(LimitOrder))
+  priceImpact: z7.number()
 });
-var LimitOrderQuoteByInput = z.object({
-  amountOut: z.coerce.bigint()
+var LimitOrderQuoteByInput = z7.object({
+  amountOut: z7.coerce.bigint()
 });
-var LimitOrderQuoteByOutput = z.object({
-  amountIn: z.coerce.bigint()
+var LimitOrderQuoteByOutput = z7.object({
+  amountIn: z7.coerce.bigint()
 });
-var TradableAmount = amountWithUsd;
-var UpdateStreamSubscriptionResult = z.object({
-  status: z.string()
+var TradableAmount = AmountWithUsdSchema;
+var UpdateStreamSubscriptionResult = z7.object({
+  status: z7.string()
 });
-var createNotificationSchema = (dataSchema, metaSchema) => z.object({
+var createNotificationSchema = (dataSchema, metaSchema) => z7.object({
   entity: NotificationEntitySchema,
   action: NotificationActionSchema,
   data: dataSchema,
-  id: z.string(),
-  authority: z.nullish(z.string()),
-  ...metaSchema ? { meta: metaSchema } : { meta: z.undefined().nullable() }
+  id: z7.string(),
+  authority: z7.nullish(z7.string()),
+  ...metaSchema ? { meta: metaSchema } : { meta: z7.undefined().nullable() }
 });
-var OrderBookNotificationMeta = z.object({
-  pool: z.string(),
-  priceStep: z.number(),
-  inverted: z.boolean()
+var OrderBookNotificationMeta = z7.object({
+  pool: z7.string(),
+  priceStep: z7.number(),
+  inverted: z7.boolean()
 });
 var PoolSwapNotification = createNotificationSchema(PoolSwap);
 var PoolPriceUpdateNotification = createNotificationSchema(PoolPriceUpdate);
 var OrderBookNotification = createNotificationSchema(OrderBook, OrderBookNotificationMeta);
-var TunaPositionNotification = createNotificationSchema(TunaPosition);
+var TunaPositionNotification = createNotificationSchema(TunaPositionLegacy);
 var TunaSpotPositionNotification = createNotificationSchema(TunaSpotPosition);
 var LendingPositionNotification = createNotificationSchema(LendingPosition);
 var LimitOrderNotification = createNotificationSchema(LimitOrder);
@@ -893,11 +1202,44 @@ var TunaApiClient = class {
   }
   async getUserTunaPositions(userAddress) {
     const url = this.buildURL(`users/${userAddress}/tuna-positions`);
-    return await this.httpRequest(url, TunaPosition.array());
+    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, TunaPosition);
+    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`);
@@ -908,7 +1250,7 @@ var TunaApiClient = class {
     return await this.httpRequest(url, TunaSpotPosition);
   }
   async getUserLimitOrders(userAddress, options) {
-    let query = {};
+    const query = {};
     if (options) {
       if (options.pool?.length) {
         query.pool = options.pool.join(",");
@@ -940,7 +1282,7 @@ var TunaApiClient = class {
     return await this.httpRequest(url, LimitOrder);
   }
   async getUserTradeHistory(userAddress, options) {
-    let query = {};
+    const query = {};
     if (options) {
       if (options.pool?.length) {
         query.pool = options.pool.join(",");
@@ -965,7 +1307,7 @@ var TunaApiClient = class {
     return await this.httpRequest(url, TradeHistoryEntry.array());
   }
   async getUserOrderHistory(userAddress, options) {
-    let query = {};
+    const query = {};
     if (options) {
       if (options.pool?.length) {
         query.pool = options.pool.join(",");
@@ -1014,7 +1356,7 @@ var TunaApiClient = class {
   }
   async getLimitOrderQuoteByInput(args, config) {
     const { pool, amountIn, aToB, tickIndex } = args;
-    let query = {
+    const query = {
       pool,
       amount_in: amountIn.toString(),
       a_to_b: aToB,
@@ -1027,7 +1369,7 @@ var TunaApiClient = class {
   }
   async getLimitOrderQuoteByOutput(args, config) {
     const { pool, amountOut, aToB, tickIndex } = args;
-    let query = {
+    const query = {
       pool,
       amount_out: amountOut.toString(),
       a_to_b: aToB,
@@ -1040,7 +1382,7 @@ var TunaApiClient = class {
   }
   async getSwapQuoteByInput(args, config) {
     const { pool, amountIn, aToB, slippageToleranceBps } = args;
-    let query = {
+    const query = {
       pool,
       amount_in: amountIn.toString(),
       a_to_b: aToB
@@ -1055,7 +1397,7 @@ var TunaApiClient = class {
   }
   async getSwapQuoteByOutput(args, config) {
     const { pool, amountOut, aToB, slippageToleranceBps } = args;
-    let query = {
+    const query = {
       pool,
       amount_out: amountOut.toString(),
       a_to_b: aToB
@@ -1079,7 +1421,7 @@ var TunaApiClient = class {
       positionDebt,
       slippageTolerance
     } = args;
-    let query = {
+    const query = {
       market,
       increase_amount: increaseAmount.toString(),
       collateral_token: collateralToken,
@@ -1111,7 +1453,7 @@ var TunaApiClient = class {
       positionDebt,
       slippageTolerance
     } = args;
-    let query = {
+    const query = {
       market,
       decrease_amount: decreaseAmount.toString(),
       collateral_token: collateralToken,
@@ -1130,7 +1472,7 @@ var TunaApiClient = class {
   }
   async getCloseSpotPositionQuote(args, config) {
     const { market, decreasePercent, collateralToken, positionToken, positionAmount, positionDebt, slippageTolerance } = args;
-    let query = {
+    const query = {
       market,
       decrease_percent: decreasePercent,
       collateral_token: collateralToken,