@crypticdot/defituna-api 1.10.0 → 1.10.2

package/dist/index.js

@@ -48,6 +48,8 @@ var import_snakecase_keys = __toESM(require("snakecase-keys"));
 // src/client/schemas.ts
 var schemas_exports = {};
 __export(schemas_exports, {
+  AmountWithUsdSchema: () => AmountWithUsdSchema,
+  AmountWithoutUsdSchema: () => AmountWithoutUsdSchema,
   CloseSpotPositionQuote: () => CloseSpotPositionQuote,
   DecreaseSpotPositionQuote: () => DecreaseSpotPositionQuote,
   FeesStatsGroup: () => FeesStatsGroup,
@@ -113,6 +115,7 @@ __export(schemas_exports, {
   SwapQuoteByOutput: () => SwapQuoteByOutput,
   Tick: () => Tick,
   TokenOraclePrice: () => TokenOraclePrice,
+  TokensPnlSchema: () => TokensPnlSchema,
   TradableAmount: () => TradableAmount,
   TradeHistoryAction: () => TradeHistoryAction,
   TradeHistoryActionSchema: () => TradeHistoryActionSchema,
@@ -120,7 +123,6 @@ __export(schemas_exports, {
   TradeHistoryEntryNotification: () => TradeHistoryEntryNotification,
   TradeHistoryUIDirection: () => TradeHistoryUIDirection,
   TradeHistoryUIDirectionSchema: () => TradeHistoryUIDirectionSchema,
-  TunaLpPosition: () => TunaLpPosition,
   TunaLpPositionAction: () => TunaLpPositionAction,
   TunaLpPositionActionClose: () => TunaLpPositionActionClose,
   TunaLpPositionActionCollectAndCompoundFees: () => TunaLpPositionActionCollectAndCompoundFees,
@@ -131,71 +133,61 @@ __export(schemas_exports, {
   TunaLpPositionActionOpen: () => TunaLpPositionActionOpen,
   TunaLpPositionActionParametersUpdate: () => TunaLpPositionActionParametersUpdate,
   TunaLpPositionActionRepayDebt: () => TunaLpPositionActionRepayDebt,
+  TunaLpPositionAutoCompounding: () => TunaLpPositionAutoCompounding,
+  TunaLpPositionAutoCompoundingSchema: () => TunaLpPositionAutoCompoundingSchema,
+  TunaLpPositionDtoSchema: () => TunaLpPositionDtoSchema,
+  TunaLpPositionFlagsSchema: () => TunaLpPositionFlagsSchema,
+  TunaLpPositionHistorical: () => TunaLpPositionHistorical,
   TunaLpPositionParameters: () => TunaLpPositionParameters,
   TunaLpPositionTokenPrices: () => TunaLpPositionTokenPrices,
   TunaLpPositionTransfer: () => TunaLpPositionTransfer,
   TunaLpPositionValue: () => TunaLpPositionValue,
-  TunaPosition: () => TunaPosition,
+  TunaPositionLegacy: () => TunaPositionLegacy,
   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
 });
+var import_zod8 = require("zod");
+
+// src/client/schemas/basic.ts
 var import_zod = require("zod");
-var amountWithoutUsd = import_zod.z.object({
-  amount: import_zod.z.coerce.bigint()
-});
-var amountWithUsd = import_zod.z.object({
+var AmountWithUsdSchema = import_zod.z.object({
   amount: import_zod.z.coerce.bigint(),
   usd: import_zod.z.number()
 });
-var tokensPnl = import_zod.z.object({
+var AmountWithoutUsdSchema = import_zod.z.object({
+  amount: import_zod.z.coerce.bigint()
+});
+var TokensPnlSchema = import_zod.z.object({
   amount: import_zod.z.coerce.bigint(),
-  bps: import_zod.z.number()
+  rate: import_zod.z.number()
 });
-var usdPnl = import_zod.z.object({
+var UsdPnlSchema = import_zod.z.object({
   amount: import_zod.z.number(),
-  bps: import_zod.z.number()
+  rate: import_zod.z.number()
 });
-var NotificationEntity = {
-  POOL_SWAP: "pool_swap",
-  POOL_PRICE: "pool_price",
-  ORDER_BOOK: "order_book",
-  TUNA_POSITION: "tuna_position",
-  TUNA_SPOT_POSITION: "tuna_spot_position",
-  LENDING_POSITION: "lending_position",
-  STAKING_POSITION: "staking_position",
-  FUSION_LIMIT_ORDER: "fusion_limit_order",
-  TRADE_HISTORY_ENTRY: "trade_history_entry",
-  ORDER_HISTORY_ENTRY: "order_history_entry",
-  STATE_SNAPSHOT: "state_snapshot"
-};
-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 PoolProviderSchema = import_zod.z.enum([PoolProvider.ORCA, ...Object.values(PoolProvider)]);
+
+// src/client/schemas/limit_orders.ts
+var import_zod2 = require("zod");
 var LimitOrderState = {
   OPEN: "open",
   PARTIALLY_FILLED: "partially_filled",
@@ -203,65 +195,50 @@ var LimitOrderState = {
   COMPLETE: "complete",
   CANCELLED: "cancelled"
 };
-var TradeHistoryAction = {
-  SWAP: "swap",
-  LIMIT_ORDER_FILL: "limit_order_fill",
-  POSITION_INCREASE: "position_increase",
-  POSITION_DECREASE: "position_decrease",
-  TAKE_PROFIT: "take_profit",
-  STOP_LOSS: "stop_loss",
-  LIQUIDATION: "liquidation"
-};
-var 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_PRICES: "pool_prices",
-  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 LimitOrderStateSchema = import_zod2.z.enum([LimitOrderState.OPEN, ...Object.values(LimitOrderState)]);
+var LimitOrder = import_zod2.z.object({
+  address: import_zod2.z.string(),
+  mint: import_zod2.z.string(),
+  pool: import_zod2.z.string(),
+  state: LimitOrderStateSchema,
+  aToB: import_zod2.z.boolean(),
+  tickIndex: import_zod2.z.number(),
+  fillRatio: import_zod2.z.number(),
+  openTxSignature: import_zod2.z.string(),
+  closeTxSignature: import_zod2.z.nullable(import_zod2.z.string()),
+  amountIn: AmountWithUsdSchema,
+  amountOut: AmountWithUsdSchema,
+  openedAt: import_zod2.z.coerce.date(),
+  closedAt: import_zod2.z.nullable(import_zod2.z.coerce.date())
+});
+
+// src/client/schemas/lp_positions.ts
+var import_zod5 = __toESM(require("zod"));
+
+// src/client/schemas/mint.ts
+var import_zod3 = require("zod");
+var Mint = import_zod3.z.object({
+  mint: import_zod3.z.string(),
+  symbol: import_zod3.z.string(),
+  name: import_zod3.z.string(),
+  logo: import_zod3.z.string(),
+  decimals: import_zod3.z.number()
+});
+
+// src/client/schemas/positions_shared.ts
+var import_zod4 = __toESM(require("zod"));
+var TunaPositionPoolSchema = import_zod4.default.object({
+  addr: import_zod4.default.string(),
+  price: import_zod4.default.number(),
+  tickSpacing: import_zod4.default.number()
+});
+var TunaPositionPoolToken = {
+  A: "a",
+  B: "b"
 };
+var TunaPositionPoolTokenSchema = import_zod4.default.enum(Object.values(TunaPositionPoolToken));
+
+// src/client/schemas/lp_positions.ts
 var LpPositionLimitOrderSwap = {
   NO_SWAP: "no_swap",
   SWAP_TO_TOKEN_A: "swap_to_token_a",
@@ -292,270 +269,173 @@ var LpPositionsActionType = {
   SET_FLAGS: "set_flags",
   SET_REBALANCE_THRESHOLD: "set_rebalance_threshold"
 };
-var NotificationEntitySchema = import_zod.z.enum([NotificationEntity.POOL_SWAP, ...Object.values(NotificationEntity)]);
-var NotificationActionSchema = import_zod.z.enum([NotificationAction.CREATE, ...Object.values(NotificationAction)]);
-var PoolProviderSchema = import_zod.z.enum([PoolProvider.ORCA, ...Object.values(PoolProvider)]);
-var TunaPositionStateSchema = import_zod.z.enum([TunaPositionState.OPEN, ...Object.values(TunaPositionState)]);
-var TunaSpotPositionStateSchema = import_zod.z.enum([
-  TunaSpotPositionState.OPEN,
-  ...Object.values(TunaSpotPositionState)
-]);
-var LimitOrderStateSchema = import_zod.z.enum([LimitOrderState.OPEN, ...Object.values(LimitOrderState)]);
-var TradeHistoryActionSchema = import_zod.z.enum([TradeHistoryAction.SWAP, ...Object.values(TradeHistoryAction)]);
-var TradeHistoryUIDirectionSchema = import_zod.z.enum([
-  TradeHistoryUIDirection.BUY,
-  ...Object.values(TradeHistoryUIDirection)
-]);
-var OrderHistoryOrderTypeSchema = import_zod.z.enum([
-  OrderHistoryOrderType.MARKET,
-  ...Object.values(OrderHistoryOrderType)
-]);
-var OrderHistoryStatusSchema = import_zod.z.enum([OrderHistoryStatus.OPEN, ...Object.values(OrderHistoryStatus)]);
-var OrderHistoryUIDirectionSchema = import_zod.z.enum([
-  OrderHistoryUIDirection.BUY,
-  ...Object.values(OrderHistoryUIDirection)
-]);
-var StakingPositionHistoryActionTypeSchema = import_zod.z.enum([
-  StakingPositionHistoryActionType.STAKE,
-  ...Object.values(StakingPositionHistoryActionType)
-]);
-var PoolSubscriptionTopicSchema = import_zod.z.enum([
-  PoolSubscriptionTopic.ORDER_BOOK,
-  ...Object.values(PoolSubscriptionTopic)
-]);
-var WalletSubscriptionTopicSchema = import_zod.z.enum([
-  WalletSubscriptionTopic.TUNA_POSITIONS,
-  ...Object.values(WalletSubscriptionTopic)
-]);
-var LpPositionLimitOrderSwapSchema = import_zod.z.enum(Object.values(LpPositionLimitOrderSwap));
-var LpPositionAutoCompoundSchema = import_zod.z.enum(Object.values(LpPositionAutoCompound));
-var LpPositionRebalanceSchema = import_zod.z.enum(Object.values(LpPositionRebalance));
-var LpPositionsActionTypeSchema = import_zod.z.enum(Object.values(LpPositionsActionType));
-var PaginationMeta = import_zod.z.object({
-  total: import_zod.z.number()
-});
-var Mint = import_zod.z.object({
-  symbol: import_zod.z.string(),
-  mint: import_zod.z.string(),
-  logo: import_zod.z.string(),
-  decimals: import_zod.z.number()
-});
-var Market = import_zod.z.object({
-  address: import_zod.z.string(),
-  addressLookupTable: import_zod.z.string(),
-  poolAddress: import_zod.z.string(),
-  poolFeeRate: import_zod.z.number(),
-  provider: PoolProviderSchema,
-  maxLeverage: import_zod.z.number(),
-  maxSwapSlippage: import_zod.z.number(),
-  protocolFee: import_zod.z.number(),
-  rebalanceProtocolFee: import_zod.z.number(),
-  protocolFeeOnCollateral: import_zod.z.number(),
-  liquidationFee: import_zod.z.number(),
-  liquidationThreshold: import_zod.z.number(),
-  oraclePriceDeviationThreshold: import_zod.z.number(),
-  limitOrderExecutionFee: import_zod.z.number(),
-  maxSpotPositionSizeA: amountWithUsd,
-  maxSpotPositionSizeB: amountWithUsd,
-  borrowedFundsA: amountWithUsd,
-  borrowedFundsB: amountWithUsd,
-  availableBorrowA: amountWithUsd,
-  availableBorrowB: amountWithUsd,
-  borrowLimitA: amountWithUsd,
-  borrowLimitB: amountWithUsd,
-  disabled: import_zod.z.boolean(),
-  createdAt: import_zod.z.coerce.date()
-});
-var TokenOraclePrice = import_zod.z.object({
-  mint: import_zod.z.string(),
-  price: import_zod.z.coerce.bigint(),
-  decimals: import_zod.z.number(),
-  time: import_zod.z.coerce.date()
-});
-var Vault = import_zod.z.object({
-  address: import_zod.z.string(),
-  mint: import_zod.z.string(),
-  depositedFunds: amountWithUsd,
-  borrowedFunds: amountWithUsd,
-  supplyLimit: amountWithUsd,
-  borrowedShares: import_zod.z.coerce.bigint(),
-  depositedShares: import_zod.z.coerce.bigint(),
-  supplyApy: import_zod.z.number(),
-  borrowApy: import_zod.z.number(),
-  interestRate: import_zod.z.coerce.bigint(),
-  utilization: import_zod.z.number(),
-  pythOracleFeedId: import_zod.z.string(),
-  pythOraclePriceUpdate: import_zod.z.string()
-});
-var VaultHistoricalStats = import_zod.z.object({
-  date: import_zod.z.preprocess((val, ctx) => {
-    if (typeof val === "string") {
-      const [year, month, day] = val.split("-").map(Number);
-      return new Date(year, month - 1, day);
-    }
-    ctx.addIssue({
-      code: "custom",
-      message: "Not a valid date string"
-    });
-    return import_zod.z.NEVER;
-  }, import_zod.z.date()),
-  supply: amountWithUsd,
-  borrow: amountWithUsd,
-  supplyApy: import_zod.z.number(),
-  borrowApr: import_zod.z.number()
-});
-var Pool = import_zod.z.object({
-  address: import_zod.z.string(),
-  provider: PoolProviderSchema,
-  tokenAMint: import_zod.z.string(),
-  tokenBMint: import_zod.z.string(),
-  tokenAVault: import_zod.z.string(),
-  tokenBVault: import_zod.z.string(),
-  tvlUsdc: import_zod.z.coerce.number(),
-  priceChange24H: import_zod.z.number(),
-  tickSpacing: import_zod.z.number(),
-  feeRate: import_zod.z.number(),
-  olpFeeRate: import_zod.z.nullable(import_zod.z.number()),
-  protocolFeeRate: import_zod.z.number(),
-  liquidity: import_zod.z.coerce.bigint(),
-  sqrtPrice: import_zod.z.coerce.bigint(),
-  tickCurrentIndex: import_zod.z.number(),
-  stats: import_zod.z.object({
-    "24h": import_zod.z.object({
-      volume: import_zod.z.coerce.number(),
-      fees: import_zod.z.coerce.number(),
-      rewards: import_zod.z.coerce.number(),
-      yieldOverTvl: import_zod.z.coerce.number()
-    }),
-    "7d": import_zod.z.object({
-      volume: import_zod.z.coerce.number(),
-      fees: import_zod.z.coerce.number(),
-      rewards: import_zod.z.coerce.number(),
-      yieldOverTvl: import_zod.z.coerce.number()
-    }),
-    "30d": import_zod.z.object({
-      volume: import_zod.z.coerce.number(),
-      fees: import_zod.z.coerce.number(),
-      rewards: import_zod.z.coerce.number(),
-      yieldOverTvl: import_zod.z.coerce.number()
-    })
-  })
-});
-var Tick = import_zod.z.object({
-  index: import_zod.z.number(),
-  liquidity: import_zod.z.coerce.bigint()
+var LpPositionLimitOrderSwapSchema = import_zod5.default.enum(Object.values(LpPositionLimitOrderSwap));
+var LpPositionAutoCompoundSchema = import_zod5.default.enum(Object.values(LpPositionAutoCompound));
+var LpPositionRebalanceSchema = import_zod5.default.enum(Object.values(LpPositionRebalance));
+var LpPositionsActionTypeSchema = import_zod5.default.enum(Object.values(LpPositionsActionType));
+var TunaPositionState = {
+  OPEN: "open",
+  LIQUIDATED: "liquidated",
+  CLOSED_BY_LIMIT_ORDER: "closed_by_limit_order",
+  CLOSED: "closed"
+};
+var TunaPositionStateSchema = import_zod5.default.enum([TunaPositionState.OPEN, ...Object.values(TunaPositionState)]);
+var TunaLpPositionAutoCompounding = {
+  WITH_LEVERAGE: "with_leverage",
+  WITHOUT_LEVERAGE: "without_leverage"
+};
+var TunaLpPositionAutoCompoundingSchema = import_zod5.default.enum(
+  Object.values(TunaLpPositionAutoCompounding)
+);
+var TunaPositionTokenPnlSchema = import_zod5.default.object({
+  amount: import_zod5.default.coerce.bigint(),
+  bps: import_zod5.default.number()
 });
-var PoolTicks = import_zod.z.object({
-  tickSpacing: import_zod.z.number(),
-  ticks: Tick.array()
+var TunaLpPositionFlagsSchema = import_zod5.default.object({
+  lowerLimitOrderSwapToToken: import_zod5.default.nullable(TunaPositionPoolTokenSchema),
+  upperLimitOrderSwapToToken: import_zod5.default.nullable(TunaPositionPoolTokenSchema),
+  autoCompounding: import_zod5.default.nullable(TunaLpPositionAutoCompoundingSchema),
+  autoRebalancing: import_zod5.default.boolean()
 });
-var LendingPosition = import_zod.z.object({
-  address: import_zod.z.string(),
-  authority: import_zod.z.string(),
-  mint: import_zod.z.string(),
-  vault: import_zod.z.string(),
-  shares: import_zod.z.coerce.bigint(),
-  funds: amountWithUsd,
-  earned: amountWithUsd
-});
-var TunaPosition = import_zod.z.object({
-  address: import_zod.z.string(),
-  authority: import_zod.z.string(),
-  version: import_zod.z.number(),
+var TunaLpPositionDtoSchema = import_zod5.default.object({
+  address: import_zod5.default.string(),
+  authority: import_zod5.default.string(),
+  version: import_zod5.default.number(),
   state: TunaPositionStateSchema,
-  positionMint: import_zod.z.string(),
-  liquidity: import_zod.z.coerce.bigint(),
-  tickLowerIndex: import_zod.z.number(),
-  tickUpperIndex: import_zod.z.number(),
-  entrySqrtPrice: import_zod.z.coerce.bigint(),
-  lowerLimitOrderSqrtPrice: import_zod.z.coerce.bigint(),
-  upperLimitOrderSqrtPrice: import_zod.z.coerce.bigint(),
-  flags: import_zod.z.number(),
-  pool: import_zod.z.string(),
-  poolSqrtPrice: import_zod.z.coerce.bigint(),
-  depositedCollateralA: amountWithoutUsd,
-  depositedCollateralB: amountWithoutUsd,
-  depositedCollateralUsd: import_zod.z.object({
-    amount: import_zod.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: import_zod.z.coerce.date(),
-  updatedAtSlot: import_zod.z.coerce.bigint(),
-  closedAt: import_zod.z.nullable(import_zod.z.coerce.date())
-});
-var TunaLpPosition = import_zod.z.object({
-  positionAddress: import_zod.z.string(),
-  authority: import_zod.z.string(),
-  pool: import_zod.z.string(),
+  positionMint: import_zod5.default.string(),
+  liquidity: import_zod5.default.coerce.bigint(),
+  lowerPrice: import_zod5.default.number(),
+  upperPrice: import_zod5.default.number(),
+  lowerLimitOrderPrice: import_zod5.default.number(),
+  upperLimitOrderPrice: import_zod5.default.number(),
+  entryPrice: import_zod5.default.number(),
+  flags: TunaLpPositionFlagsSchema,
+  mintA: Mint,
+  mintB: Mint,
+  pool: TunaPositionPoolSchema,
+  marketMaker: PoolProviderSchema,
+  depositedCollateralA: AmountWithUsdSchema,
+  depositedCollateralB: AmountWithUsdSchema,
+  leverage: import_zod5.default.number(),
+  maxLeverage: import_zod5.default.number(),
+  liquidationPriceLower: import_zod5.default.number(),
+  liquidationPriceUpper: import_zod5.default.number(),
+  initialDebtA: AmountWithUsdSchema,
+  initialDebtB: AmountWithUsdSchema,
+  currentDebtA: AmountWithUsdSchema,
+  currentDebtB: AmountWithUsdSchema,
+  leftoversA: AmountWithUsdSchema,
+  leftoversB: AmountWithUsdSchema,
+  yieldA: AmountWithUsdSchema,
+  yieldB: AmountWithUsdSchema,
+  compoundedYieldA: AmountWithUsdSchema,
+  compoundedYieldB: AmountWithUsdSchema,
+  totalA: AmountWithUsdSchema,
+  totalB: AmountWithUsdSchema,
+  pnlA: TokensPnlSchema,
+  pnlB: TokensPnlSchema,
+  pnlUsd: UsdPnlSchema,
+  openedAt: import_zod5.default.coerce.date(),
+  closedAt: import_zod5.default.nullable(import_zod5.default.coerce.date())
+});
+var TunaLpPositionHistorical = import_zod5.default.object({
+  positionAddress: import_zod5.default.string(),
+  authority: import_zod5.default.string(),
+  pool: import_zod5.default.string(),
   state: TunaPositionStateSchema,
-  lowerPrice: import_zod.z.number(),
-  upperPrice: import_zod.z.number(),
-  lowerLimitOrder: import_zod.z.number().nullable(),
-  upperLimitOrder: import_zod.z.number().nullable(),
+  lowerPrice: import_zod5.default.number(),
+  upperPrice: import_zod5.default.number(),
+  lowerLimitOrder: import_zod5.default.number().nullable(),
+  upperLimitOrder: import_zod5.default.number().nullable(),
   marketMaker: PoolProviderSchema,
-  openedAt: import_zod.z.coerce.date(),
-  closedAt: import_zod.z.coerce.date().nullable(),
-  totalValueUsd: import_zod.z.number(),
-  leverage: import_zod.z.number(),
-  initialLeverage: import_zod.z.number(),
-  totalDepositUsd: import_zod.z.number(),
-  totalWithdrawnUsd: import_zod.z.number(),
-  feesSumUsd: import_zod.z.number(),
-  closedPnlSumUsd: import_zod.z.number(),
-  entryPrice: import_zod.z.number(),
-  exitPrice: import_zod.z.number().nullable()
-});
-var TunaLpPositionParameters = import_zod.z.object({
-  lowerPrice: import_zod.z.number(),
-  upperPrice: import_zod.z.number(),
-  lowerLimitOrder: import_zod.z.number().nullable(),
-  upperLimitOrder: import_zod.z.number().nullable(),
+  openedAt: import_zod5.default.coerce.date(),
+  closedAt: import_zod5.default.coerce.date().nullable(),
+  totalValueUsd: import_zod5.default.number(),
+  leverage: import_zod5.default.number(),
+  initialLeverage: import_zod5.default.number(),
+  totalDepositUsd: import_zod5.default.number(),
+  totalWithdrawnUsd: import_zod5.default.number(),
+  feesSumUsd: import_zod5.default.number(),
+  closedPnlSumUsd: import_zod5.default.number(),
+  entryPrice: import_zod5.default.number(),
+  exitPrice: import_zod5.default.number().nullable()
+});
+var TunaPositionLegacy = import_zod5.default.object({
+  address: import_zod5.default.string(),
+  authority: import_zod5.default.string(),
+  version: import_zod5.default.number(),
+  state: TunaPositionStateSchema,
+  positionMint: import_zod5.default.string(),
+  liquidity: import_zod5.default.coerce.bigint(),
+  tickLowerIndex: import_zod5.default.number(),
+  tickUpperIndex: import_zod5.default.number(),
+  entrySqrtPrice: import_zod5.default.coerce.bigint(),
+  lowerLimitOrderSqrtPrice: import_zod5.default.coerce.bigint(),
+  upperLimitOrderSqrtPrice: import_zod5.default.coerce.bigint(),
+  flags: import_zod5.default.number(),
+  pool: import_zod5.default.string(),
+  poolSqrtPrice: import_zod5.default.coerce.bigint(),
+  depositedCollateralA: AmountWithoutUsdSchema,
+  depositedCollateralB: AmountWithoutUsdSchema,
+  depositedCollateralUsd: import_zod5.default.object({
+    amount: import_zod5.default.number()
+  }),
+  loanFundsA: AmountWithUsdSchema,
+  loanFundsB: AmountWithUsdSchema,
+  currentLoanA: AmountWithUsdSchema,
+  currentLoanB: AmountWithUsdSchema,
+  leftoversA: AmountWithUsdSchema,
+  leftoversB: AmountWithUsdSchema,
+  yieldA: AmountWithUsdSchema,
+  yieldB: AmountWithUsdSchema,
+  compoundedYieldA: AmountWithUsdSchema,
+  compoundedYieldB: AmountWithUsdSchema,
+  totalA: AmountWithUsdSchema,
+  totalB: AmountWithUsdSchema,
+  pnlA: TokensPnlSchema,
+  pnlB: TokensPnlSchema,
+  pnlUsd: UsdPnlSchema,
+  openedAt: import_zod5.default.coerce.date(),
+  updatedAtSlot: import_zod5.default.coerce.bigint(),
+  closedAt: import_zod5.default.nullable(import_zod5.default.coerce.date())
+});
+var TunaLpPositionParameters = import_zod5.default.object({
+  lowerPrice: import_zod5.default.number(),
+  upperPrice: import_zod5.default.number(),
+  lowerLimitOrder: import_zod5.default.number().nullable(),
+  upperLimitOrder: import_zod5.default.number().nullable(),
   lowerLimitOrderSwap: LpPositionLimitOrderSwapSchema,
   upperLimitOrderSwap: LpPositionLimitOrderSwapSchema,
   autoCompound: LpPositionAutoCompoundSchema,
   rebalance: LpPositionRebalanceSchema,
-  rebalanceThresholdTicks: import_zod.z.number()
-});
-var TunaLpPositionValue = import_zod.z.object({
-  totalValueA: import_zod.z.number(),
-  totalValueB: import_zod.z.number(),
-  totalValueUsd: import_zod.z.number(),
-  loanFundsA: import_zod.z.number(),
-  loanFundsB: import_zod.z.number(),
-  loanFundsUsd: import_zod.z.number(),
-  leverage: import_zod.z.number()
-});
-var TunaLpPositionTransfer = import_zod.z.object({
-  amountA: import_zod.z.number(),
-  amountB: import_zod.z.number(),
-  amountUsd: import_zod.z.number()
-});
-var TunaLpPositionTokenPrices = import_zod.z.object({
-  tokenPriceA: import_zod.z.number(),
-  tokenPriceB: import_zod.z.number()
-});
-var TunaLpPositionActionOpen = import_zod.z.object({
+  rebalanceThresholdTicks: import_zod5.default.number()
+});
+var TunaLpPositionValue = import_zod5.default.object({
+  totalValueA: import_zod5.default.number(),
+  totalValueB: import_zod5.default.number(),
+  totalValueUsd: import_zod5.default.number(),
+  loanFundsA: import_zod5.default.number(),
+  loanFundsB: import_zod5.default.number(),
+  loanFundsUsd: import_zod5.default.number(),
+  leverage: import_zod5.default.number()
+});
+var TunaLpPositionTransfer = import_zod5.default.object({
+  amountA: import_zod5.default.number(),
+  amountB: import_zod5.default.number(),
+  amountUsd: import_zod5.default.number()
+});
+var TunaLpPositionTokenPrices = import_zod5.default.object({
+  tokenPriceA: import_zod5.default.number(),
+  tokenPriceB: import_zod5.default.number()
+});
+var TunaLpPositionActionOpen = import_zod5.default.object({
   parameters: TunaLpPositionParameters
 });
-var TunaLpPositionActionClose = import_zod.z.object({
+var TunaLpPositionActionClose = import_zod5.default.object({
   toOwner: TunaLpPositionTransfer.nullable(),
   prices: TunaLpPositionTokenPrices.nullable()
 });
-var TunaLpPositionActionIncreaseLiquidity = import_zod.z.object({
+var TunaLpPositionActionIncreaseLiquidity = import_zod5.default.object({
   fromPosition: TunaLpPositionValue.nullable(),
   toPosition: TunaLpPositionValue,
   fromOwner: TunaLpPositionTransfer,
@@ -563,9 +443,9 @@ var TunaLpPositionActionIncreaseLiquidity = import_zod.z.object({
   protocolFees: TunaLpPositionTransfer,
   prices: TunaLpPositionTokenPrices
 });
-var TunaLpPositionActionDecreaseLiquidity = import_zod.z.object({
-  withdrawPercent: import_zod.z.number(),
-  closedPnlUsd: import_zod.z.number(),
+var TunaLpPositionActionDecreaseLiquidity = import_zod5.default.object({
+  withdrawPercent: import_zod5.default.number(),
+  closedPnlUsd: import_zod5.default.number(),
   fromPosition: TunaLpPositionValue,
   toPosition: TunaLpPositionValue.nullable(),
   toOwner: TunaLpPositionTransfer,
@@ -573,28 +453,28 @@ var TunaLpPositionActionDecreaseLiquidity = import_zod.z.object({
   collectedFees: TunaLpPositionTransfer,
   prices: TunaLpPositionTokenPrices
 });
-var TunaLpPositionActionLiquidate = import_zod.z.object({
-  withdrawPercent: import_zod.z.number(),
+var TunaLpPositionActionLiquidate = import_zod5.default.object({
+  withdrawPercent: import_zod5.default.number(),
   fromPosition: TunaLpPositionValue,
   toLending: TunaLpPositionTransfer,
   protocolFees: TunaLpPositionTransfer,
   prices: TunaLpPositionTokenPrices
 });
-var TunaLpPositionActionRepayDebt = import_zod.z.object({
+var TunaLpPositionActionRepayDebt = import_zod5.default.object({
   fromPosition: TunaLpPositionValue,
   toPosition: TunaLpPositionValue,
   fromOwner: TunaLpPositionTransfer,
   toLending: TunaLpPositionTransfer,
   prices: TunaLpPositionTokenPrices
 });
-var TunaLpPositionActionCollectFees = import_zod.z.object({
-  closedPnlUsd: import_zod.z.number(),
+var TunaLpPositionActionCollectFees = import_zod5.default.object({
+  closedPnlUsd: import_zod5.default.number(),
   position: TunaLpPositionValue,
   collectedFees: TunaLpPositionTransfer,
   toOwner: TunaLpPositionTransfer,
   prices: TunaLpPositionTokenPrices
 });
-var TunaLpPositionActionCollectAndCompoundFees = import_zod.z.object({
+var TunaLpPositionActionCollectAndCompoundFees = import_zod5.default.object({
   fromPosition: TunaLpPositionValue,
   toPosition: TunaLpPositionValue,
   collectedFees: TunaLpPositionTransfer,
@@ -602,15 +482,15 @@ var TunaLpPositionActionCollectAndCompoundFees = import_zod.z.object({
   protocolFees: TunaLpPositionTransfer,
   prices: TunaLpPositionTokenPrices
 });
-var TunaLpPositionActionParametersUpdate = import_zod.z.object({
+var TunaLpPositionActionParametersUpdate = import_zod5.default.object({
   fromParameters: TunaLpPositionParameters,
   toParameters: TunaLpPositionParameters
 });
-var TunaLpPositionAction = import_zod.z.object({
+var TunaLpPositionAction = import_zod5.default.object({
   action: LpPositionsActionTypeSchema,
-  txSignature: import_zod.z.string(),
-  txTimestamp: import_zod.z.coerce.date(),
-  data: import_zod.z.object({
+  txSignature: import_zod5.default.string(),
+  txTimestamp: import_zod5.default.coerce.date(),
+  data: import_zod5.default.object({
     /** defined for: IncreaseLiquidity, DecreaseLiquidity, Liquidate, ExecuteLimitOrder, RepayDebt, CollectAndCompoundFees */
     fromPosition: TunaLpPositionValue.optional().nullable(),
     /** defined for: IncreaseLiquidity, DecreaseLiquidity, Liquidate, ExecuteLimitOrder, RepayDebt, CollectAndCompoundFees */
@@ -638,324 +518,548 @@ var TunaLpPositionAction = import_zod.z.object({
     /** defined for: ParametersUpdate */
     toParameters: TunaLpPositionParameters.optional(),
     /** defined for: DecreaseLiquidity */
-    withdrawPercent: import_zod.z.number().optional(),
+    withdrawPercent: import_zod5.default.number().optional(),
     /** defined for: DecreaseLiquidity, CollectFees */
-    closedPnlUsd: import_zod.z.number().optional()
+    closedPnlUsd: import_zod5.default.number().optional()
   })
 });
-var TunaSpotPosition = import_zod.z.object({
-  address: import_zod.z.string(),
-  authority: import_zod.z.string(),
-  version: import_zod.z.number(),
+
+// src/client/schemas/spot_positions.ts
+var import_zod6 = require("zod");
+var TunaSpotPositionState = {
+  OPEN: "open",
+  CLOSED: "closed"
+};
+var TunaSpotPositionStateSchema = import_zod6.z.enum([
+  TunaSpotPositionState.OPEN,
+  ...Object.values(TunaSpotPositionState)
+]);
+var TunaSpotPosition = import_zod6.z.object({
+  address: import_zod6.z.string(),
+  authority: import_zod6.z.string(),
+  version: import_zod6.z.number(),
   state: TunaSpotPositionStateSchema,
-  entrySqrtPrice: import_zod.z.coerce.bigint(),
-  lowerLimitOrderSqrtPrice: import_zod.z.coerce.bigint(),
-  upperLimitOrderSqrtPrice: import_zod.z.coerce.bigint(),
-  flags: import_zod.z.number(),
-  pool: import_zod.z.string(),
-  poolSqrtPrice: import_zod.z.coerce.bigint(),
-  collateralToken: import_zod.z.string(),
-  borrowToken: import_zod.z.string(),
-  positionToken: import_zod.z.string(),
-  collateral: amountWithUsd,
-  loanFunds: amountWithUsd,
-  currentLoan: amountWithUsd,
-  total: amountWithUsd,
-  uiLiquidationPrice: import_zod.z.nullable(import_zod.z.number()),
-  pnlUsd: usdPnl,
-  leverage: import_zod.z.number(),
-  openedAt: import_zod.z.coerce.date(),
-  openedAtSlot: import_zod.z.coerce.bigint(),
-  updatedAtSlot: import_zod.z.coerce.bigint(),
-  closedAt: import_zod.z.nullable(import_zod.z.coerce.date())
-});
-var PoolSwap = import_zod.z.object({
-  id: import_zod.z.string(),
-  amountIn: import_zod.z.coerce.bigint(),
-  amountOut: import_zod.z.coerce.bigint(),
-  amountUsd: import_zod.z.number(),
-  aToB: import_zod.z.boolean(),
-  pool: import_zod.z.string(),
-  time: import_zod.z.coerce.date()
-});
-var OrderBookEntry = import_zod.z.object({
-  concentratedAmount: import_zod.z.coerce.bigint(),
-  concentratedAmountQuote: import_zod.z.coerce.bigint(),
-  concentratedTotal: import_zod.z.coerce.bigint(),
-  concentratedTotalQuote: import_zod.z.coerce.bigint(),
-  limitAmount: import_zod.z.coerce.bigint(),
-  limitAmountQuote: import_zod.z.coerce.bigint(),
-  limitTotal: import_zod.z.coerce.bigint(),
-  limitTotalQuote: import_zod.z.coerce.bigint(),
-  price: import_zod.z.number(),
-  askSide: import_zod.z.boolean()
-});
-var PoolPriceUpdate = import_zod.z.object({
-  pool: import_zod.z.string(),
-  price: import_zod.z.number(),
-  sqrtPrice: import_zod.z.coerce.bigint(),
-  time: import_zod.z.coerce.date()
-});
-var OrderBook = import_zod.z.object({
-  entries: OrderBookEntry.array(),
-  poolPrice: import_zod.z.number()
-});
-var LimitOrder = import_zod.z.object({
-  address: import_zod.z.string(),
-  mint: import_zod.z.string(),
-  pool: import_zod.z.string(),
-  state: LimitOrderStateSchema,
-  aToB: import_zod.z.boolean(),
-  tickIndex: import_zod.z.number(),
-  fillRatio: import_zod.z.number(),
-  openTxSignature: import_zod.z.string(),
-  closeTxSignature: import_zod.z.nullable(import_zod.z.string()),
-  amountIn: amountWithUsd,
-  amountOut: amountWithUsd,
-  openedAt: import_zod.z.coerce.date(),
-  closedAt: import_zod.z.nullable(import_zod.z.coerce.date())
-});
-var TradeHistoryEntry = import_zod.z.object({
-  // Internal entry ID
-  id: import_zod.z.string(),
-  pool: import_zod.z.string(),
-  authority: import_zod.z.string(),
-  aToB: import_zod.z.boolean(),
-  // Trade action which created entry
-  action: TradeHistoryActionSchema,
-  // Trade direction formatted for ui display
-  uiDirection: TradeHistoryUIDirectionSchema,
-  // Trade price formatted for ui display
-  uiPrice: import_zod.z.number(),
-  baseToken: amountWithUsd,
-  quoteToken: amountWithUsd,
-  fee: amountWithUsd,
-  pnl: import_zod.z.nullable(
-    import_zod.z.object({
-      usd: import_zod.z.number(),
-      bps: import_zod.z.number()
-    })
-  ),
-  txSignature: import_zod.z.nullable(import_zod.z.string()),
-  positionAddress: import_zod.z.nullable(import_zod.z.string()),
-  slot: import_zod.z.coerce.bigint(),
-  ts: import_zod.z.coerce.date()
-});
-var OrderHistoryEntry = import_zod.z.object({
-  // Internal entry ID
-  id: import_zod.z.string(),
-  pool: import_zod.z.string(),
-  authority: import_zod.z.string(),
-  orderType: OrderHistoryOrderTypeSchema,
-  isReduceOnly: import_zod.z.nullable(import_zod.z.boolean()),
-  aToB: import_zod.z.boolean(),
-  uiDirection: OrderHistoryUIDirectionSchema,
-  uiPrice: import_zod.z.nullable(import_zod.z.number()),
-  uiExecutionPrice: import_zod.z.nullable(import_zod.z.number()),
-  status: OrderHistoryStatusSchema,
-  baseToken: amountWithUsd,
-  quoteToken: amountWithUsd,
-  baseTokenConsumedAmount: import_zod.z.nullable(amountWithUsd),
-  quoteTokenFilledAmount: import_zod.z.nullable(amountWithUsd),
-  txSignature: import_zod.z.nullable(import_zod.z.string()),
-  positionAddress: import_zod.z.nullable(import_zod.z.string()),
-  slot: import_zod.z.coerce.bigint(),
-  ts: import_zod.z.coerce.date()
-});
-var StakingTreasury = import_zod.z.object({
-  address: import_zod.z.string(),
-  stakedTokenMint: import_zod.z.string(),
-  rewardTokenMint: import_zod.z.string(),
-  apy: import_zod.z.number(),
-  uniqueStakers: import_zod.z.number(),
-  totalStaked: amountWithUsd,
-  totalReward: amountWithUsd,
-  unstakeCooldownSeconds: import_zod.z.number(),
-  isStakingEnabled: import_zod.z.boolean(),
-  isUnstakingEnabled: import_zod.z.boolean(),
-  isWithdrawEnabled: import_zod.z.boolean()
-});
-var StakingPosition = import_zod.z.object({
-  address: import_zod.z.string(),
-  owner: import_zod.z.string(),
-  staked: amountWithUsd,
-  unstaked: amountWithUsd,
-  claimedReward: amountWithUsd,
-  unclaimedReward: amountWithUsd,
-  rank: import_zod.z.nullable(import_zod.z.number()),
-  vesting: import_zod.z.object({
-    locked: amountWithUsd,
-    unlocked: amountWithUsd,
-    unlockRate: import_zod.z.coerce.bigint(),
-    unlockEverySeconds: import_zod.z.number(),
-    unlockCliffSeconds: import_zod.z.number(),
-    lockedAt: import_zod.z.nullable(import_zod.z.coerce.date())
-  }),
-  lastUnstakedAt: import_zod.z.nullable(import_zod.z.coerce.date()),
-  withdrawAvailableAt: import_zod.z.nullable(import_zod.z.coerce.date())
-});
-var StakingLeaderboardPosition = import_zod.z.object({
-  rank: import_zod.z.number(),
-  address: import_zod.z.string(),
-  owner: import_zod.z.string(),
-  staked: amountWithUsd
-});
-var StakingLeaderboardPage = import_zod.z.object({
-  data: StakingLeaderboardPosition.array(),
-  meta: PaginationMeta
+  lowerLimitOrderPrice: import_zod6.z.number(),
+  upperLimitOrderPrice: import_zod6.z.number(),
+  entryPrice: import_zod6.z.number(),
+  mintA: Mint,
+  mintB: Mint,
+  pool: TunaPositionPoolSchema,
+  positionToken: TunaPositionPoolToken,
+  collateralToken: TunaPositionPoolToken,
+  marketMaker: PoolProviderSchema,
+  depositedCollateral: AmountWithUsdSchema,
+  initialDebt: AmountWithUsdSchema,
+  currentDebt: AmountWithUsdSchema,
+  total: AmountWithUsdSchema,
+  leverage: import_zod6.z.number(),
+  maxLeverage: import_zod6.z.number(),
+  liquidationPrice: import_zod6.z.number(),
+  pnlUsd: UsdPnlSchema,
+  openedAt: import_zod6.z.coerce.date(),
+  closedAt: import_zod6.z.nullable(import_zod6.z.coerce.date())
 });
-var StakingPositionHistoryAction = import_zod.z.object({
-  position: import_zod.z.string(),
-  action: StakingPositionHistoryActionTypeSchema,
-  txSignature: import_zod.z.string(),
-  amount: import_zod.z.coerce.bigint(),
-  time: import_zod.z.coerce.date()
-});
-var PoolPriceCandle = import_zod.z.object({
-  time: import_zod.z.number(),
-  open: import_zod.z.number(),
-  close: import_zod.z.number(),
-  high: import_zod.z.number(),
-  low: import_zod.z.number(),
-  volume: import_zod.z.number()
-});
-var FeesStatsGroup = import_zod.z.object({
-  time: import_zod.z.coerce.date(),
-  addLiquidityFees: import_zod.z.number(),
-  limitOrderFees: import_zod.z.number(),
-  yieldCompoundingFees: import_zod.z.number(),
-  liquidationFees: import_zod.z.number(),
-  totalLiquidationsNetworkFees: import_zod.z.number(),
-  totalLimitOrdersNetworkFees: import_zod.z.number(),
-  totalYieldCompoundingNetworkFees: import_zod.z.number(),
-  failedNetworkFees: import_zod.z.number(),
-  processedNetworkFees: import_zod.z.number(),
-  totalCollectedFees: import_zod.z.number(),
-  totalNetworkFees: import_zod.z.number(),
-  jitoLiquidationFees: import_zod.z.number(),
-  jitoLimitOrderFees: import_zod.z.number(),
-  jitoYieldCompoundingFees: import_zod.z.number(),
-  runningAddLiquidityFees: import_zod.z.number(),
-  runningLimitOrderFees: import_zod.z.number(),
-  runningYieldCompoundingFees: import_zod.z.number(),
-  runningLiquidationFees: import_zod.z.number(),
-  runningTotalLiquidationsNetworkFees: import_zod.z.number(),
-  runningTotalLimitOrdersNetworkFees: import_zod.z.number(),
-  runningTotalYieldCompoundingNetworkFees: import_zod.z.number(),
-  runningFailedNetworkFees: import_zod.z.number(),
-  runningProcessedNetworkFees: import_zod.z.number(),
-  runningJitoLiquidationFees: import_zod.z.number(),
-  runningJitoLimitOrderFees: import_zod.z.number(),
-  runningJitoYieldCompoundingFees: import_zod.z.number(),
-  runningTotalCollectedFees: import_zod.z.number(),
-  runningTotalNetworkFees: import_zod.z.number()
-});
-var StakingRevenueStatsGroup = import_zod.z.object({
-  time: import_zod.z.coerce.date(),
-  totalDepositsUsd: import_zod.z.number(),
-  totalDepositsSol: import_zod.z.coerce.bigint(),
-  runningTotalDepositsUsd: import_zod.z.number(),
-  runningTotalDepositsSol: import_zod.z.coerce.bigint()
-});
-var IncreaseSpotPositionQuote = import_zod.z.object({
+var IncreaseSpotPositionQuote = import_zod6.z.object({
   /** Required collateral amount */
-  collateralAmount: import_zod.z.coerce.bigint(),
+  collateralAmount: import_zod6.z.coerce.bigint(),
   /** Required amount to borrow */
-  borrowAmount: import_zod.z.coerce.bigint(),
+  borrowAmount: import_zod6.z.coerce.bigint(),
   /** Estimated position size in the position token. */
-  estimatedAmount: import_zod.z.coerce.bigint(),
+  estimatedAmount: import_zod6.z.coerce.bigint(),
   /** Swap input amount. */
-  swapInputAmount: import_zod.z.coerce.bigint(),
+  swapInputAmount: import_zod6.z.coerce.bigint(),
   /** Minimum swap output amount according to the provided slippage. */
-  minSwapOutputAmount: import_zod.z.coerce.bigint(),
+  minSwapOutputAmount: import_zod6.z.coerce.bigint(),
   /** Protocol fee in token A */
-  protocolFeeA: import_zod.z.coerce.bigint(),
+  protocolFeeA: import_zod6.z.coerce.bigint(),
   /** Protocol fee in token B */
-  protocolFeeB: import_zod.z.coerce.bigint(),
+  protocolFeeB: import_zod6.z.coerce.bigint(),
   /** Price impact in percents */
-  priceImpact: import_zod.z.number(),
+  priceImpact: import_zod6.z.number(),
   /** Liquidation price */
-  uiLiquidationPrice: import_zod.z.nullable(import_zod.z.number())
+  liquidationPrice: import_zod6.z.number()
 });
-var DecreaseSpotPositionQuote = import_zod.z.object({
+var DecreaseSpotPositionQuote = import_zod6.z.object({
   /** Confirmed position decrease percentage (100% = 1.0) */
-  decreasePercent: import_zod.z.number(),
+  decreasePercent: import_zod6.z.number(),
   /** The maximum acceptable swap input amount for position decrease according to the provided slippage
    * (if collateral_token == position_token) OR the minimum swap output amount (if collateral_token != position_token).
    */
-  requiredSwapAmount: import_zod.z.coerce.bigint(),
+  requiredSwapAmount: import_zod6.z.coerce.bigint(),
   /**  Estimated total amount of the adjusted position */
-  estimatedAmount: import_zod.z.coerce.bigint(),
+  estimatedAmount: import_zod6.z.coerce.bigint(),
   /** Estimated amount of the withdrawn collateral */
-  estimatedWithdrawnCollateral: import_zod.z.coerce.bigint(),
+  estimatedWithdrawnCollateral: import_zod6.z.coerce.bigint(),
   /** Price impact in percents */
-  priceImpact: import_zod.z.number(),
+  priceImpact: import_zod6.z.number(),
   /** Liquidation price */
-  uiLiquidationPrice: import_zod.z.nullable(import_zod.z.number())
+  liquidationPrice: import_zod6.z.number()
 });
-var CloseSpotPositionQuote = import_zod.z.object({
+var CloseSpotPositionQuote = import_zod6.z.object({
   /** Position decrease percentage */
-  decreasePercent: import_zod.z.number(),
+  decreasePercent: import_zod6.z.number(),
   /** The maximum acceptable swap input amount for position decrease according to the provided slippage
    * (if collateral_token == position_token) OR the minimum swap output amount (if collateral_token != position_token).
    */
-  requiredSwapAmount: import_zod.z.coerce.bigint(),
+  requiredSwapAmount: import_zod6.z.coerce.bigint(),
   /** Estimated amount of the withdrawn collateral */
-  estimatedWithdrawnCollateral: import_zod.z.coerce.bigint(),
+  estimatedWithdrawnCollateral: import_zod6.z.coerce.bigint(),
   /** Price impact in percents */
-  priceImpact: import_zod.z.number()
+  priceImpact: import_zod6.z.number()
 });
-var SwapQuoteByInput = import_zod.z.object({
-  estimatedAmountOut: import_zod.z.coerce.bigint(),
-  minAmountOut: import_zod.z.coerce.bigint(),
-  feeAmount: import_zod.z.coerce.bigint(),
-  feeUsd: import_zod.z.number(),
-  /** Price impact in percents */
-  priceImpact: import_zod.z.number()
+
+// src/client/schemas/state_snapshot.ts
+var import_zod7 = __toESM(require("zod"));
+var PoolPriceUpdate = import_zod7.default.object({
+  pool: import_zod7.default.string(),
+  price: import_zod7.default.number(),
+  sqrtPrice: import_zod7.default.coerce.bigint(),
+  time: import_zod7.default.coerce.date()
+});
+var StateSnapshot = import_zod7.default.object({
+  slot: import_zod7.default.coerce.bigint(),
+  blockTime: import_zod7.default.coerce.date(),
+  poolPrices: import_zod7.default.optional(import_zod7.default.record(import_zod7.default.string(), PoolPriceUpdate)),
+  tunaSpotPositions: import_zod7.default.optional(import_zod7.default.array(TunaSpotPosition)),
+  tunaLpPositions: import_zod7.default.optional(import_zod7.default.array(TunaLpPositionDtoSchema)),
+  fusionLimitOrders: import_zod7.default.optional(import_zod7.default.array(LimitOrder))
 });
-var SwapQuoteByOutput = import_zod.z.object({
-  estimatedAmountIn: import_zod.z.coerce.bigint(),
-  maxAmountIn: import_zod.z.coerce.bigint(),
-  feeAmount: import_zod.z.coerce.bigint(),
-  feeUsd: import_zod.z.number(),
+
+// src/client/schemas.ts
+var NotificationEntity = {
+  POOL_SWAP: "pool_swap",
+  POOL_PRICE: "pool_price",
+  ORDER_BOOK: "order_book",
+  TUNA_POSITION: "tuna_position",
+  TUNA_SPOT_POSITION: "tuna_spot_position",
+  LENDING_POSITION: "lending_position",
+  STAKING_POSITION: "staking_position",
+  FUSION_LIMIT_ORDER: "fusion_limit_order",
+  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_PRICES: "pool_prices",
+  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 = import_zod8.z.enum([NotificationEntity.POOL_SWAP, ...Object.values(NotificationEntity)]);
+var NotificationActionSchema = import_zod8.z.enum([NotificationAction.CREATE, ...Object.values(NotificationAction)]);
+var TradeHistoryActionSchema = import_zod8.z.enum([TradeHistoryAction.SWAP, ...Object.values(TradeHistoryAction)]);
+var TradeHistoryUIDirectionSchema = import_zod8.z.enum([
+  TradeHistoryUIDirection.BUY,
+  ...Object.values(TradeHistoryUIDirection)
+]);
+var OrderHistoryOrderTypeSchema = import_zod8.z.enum([
+  OrderHistoryOrderType.MARKET,
+  ...Object.values(OrderHistoryOrderType)
+]);
+var OrderHistoryStatusSchema = import_zod8.z.enum([OrderHistoryStatus.OPEN, ...Object.values(OrderHistoryStatus)]);
+var OrderHistoryUIDirectionSchema = import_zod8.z.enum([
+  OrderHistoryUIDirection.BUY,
+  ...Object.values(OrderHistoryUIDirection)
+]);
+var StakingPositionHistoryActionTypeSchema = import_zod8.z.enum([
+  StakingPositionHistoryActionType.STAKE,
+  ...Object.values(StakingPositionHistoryActionType)
+]);
+var PoolSubscriptionTopicSchema = import_zod8.z.enum([
+  PoolSubscriptionTopic.ORDER_BOOK,
+  ...Object.values(PoolSubscriptionTopic)
+]);
+var WalletSubscriptionTopicSchema = import_zod8.z.enum([
+  WalletSubscriptionTopic.TUNA_POSITIONS,
+  ...Object.values(WalletSubscriptionTopic)
+]);
+var PaginationMeta = import_zod8.z.object({
+  total: import_zod8.z.number()
+});
+var Market = import_zod8.z.object({
+  address: import_zod8.z.string(),
+  addressLookupTable: import_zod8.z.string(),
+  poolAddress: import_zod8.z.string(),
+  poolFeeRate: import_zod8.z.number(),
+  provider: PoolProviderSchema,
+  maxLeverage: import_zod8.z.number(),
+  maxSwapSlippage: import_zod8.z.number(),
+  protocolFee: import_zod8.z.number(),
+  rebalanceProtocolFee: import_zod8.z.number(),
+  protocolFeeOnCollateral: import_zod8.z.number(),
+  liquidationFee: import_zod8.z.number(),
+  liquidationThreshold: import_zod8.z.number(),
+  oraclePriceDeviationThreshold: import_zod8.z.number(),
+  maxSpotPositionSizeA: AmountWithUsdSchema,
+  maxSpotPositionSizeB: AmountWithUsdSchema,
+  borrowedFundsA: AmountWithUsdSchema,
+  borrowedFundsB: AmountWithUsdSchema,
+  availableBorrowA: AmountWithUsdSchema,
+  availableBorrowB: AmountWithUsdSchema,
+  borrowLimitA: AmountWithUsdSchema,
+  borrowLimitB: AmountWithUsdSchema,
+  disabled: import_zod8.z.boolean(),
+  createdAt: import_zod8.z.coerce.date()
+});
+var TokenOraclePrice = import_zod8.z.object({
+  mint: import_zod8.z.string(),
+  price: import_zod8.z.coerce.bigint(),
+  decimals: import_zod8.z.number(),
+  time: import_zod8.z.coerce.date()
+});
+var Vault = import_zod8.z.object({
+  address: import_zod8.z.string(),
+  mint: import_zod8.z.string(),
+  depositedFunds: AmountWithUsdSchema,
+  borrowedFunds: AmountWithUsdSchema,
+  supplyLimit: AmountWithUsdSchema,
+  borrowedShares: import_zod8.z.coerce.bigint(),
+  depositedShares: import_zod8.z.coerce.bigint(),
+  supplyApy: import_zod8.z.number(),
+  borrowApy: import_zod8.z.number(),
+  interestRate: import_zod8.z.coerce.bigint(),
+  utilization: import_zod8.z.number(),
+  pythOracleFeedId: import_zod8.z.string(),
+  pythOraclePriceUpdate: import_zod8.z.string()
+});
+var VaultHistoricalStats = import_zod8.z.object({
+  date: import_zod8.z.preprocess((val, ctx) => {
+    if (typeof val === "string") {
+      const [year, month, day] = val.split("-").map(Number);
+      return new Date(year, month - 1, day);
+    }
+    ctx.addIssue({
+      code: "custom",
+      message: "Not a valid date string"
+    });
+    return import_zod8.z.NEVER;
+  }, import_zod8.z.date()),
+  supply: AmountWithUsdSchema,
+  borrow: AmountWithUsdSchema,
+  supplyApy: import_zod8.z.number(),
+  borrowApr: import_zod8.z.number()
+});
+var Pool = import_zod8.z.object({
+  address: import_zod8.z.string(),
+  provider: PoolProviderSchema,
+  tokenAMint: import_zod8.z.string(),
+  tokenBMint: import_zod8.z.string(),
+  tokenAVault: import_zod8.z.string(),
+  tokenBVault: import_zod8.z.string(),
+  tvlUsdc: import_zod8.z.coerce.number(),
+  priceChange24H: import_zod8.z.number(),
+  tickSpacing: import_zod8.z.number(),
+  feeRate: import_zod8.z.number(),
+  olpFeeRate: import_zod8.z.nullable(import_zod8.z.number()),
+  protocolFeeRate: import_zod8.z.number(),
+  liquidity: import_zod8.z.coerce.bigint(),
+  sqrtPrice: import_zod8.z.coerce.bigint(),
+  tickCurrentIndex: import_zod8.z.number(),
+  stats: import_zod8.z.object({
+    "24h": import_zod8.z.object({
+      volume: import_zod8.z.coerce.number(),
+      fees: import_zod8.z.coerce.number(),
+      rewards: import_zod8.z.coerce.number(),
+      yieldOverTvl: import_zod8.z.coerce.number()
+    }),
+    "7d": import_zod8.z.object({
+      volume: import_zod8.z.coerce.number(),
+      fees: import_zod8.z.coerce.number(),
+      rewards: import_zod8.z.coerce.number(),
+      yieldOverTvl: import_zod8.z.coerce.number()
+    }),
+    "30d": import_zod8.z.object({
+      volume: import_zod8.z.coerce.number(),
+      fees: import_zod8.z.coerce.number(),
+      rewards: import_zod8.z.coerce.number(),
+      yieldOverTvl: import_zod8.z.coerce.number()
+    })
+  })
+});
+var Tick = import_zod8.z.object({
+  index: import_zod8.z.number(),
+  liquidity: import_zod8.z.coerce.bigint()
+});
+var PoolTicks = import_zod8.z.object({
+  tickSpacing: import_zod8.z.number(),
+  ticks: Tick.array()
+});
+var LendingPosition = import_zod8.z.object({
+  address: import_zod8.z.string(),
+  authority: import_zod8.z.string(),
+  mint: import_zod8.z.string(),
+  vault: import_zod8.z.string(),
+  shares: import_zod8.z.coerce.bigint(),
+  funds: AmountWithUsdSchema,
+  earned: AmountWithUsdSchema
+});
+var PoolSwap = import_zod8.z.object({
+  id: import_zod8.z.string(),
+  amountIn: import_zod8.z.coerce.bigint(),
+  amountOut: import_zod8.z.coerce.bigint(),
+  amountUsd: import_zod8.z.number(),
+  aToB: import_zod8.z.boolean(),
+  pool: import_zod8.z.string(),
+  time: import_zod8.z.coerce.date()
+});
+var OrderBookEntry = import_zod8.z.object({
+  concentratedAmount: import_zod8.z.coerce.bigint(),
+  concentratedAmountQuote: import_zod8.z.coerce.bigint(),
+  concentratedTotal: import_zod8.z.coerce.bigint(),
+  concentratedTotalQuote: import_zod8.z.coerce.bigint(),
+  limitAmount: import_zod8.z.coerce.bigint(),
+  limitAmountQuote: import_zod8.z.coerce.bigint(),
+  limitTotal: import_zod8.z.coerce.bigint(),
+  limitTotalQuote: import_zod8.z.coerce.bigint(),
+  price: import_zod8.z.number(),
+  askSide: import_zod8.z.boolean()
+});
+var OrderBook = import_zod8.z.object({
+  entries: OrderBookEntry.array(),
+  poolPrice: import_zod8.z.number()
+});
+var TradeHistoryEntry = import_zod8.z.object({
+  // Internal entry ID
+  id: import_zod8.z.string(),
+  pool: import_zod8.z.string(),
+  authority: import_zod8.z.string(),
+  aToB: import_zod8.z.boolean(),
+  // Trade action which created entry
+  action: TradeHistoryActionSchema,
+  // Trade direction formatted for ui display
+  uiDirection: TradeHistoryUIDirectionSchema,
+  // Trade price formatted for ui display
+  uiPrice: import_zod8.z.number(),
+  baseToken: AmountWithUsdSchema,
+  quoteToken: AmountWithUsdSchema,
+  fee: AmountWithUsdSchema,
+  pnl: import_zod8.z.nullable(
+    import_zod8.z.object({
+      usd: import_zod8.z.number(),
+      bps: import_zod8.z.number()
+    })
+  ),
+  txSignature: import_zod8.z.nullable(import_zod8.z.string()),
+  positionAddress: import_zod8.z.nullable(import_zod8.z.string()),
+  slot: import_zod8.z.coerce.bigint(),
+  ts: import_zod8.z.coerce.date()
+});
+var OrderHistoryEntry = import_zod8.z.object({
+  // Internal entry ID
+  id: import_zod8.z.string(),
+  pool: import_zod8.z.string(),
+  authority: import_zod8.z.string(),
+  orderType: OrderHistoryOrderTypeSchema,
+  isReduceOnly: import_zod8.z.nullable(import_zod8.z.boolean()),
+  aToB: import_zod8.z.boolean(),
+  uiDirection: OrderHistoryUIDirectionSchema,
+  uiPrice: import_zod8.z.nullable(import_zod8.z.number()),
+  uiExecutionPrice: import_zod8.z.nullable(import_zod8.z.number()),
+  status: OrderHistoryStatusSchema,
+  baseToken: AmountWithUsdSchema,
+  quoteToken: AmountWithUsdSchema,
+  baseTokenConsumedAmount: import_zod8.z.nullable(AmountWithUsdSchema),
+  quoteTokenFilledAmount: import_zod8.z.nullable(AmountWithUsdSchema),
+  txSignature: import_zod8.z.nullable(import_zod8.z.string()),
+  positionAddress: import_zod8.z.nullable(import_zod8.z.string()),
+  slot: import_zod8.z.coerce.bigint(),
+  ts: import_zod8.z.coerce.date()
+});
+var StakingTreasury = import_zod8.z.object({
+  address: import_zod8.z.string(),
+  stakedTokenMint: import_zod8.z.string(),
+  rewardTokenMint: import_zod8.z.string(),
+  apy: import_zod8.z.number(),
+  uniqueStakers: import_zod8.z.number(),
+  totalStaked: AmountWithUsdSchema,
+  totalReward: AmountWithUsdSchema,
+  unstakeCooldownSeconds: import_zod8.z.number(),
+  isStakingEnabled: import_zod8.z.boolean(),
+  isUnstakingEnabled: import_zod8.z.boolean(),
+  isWithdrawEnabled: import_zod8.z.boolean()
+});
+var StakingPosition = import_zod8.z.object({
+  address: import_zod8.z.string(),
+  owner: import_zod8.z.string(),
+  staked: AmountWithUsdSchema,
+  unstaked: AmountWithUsdSchema,
+  claimedReward: AmountWithUsdSchema,
+  unclaimedReward: AmountWithUsdSchema,
+  rank: import_zod8.z.nullable(import_zod8.z.number()),
+  vesting: import_zod8.z.object({
+    locked: AmountWithUsdSchema,
+    unlocked: AmountWithUsdSchema,
+    unlockRate: import_zod8.z.coerce.bigint(),
+    unlockEverySeconds: import_zod8.z.number(),
+    unlockCliffSeconds: import_zod8.z.number(),
+    lockedAt: import_zod8.z.nullable(import_zod8.z.coerce.date())
+  }),
+  lastUnstakedAt: import_zod8.z.nullable(import_zod8.z.coerce.date()),
+  withdrawAvailableAt: import_zod8.z.nullable(import_zod8.z.coerce.date())
+});
+var StakingLeaderboardPosition = import_zod8.z.object({
+  rank: import_zod8.z.number(),
+  address: import_zod8.z.string(),
+  owner: import_zod8.z.string(),
+  staked: AmountWithUsdSchema
+});
+var StakingLeaderboardPage = import_zod8.z.object({
+  data: StakingLeaderboardPosition.array(),
+  meta: PaginationMeta
+});
+var StakingPositionHistoryAction = import_zod8.z.object({
+  position: import_zod8.z.string(),
+  action: StakingPositionHistoryActionTypeSchema,
+  txSignature: import_zod8.z.string(),
+  amount: import_zod8.z.coerce.bigint(),
+  time: import_zod8.z.coerce.date()
+});
+var PoolPriceCandle = import_zod8.z.object({
+  time: import_zod8.z.number(),
+  open: import_zod8.z.number(),
+  close: import_zod8.z.number(),
+  high: import_zod8.z.number(),
+  low: import_zod8.z.number(),
+  volume: import_zod8.z.number()
+});
+var FeesStatsGroup = import_zod8.z.object({
+  time: import_zod8.z.coerce.date(),
+  addLiquidityFees: import_zod8.z.number(),
+  limitOrderFees: import_zod8.z.number(),
+  yieldCompoundingFees: import_zod8.z.number(),
+  liquidationFees: import_zod8.z.number(),
+  totalLiquidationsNetworkFees: import_zod8.z.number(),
+  totalLimitOrdersNetworkFees: import_zod8.z.number(),
+  totalYieldCompoundingNetworkFees: import_zod8.z.number(),
+  failedNetworkFees: import_zod8.z.number(),
+  processedNetworkFees: import_zod8.z.number(),
+  totalCollectedFees: import_zod8.z.number(),
+  totalNetworkFees: import_zod8.z.number(),
+  jitoLiquidationFees: import_zod8.z.number(),
+  jitoLimitOrderFees: import_zod8.z.number(),
+  jitoYieldCompoundingFees: import_zod8.z.number(),
+  runningAddLiquidityFees: import_zod8.z.number(),
+  runningLimitOrderFees: import_zod8.z.number(),
+  runningYieldCompoundingFees: import_zod8.z.number(),
+  runningLiquidationFees: import_zod8.z.number(),
+  runningTotalLiquidationsNetworkFees: import_zod8.z.number(),
+  runningTotalLimitOrdersNetworkFees: import_zod8.z.number(),
+  runningTotalYieldCompoundingNetworkFees: import_zod8.z.number(),
+  runningFailedNetworkFees: import_zod8.z.number(),
+  runningProcessedNetworkFees: import_zod8.z.number(),
+  runningJitoLiquidationFees: import_zod8.z.number(),
+  runningJitoLimitOrderFees: import_zod8.z.number(),
+  runningJitoYieldCompoundingFees: import_zod8.z.number(),
+  runningTotalCollectedFees: import_zod8.z.number(),
+  runningTotalNetworkFees: import_zod8.z.number()
+});
+var StakingRevenueStatsGroup = import_zod8.z.object({
+  time: import_zod8.z.coerce.date(),
+  totalDepositsUsd: import_zod8.z.number(),
+  totalDepositsSol: import_zod8.z.coerce.bigint(),
+  runningTotalDepositsUsd: import_zod8.z.number(),
+  runningTotalDepositsSol: import_zod8.z.coerce.bigint()
+});
+var SwapQuoteByInput = import_zod8.z.object({
+  estimatedAmountOut: import_zod8.z.coerce.bigint(),
+  minAmountOut: import_zod8.z.coerce.bigint(),
+  feeAmount: import_zod8.z.coerce.bigint(),
+  feeUsd: import_zod8.z.number(),
   /** Price impact in percents */
-  priceImpact: import_zod.z.number()
+  priceImpact: import_zod8.z.number()
 });
-var StateSnapshot = import_zod.z.object({
-  slot: import_zod.z.coerce.bigint(),
-  blockTime: import_zod.z.coerce.date(),
-  poolPrices: import_zod.z.optional(import_zod.z.record(import_zod.z.string(), PoolPriceUpdate)),
-  tunaSpotPositions: import_zod.z.optional(import_zod.z.array(TunaSpotPosition)),
-  tunaLpPositions: import_zod.z.optional(import_zod.z.array(TunaPosition)),
-  fusionLimitOrders: import_zod.z.optional(import_zod.z.array(LimitOrder))
+var SwapQuoteByOutput = import_zod8.z.object({
+  estimatedAmountIn: import_zod8.z.coerce.bigint(),
+  maxAmountIn: import_zod8.z.coerce.bigint(),
+  feeAmount: import_zod8.z.coerce.bigint(),
+  feeUsd: import_zod8.z.number(),
+  /** Price impact in percents */
+  priceImpact: import_zod8.z.number()
 });
-var LimitOrderQuoteByInput = import_zod.z.object({
-  amountOut: import_zod.z.coerce.bigint()
+var LimitOrderQuoteByInput = import_zod8.z.object({
+  amountOut: import_zod8.z.coerce.bigint()
 });
-var LimitOrderQuoteByOutput = import_zod.z.object({
-  amountIn: import_zod.z.coerce.bigint()
+var LimitOrderQuoteByOutput = import_zod8.z.object({
+  amountIn: import_zod8.z.coerce.bigint()
 });
-var TradableAmount = amountWithUsd;
-var UpdateStreamSubscriptionResult = import_zod.z.object({
-  status: import_zod.z.string()
+var TradableAmount = AmountWithUsdSchema;
+var UpdateStreamSubscriptionResult = import_zod8.z.object({
+  status: import_zod8.z.string()
 });
-var createNotificationSchema = (dataSchema, metaSchema) => import_zod.z.object({
+var createNotificationSchema = (dataSchema, metaSchema) => import_zod8.z.object({
   entity: NotificationEntitySchema,
   action: NotificationActionSchema,
   data: dataSchema,
-  id: import_zod.z.string(),
-  authority: import_zod.z.nullish(import_zod.z.string()),
-  ...metaSchema ? { meta: metaSchema } : { meta: import_zod.z.undefined().nullable() }
+  id: import_zod8.z.string(),
+  authority: import_zod8.z.nullish(import_zod8.z.string()),
+  ...metaSchema ? { meta: metaSchema } : { meta: import_zod8.z.undefined().nullable() }
 });
-var OrderBookNotificationMeta = import_zod.z.object({
-  pool: import_zod.z.string(),
-  priceStep: import_zod.z.number(),
-  inverted: import_zod.z.boolean()
+var OrderBookNotificationMeta = import_zod8.z.object({
+  pool: import_zod8.z.string(),
+  priceStep: import_zod8.z.number(),
+  inverted: import_zod8.z.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);
@@ -1133,11 +1237,11 @@ 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 = {};
@@ -1166,7 +1270,7 @@ var TunaApiClient = class {
       }
     }
     const url = this.appendUrlSearchParams(this.buildURL(`users/${userAddress}/lp-positions`), query);
-    return await this.httpRequest(url, TunaLpPosition.array());
+    return await this.httpRequest(url, TunaLpPositionHistorical.array());
   }
   async getUserLpPositionActions(userAddress, positionAddress) {
     const url = this.buildURL(`users/${userAddress}/lp-positions/${positionAddress}/actions`);