@crypticdot/defituna-api 1.10.1 → 1.10.2

package/dist/index.mjs

@@ -106,7 +106,6 @@ __export(schemas_exports, {
   TunaLpPositionTransfer: () => TunaLpPositionTransfer,
   TunaLpPositionValue: () => TunaLpPositionValue,
   TunaPositionLegacy: () => TunaPositionLegacy,
-  TunaPositionMintSchema: () => TunaPositionMintSchema,
   TunaPositionNotification: () => TunaPositionNotification,
   TunaPositionPoolSchema: () => TunaPositionPoolSchema,
   TunaPositionPoolToken: () => TunaPositionPoolToken,
@@ -125,7 +124,7 @@ __export(schemas_exports, {
   WalletSubscriptionTopic: () => WalletSubscriptionTopic,
   WalletSubscriptionTopicSchema: () => WalletSubscriptionTopicSchema
 });
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // src/client/schemas/basic.ts
 import { z } from "zod";
@@ -177,25 +176,30 @@ var LimitOrder = z2.object({
 });
 
 // src/client/schemas/lp_positions.ts
-import z4 from "zod";
+import z5 from "zod";
 
-// src/client/schemas/positions_shared.ts
-import z3 from "zod";
-var TunaPositionMintSchema = z3.object({
-  addr: z3.string(),
+// src/client/schemas/mint.ts
+import { z as z3 } from "zod";
+var Mint = z3.object({
+  mint: z3.string(),
   symbol: z3.string(),
+  name: z3.string(),
+  logo: z3.string(),
   decimals: z3.number()
 });
-var TunaPositionPoolSchema = z3.object({
-  addr: z3.string(),
-  price: z3.number(),
-  tickSpacing: z3.number()
+
+// src/client/schemas/positions_shared.ts
+import z4 from "zod";
+var TunaPositionPoolSchema = z4.object({
+  addr: z4.string(),
+  price: z4.number(),
+  tickSpacing: z4.number()
 });
 var TunaPositionPoolToken = {
   A: "a",
   B: "b"
 };
-var TunaPositionPoolTokenSchema = z3.enum(Object.values(TunaPositionPoolToken));
+var TunaPositionPoolTokenSchema = z4.enum(Object.values(TunaPositionPoolToken));
 
 // src/client/schemas/lp_positions.ts
 var LpPositionLimitOrderSwap = {
@@ -228,57 +232,57 @@ var LpPositionsActionType = {
   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 LpPositionLimitOrderSwapSchema = z5.enum(Object.values(LpPositionLimitOrderSwap));
+var LpPositionAutoCompoundSchema = z5.enum(Object.values(LpPositionAutoCompound));
+var LpPositionRebalanceSchema = z5.enum(Object.values(LpPositionRebalance));
+var LpPositionsActionTypeSchema = z5.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 TunaPositionStateSchema = z5.enum([TunaPositionState.OPEN, ...Object.values(TunaPositionState)]);
 var TunaLpPositionAutoCompounding = {
   WITH_LEVERAGE: "with_leverage",
   WITHOUT_LEVERAGE: "without_leverage"
 };
-var TunaLpPositionAutoCompoundingSchema = z4.enum(
+var TunaLpPositionAutoCompoundingSchema = z5.enum(
   Object.values(TunaLpPositionAutoCompounding)
 );
-var TunaPositionTokenPnlSchema = z4.object({
-  amount: z4.coerce.bigint(),
-  bps: z4.number()
+var TunaPositionTokenPnlSchema = z5.object({
+  amount: z5.coerce.bigint(),
+  bps: z5.number()
 });
-var TunaLpPositionFlagsSchema = z4.object({
-  lowerLimitOrderSwapToToken: z4.nullable(TunaPositionPoolTokenSchema),
-  upperLimitOrderSwapToToken: z4.nullable(TunaPositionPoolTokenSchema),
-  autoCompounding: z4.nullable(TunaLpPositionAutoCompoundingSchema),
-  autoRebalancing: z4.boolean()
+var TunaLpPositionFlagsSchema = z5.object({
+  lowerLimitOrderSwapToToken: z5.nullable(TunaPositionPoolTokenSchema),
+  upperLimitOrderSwapToToken: z5.nullable(TunaPositionPoolTokenSchema),
+  autoCompounding: z5.nullable(TunaLpPositionAutoCompoundingSchema),
+  autoRebalancing: z5.boolean()
 });
-var TunaLpPositionDtoSchema = z4.object({
-  address: z4.string(),
-  authority: z4.string(),
-  version: z4.number(),
+var TunaLpPositionDtoSchema = z5.object({
+  address: z5.string(),
+  authority: z5.string(),
+  version: z5.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(),
+  positionMint: z5.string(),
+  liquidity: z5.coerce.bigint(),
+  lowerPrice: z5.number(),
+  upperPrice: z5.number(),
+  lowerLimitOrderPrice: z5.number(),
+  upperLimitOrderPrice: z5.number(),
+  entryPrice: z5.number(),
   flags: TunaLpPositionFlagsSchema,
-  mintA: TunaPositionMintSchema,
-  mintB: TunaPositionMintSchema,
+  mintA: Mint,
+  mintB: Mint,
   pool: TunaPositionPoolSchema,
   marketMaker: PoolProviderSchema,
   depositedCollateralA: AmountWithUsdSchema,
   depositedCollateralB: AmountWithUsdSchema,
-  leverage: z4.number(),
-  maxLeverage: z4.number(),
-  liquidationPriceLower: z4.number(),
-  liquidationPriceUpper: z4.number(),
+  leverage: z5.number(),
+  maxLeverage: z5.number(),
+  liquidationPriceLower: z5.number(),
+  liquidationPriceUpper: z5.number(),
   initialDebtA: AmountWithUsdSchema,
   initialDebtB: AmountWithUsdSchema,
   currentDebtA: AmountWithUsdSchema,
@@ -294,50 +298,50 @@ var TunaLpPositionDtoSchema = z4.object({
   pnlA: TokensPnlSchema,
   pnlB: TokensPnlSchema,
   pnlUsd: UsdPnlSchema,
-  openedAt: z4.coerce.date(),
-  closedAt: z4.nullable(z4.coerce.date())
+  openedAt: z5.coerce.date(),
+  closedAt: z5.nullable(z5.coerce.date())
 });
-var TunaLpPositionHistorical = z4.object({
-  positionAddress: z4.string(),
-  authority: z4.string(),
-  pool: z4.string(),
+var TunaLpPositionHistorical = z5.object({
+  positionAddress: z5.string(),
+  authority: z5.string(),
+  pool: z5.string(),
   state: TunaPositionStateSchema,
-  lowerPrice: z4.number(),
-  upperPrice: z4.number(),
-  lowerLimitOrder: z4.number().nullable(),
-  upperLimitOrder: z4.number().nullable(),
+  lowerPrice: z5.number(),
+  upperPrice: z5.number(),
+  lowerLimitOrder: z5.number().nullable(),
+  upperLimitOrder: z5.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()
+  openedAt: z5.coerce.date(),
+  closedAt: z5.coerce.date().nullable(),
+  totalValueUsd: z5.number(),
+  leverage: z5.number(),
+  initialLeverage: z5.number(),
+  totalDepositUsd: z5.number(),
+  totalWithdrawnUsd: z5.number(),
+  feesSumUsd: z5.number(),
+  closedPnlSumUsd: z5.number(),
+  entryPrice: z5.number(),
+  exitPrice: z5.number().nullable()
 });
-var TunaPositionLegacy = z4.object({
-  address: z4.string(),
-  authority: z4.string(),
-  version: z4.number(),
+var TunaPositionLegacy = z5.object({
+  address: z5.string(),
+  authority: z5.string(),
+  version: z5.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(),
+  positionMint: z5.string(),
+  liquidity: z5.coerce.bigint(),
+  tickLowerIndex: z5.number(),
+  tickUpperIndex: z5.number(),
+  entrySqrtPrice: z5.coerce.bigint(),
+  lowerLimitOrderSqrtPrice: z5.coerce.bigint(),
+  upperLimitOrderSqrtPrice: z5.coerce.bigint(),
+  flags: z5.number(),
+  pool: z5.string(),
+  poolSqrtPrice: z5.coerce.bigint(),
   depositedCollateralA: AmountWithoutUsdSchema,
   depositedCollateralB: AmountWithoutUsdSchema,
-  depositedCollateralUsd: z4.object({
-    amount: z4.number()
+  depositedCollateralUsd: z5.object({
+    amount: z5.number()
   }),
   loanFundsA: AmountWithUsdSchema,
   loanFundsB: AmountWithUsdSchema,
@@ -354,47 +358,47 @@ var TunaPositionLegacy = z4.object({
   pnlA: TokensPnlSchema,
   pnlB: TokensPnlSchema,
   pnlUsd: UsdPnlSchema,
-  openedAt: z4.coerce.date(),
-  updatedAtSlot: z4.coerce.bigint(),
-  closedAt: z4.nullable(z4.coerce.date())
+  openedAt: z5.coerce.date(),
+  updatedAtSlot: z5.coerce.bigint(),
+  closedAt: z5.nullable(z5.coerce.date())
 });
-var TunaLpPositionParameters = z4.object({
-  lowerPrice: z4.number(),
-  upperPrice: z4.number(),
-  lowerLimitOrder: z4.number().nullable(),
-  upperLimitOrder: z4.number().nullable(),
+var TunaLpPositionParameters = z5.object({
+  lowerPrice: z5.number(),
+  upperPrice: z5.number(),
+  lowerLimitOrder: z5.number().nullable(),
+  upperLimitOrder: z5.number().nullable(),
   lowerLimitOrderSwap: LpPositionLimitOrderSwapSchema,
   upperLimitOrderSwap: LpPositionLimitOrderSwapSchema,
   autoCompound: LpPositionAutoCompoundSchema,
   rebalance: LpPositionRebalanceSchema,
-  rebalanceThresholdTicks: z4.number()
+  rebalanceThresholdTicks: z5.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 TunaLpPositionValue = z5.object({
+  totalValueA: z5.number(),
+  totalValueB: z5.number(),
+  totalValueUsd: z5.number(),
+  loanFundsA: z5.number(),
+  loanFundsB: z5.number(),
+  loanFundsUsd: z5.number(),
+  leverage: z5.number()
 });
-var TunaLpPositionTransfer = z4.object({
-  amountA: z4.number(),
-  amountB: z4.number(),
-  amountUsd: z4.number()
+var TunaLpPositionTransfer = z5.object({
+  amountA: z5.number(),
+  amountB: z5.number(),
+  amountUsd: z5.number()
 });
-var TunaLpPositionTokenPrices = z4.object({
-  tokenPriceA: z4.number(),
-  tokenPriceB: z4.number()
+var TunaLpPositionTokenPrices = z5.object({
+  tokenPriceA: z5.number(),
+  tokenPriceB: z5.number()
 });
-var TunaLpPositionActionOpen = z4.object({
+var TunaLpPositionActionOpen = z5.object({
   parameters: TunaLpPositionParameters
 });
-var TunaLpPositionActionClose = z4.object({
+var TunaLpPositionActionClose = z5.object({
   toOwner: TunaLpPositionTransfer.nullable(),
   prices: TunaLpPositionTokenPrices.nullable()
 });
-var TunaLpPositionActionIncreaseLiquidity = z4.object({
+var TunaLpPositionActionIncreaseLiquidity = z5.object({
   fromPosition: TunaLpPositionValue.nullable(),
   toPosition: TunaLpPositionValue,
   fromOwner: TunaLpPositionTransfer,
@@ -402,9 +406,9 @@ var TunaLpPositionActionIncreaseLiquidity = z4.object({
   protocolFees: TunaLpPositionTransfer,
   prices: TunaLpPositionTokenPrices
 });
-var TunaLpPositionActionDecreaseLiquidity = z4.object({
-  withdrawPercent: z4.number(),
-  closedPnlUsd: z4.number(),
+var TunaLpPositionActionDecreaseLiquidity = z5.object({
+  withdrawPercent: z5.number(),
+  closedPnlUsd: z5.number(),
   fromPosition: TunaLpPositionValue,
   toPosition: TunaLpPositionValue.nullable(),
   toOwner: TunaLpPositionTransfer,
@@ -412,28 +416,28 @@ var TunaLpPositionActionDecreaseLiquidity = z4.object({
   collectedFees: TunaLpPositionTransfer,
   prices: TunaLpPositionTokenPrices
 });
-var TunaLpPositionActionLiquidate = z4.object({
-  withdrawPercent: z4.number(),
+var TunaLpPositionActionLiquidate = z5.object({
+  withdrawPercent: z5.number(),
   fromPosition: TunaLpPositionValue,
   toLending: TunaLpPositionTransfer,
   protocolFees: TunaLpPositionTransfer,
   prices: TunaLpPositionTokenPrices
 });
-var TunaLpPositionActionRepayDebt = z4.object({
+var TunaLpPositionActionRepayDebt = z5.object({
   fromPosition: TunaLpPositionValue,
   toPosition: TunaLpPositionValue,
   fromOwner: TunaLpPositionTransfer,
   toLending: TunaLpPositionTransfer,
   prices: TunaLpPositionTokenPrices
 });
-var TunaLpPositionActionCollectFees = z4.object({
-  closedPnlUsd: z4.number(),
+var TunaLpPositionActionCollectFees = z5.object({
+  closedPnlUsd: z5.number(),
   position: TunaLpPositionValue,
   collectedFees: TunaLpPositionTransfer,
   toOwner: TunaLpPositionTransfer,
   prices: TunaLpPositionTokenPrices
 });
-var TunaLpPositionActionCollectAndCompoundFees = z4.object({
+var TunaLpPositionActionCollectAndCompoundFees = z5.object({
   fromPosition: TunaLpPositionValue,
   toPosition: TunaLpPositionValue,
   collectedFees: TunaLpPositionTransfer,
@@ -441,15 +445,15 @@ var TunaLpPositionActionCollectAndCompoundFees = z4.object({
   protocolFees: TunaLpPositionTransfer,
   prices: TunaLpPositionTokenPrices
 });
-var TunaLpPositionActionParametersUpdate = z4.object({
+var TunaLpPositionActionParametersUpdate = z5.object({
   fromParameters: TunaLpPositionParameters,
   toParameters: TunaLpPositionParameters
 });
-var TunaLpPositionAction = z4.object({
+var TunaLpPositionAction = z5.object({
   action: LpPositionsActionTypeSchema,
-  txSignature: z4.string(),
-  txTimestamp: z4.coerce.date(),
-  data: z4.object({
+  txSignature: z5.string(),
+  txTimestamp: z5.coerce.date(),
+  data: z5.object({
     /** defined for: IncreaseLiquidity, DecreaseLiquidity, Liquidate, ExecuteLimitOrder, RepayDebt, CollectAndCompoundFees */
     fromPosition: TunaLpPositionValue.optional().nullable(),
     /** defined for: IncreaseLiquidity, DecreaseLiquidity, Liquidate, ExecuteLimitOrder, RepayDebt, CollectAndCompoundFees */
@@ -477,32 +481,32 @@ var TunaLpPositionAction = z4.object({
     /** defined for: ParametersUpdate */
     toParameters: TunaLpPositionParameters.optional(),
     /** defined for: DecreaseLiquidity */
-    withdrawPercent: z4.number().optional(),
+    withdrawPercent: z5.number().optional(),
     /** defined for: DecreaseLiquidity, CollectFees */
-    closedPnlUsd: z4.number().optional()
+    closedPnlUsd: z5.number().optional()
   })
 });
 
 // src/client/schemas/spot_positions.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var TunaSpotPositionState = {
   OPEN: "open",
   CLOSED: "closed"
 };
-var TunaSpotPositionStateSchema = z5.enum([
+var TunaSpotPositionStateSchema = z6.enum([
   TunaSpotPositionState.OPEN,
   ...Object.values(TunaSpotPositionState)
 ]);
-var TunaSpotPosition = z5.object({
-  address: z5.string(),
-  authority: z5.string(),
-  version: z5.number(),
+var TunaSpotPosition = z6.object({
+  address: z6.string(),
+  authority: z6.string(),
+  version: z6.number(),
   state: TunaSpotPositionStateSchema,
-  lowerLimitOrderPrice: z5.number(),
-  upperLimitOrderPrice: z5.number(),
-  entryPrice: z5.number(),
-  mintA: TunaPositionMintSchema,
-  mintB: TunaPositionMintSchema,
+  lowerLimitOrderPrice: z6.number(),
+  upperLimitOrderPrice: z6.number(),
+  entryPrice: z6.number(),
+  mintA: Mint,
+  mintB: Mint,
   pool: TunaPositionPoolSchema,
   positionToken: TunaPositionPoolToken,
   collateralToken: TunaPositionPoolToken,
@@ -511,77 +515,77 @@ var TunaSpotPosition = z5.object({
   initialDebt: AmountWithUsdSchema,
   currentDebt: AmountWithUsdSchema,
   total: AmountWithUsdSchema,
-  leverage: z5.number(),
-  maxLeverage: z5.number(),
-  liquidationPrice: z5.number(),
+  leverage: z6.number(),
+  maxLeverage: z6.number(),
+  liquidationPrice: z6.number(),
   pnlUsd: UsdPnlSchema,
-  openedAt: z5.coerce.date(),
-  closedAt: z5.nullable(z5.coerce.date())
+  openedAt: z6.coerce.date(),
+  closedAt: z6.nullable(z6.coerce.date())
 });
-var IncreaseSpotPositionQuote = z5.object({
+var IncreaseSpotPositionQuote = z6.object({
   /** Required collateral amount */
-  collateralAmount: z5.coerce.bigint(),
+  collateralAmount: z6.coerce.bigint(),
   /** Required amount to borrow */
-  borrowAmount: z5.coerce.bigint(),
+  borrowAmount: z6.coerce.bigint(),
   /** Estimated position size in the position token. */
-  estimatedAmount: z5.coerce.bigint(),
+  estimatedAmount: z6.coerce.bigint(),
   /** Swap input amount. */
-  swapInputAmount: z5.coerce.bigint(),
+  swapInputAmount: z6.coerce.bigint(),
   /** Minimum swap output amount according to the provided slippage. */
-  minSwapOutputAmount: z5.coerce.bigint(),
+  minSwapOutputAmount: z6.coerce.bigint(),
   /** Protocol fee in token A */
-  protocolFeeA: z5.coerce.bigint(),
+  protocolFeeA: z6.coerce.bigint(),
   /** Protocol fee in token B */
-  protocolFeeB: z5.coerce.bigint(),
+  protocolFeeB: z6.coerce.bigint(),
   /** Price impact in percents */
-  priceImpact: z5.number(),
+  priceImpact: z6.number(),
   /** Liquidation price */
-  liquidationPrice: z5.number()
+  liquidationPrice: z6.number()
 });
-var DecreaseSpotPositionQuote = z5.object({
+var DecreaseSpotPositionQuote = z6.object({
   /** Confirmed position decrease percentage (100% = 1.0) */
-  decreasePercent: z5.number(),
+  decreasePercent: z6.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(),
+  requiredSwapAmount: z6.coerce.bigint(),
   /**  Estimated total amount of the adjusted position */
-  estimatedAmount: z5.coerce.bigint(),
+  estimatedAmount: z6.coerce.bigint(),
   /** Estimated amount of the withdrawn collateral */
-  estimatedWithdrawnCollateral: z5.coerce.bigint(),
+  estimatedWithdrawnCollateral: z6.coerce.bigint(),
   /** Price impact in percents */
-  priceImpact: z5.number(),
+  priceImpact: z6.number(),
   /** Liquidation price */
-  liquidationPrice: z5.number()
+  liquidationPrice: z6.number()
 });
-var CloseSpotPositionQuote = z5.object({
+var CloseSpotPositionQuote = z6.object({
   /** Position decrease percentage */
-  decreasePercent: z5.number(),
+  decreasePercent: z6.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(),
+  requiredSwapAmount: z6.coerce.bigint(),
   /** Estimated amount of the withdrawn collateral */
-  estimatedWithdrawnCollateral: z5.coerce.bigint(),
+  estimatedWithdrawnCollateral: z6.coerce.bigint(),
   /** Price impact in percents */
-  priceImpact: z5.number()
+  priceImpact: z6.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()
+import z7 from "zod";
+var PoolPriceUpdate = z7.object({
+  pool: z7.string(),
+  price: z7.number(),
+  sqrtPrice: z7.coerce.bigint(),
+  time: z7.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))
+var StateSnapshot = z7.object({
+  slot: z7.coerce.bigint(),
+  blockTime: z7.coerce.date(),
+  poolPrices: z7.optional(z7.record(z7.string(), PoolPriceUpdate)),
+  tunaSpotPositions: z7.optional(z7.array(TunaSpotPosition)),
+  tunaLpPositions: z7.optional(z7.array(TunaLpPositionDtoSchema)),
+  fusionLimitOrders: z7.optional(z7.array(LimitOrder))
 });
 
 // src/client/schemas.ts
@@ -661,57 +665,51 @@ var WalletSubscriptionTopic = {
   TRADE_HISTORY: "trade_history",
   ORDER_HISTORY: "order_history"
 };
-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([
+var NotificationEntitySchema = z8.enum([NotificationEntity.POOL_SWAP, ...Object.values(NotificationEntity)]);
+var NotificationActionSchema = z8.enum([NotificationAction.CREATE, ...Object.values(NotificationAction)]);
+var TradeHistoryActionSchema = z8.enum([TradeHistoryAction.SWAP, ...Object.values(TradeHistoryAction)]);
+var TradeHistoryUIDirectionSchema = z8.enum([
   TradeHistoryUIDirection.BUY,
   ...Object.values(TradeHistoryUIDirection)
 ]);
-var OrderHistoryOrderTypeSchema = z7.enum([
+var OrderHistoryOrderTypeSchema = z8.enum([
   OrderHistoryOrderType.MARKET,
   ...Object.values(OrderHistoryOrderType)
 ]);
-var OrderHistoryStatusSchema = z7.enum([OrderHistoryStatus.OPEN, ...Object.values(OrderHistoryStatus)]);
-var OrderHistoryUIDirectionSchema = z7.enum([
+var OrderHistoryStatusSchema = z8.enum([OrderHistoryStatus.OPEN, ...Object.values(OrderHistoryStatus)]);
+var OrderHistoryUIDirectionSchema = z8.enum([
   OrderHistoryUIDirection.BUY,
   ...Object.values(OrderHistoryUIDirection)
 ]);
-var StakingPositionHistoryActionTypeSchema = z7.enum([
+var StakingPositionHistoryActionTypeSchema = z8.enum([
   StakingPositionHistoryActionType.STAKE,
   ...Object.values(StakingPositionHistoryActionType)
 ]);
-var PoolSubscriptionTopicSchema = z7.enum([
+var PoolSubscriptionTopicSchema = z8.enum([
   PoolSubscriptionTopic.ORDER_BOOK,
   ...Object.values(PoolSubscriptionTopic)
 ]);
-var WalletSubscriptionTopicSchema = z7.enum([
+var WalletSubscriptionTopicSchema = z8.enum([
   WalletSubscriptionTopic.TUNA_POSITIONS,
   ...Object.values(WalletSubscriptionTopic)
 ]);
-var PaginationMeta = z7.object({
-  total: z7.number()
+var PaginationMeta = z8.object({
+  total: z8.number()
 });
-var Mint = z7.object({
-  symbol: z7.string(),
-  mint: z7.string(),
-  logo: z7.string(),
-  decimals: z7.number()
-});
-var Market = z7.object({
-  address: z7.string(),
-  addressLookupTable: z7.string(),
-  poolAddress: z7.string(),
-  poolFeeRate: z7.number(),
+var Market = z8.object({
+  address: z8.string(),
+  addressLookupTable: z8.string(),
+  poolAddress: z8.string(),
+  poolFeeRate: z8.number(),
   provider: PoolProviderSchema,
-  maxLeverage: z7.number(),
-  maxSwapSlippage: z7.number(),
-  protocolFee: z7.number(),
-  rebalanceProtocolFee: z7.number(),
-  protocolFeeOnCollateral: z7.number(),
-  liquidationFee: z7.number(),
-  liquidationThreshold: z7.number(),
-  oraclePriceDeviationThreshold: z7.number(),
+  maxLeverage: z8.number(),
+  maxSwapSlippage: z8.number(),
+  protocolFee: z8.number(),
+  rebalanceProtocolFee: z8.number(),
+  protocolFeeOnCollateral: z8.number(),
+  liquidationFee: z8.number(),
+  liquidationThreshold: z8.number(),
+  oraclePriceDeviationThreshold: z8.number(),
   maxSpotPositionSizeA: AmountWithUsdSchema,
   maxSpotPositionSizeB: AmountWithUsdSchema,
   borrowedFundsA: AmountWithUsdSchema,
@@ -720,32 +718,32 @@ var Market = z7.object({
   availableBorrowB: AmountWithUsdSchema,
   borrowLimitA: AmountWithUsdSchema,
   borrowLimitB: AmountWithUsdSchema,
-  disabled: z7.boolean(),
-  createdAt: z7.coerce.date()
+  disabled: z8.boolean(),
+  createdAt: z8.coerce.date()
 });
-var TokenOraclePrice = z7.object({
-  mint: z7.string(),
-  price: z7.coerce.bigint(),
-  decimals: z7.number(),
-  time: z7.coerce.date()
+var TokenOraclePrice = z8.object({
+  mint: z8.string(),
+  price: z8.coerce.bigint(),
+  decimals: z8.number(),
+  time: z8.coerce.date()
 });
-var Vault = z7.object({
-  address: z7.string(),
-  mint: z7.string(),
+var Vault = z8.object({
+  address: z8.string(),
+  mint: z8.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()
+  borrowedShares: z8.coerce.bigint(),
+  depositedShares: z8.coerce.bigint(),
+  supplyApy: z8.number(),
+  borrowApy: z8.number(),
+  interestRate: z8.coerce.bigint(),
+  utilization: z8.number(),
+  pythOracleFeedId: z8.string(),
+  pythOraclePriceUpdate: z8.string()
 });
-var VaultHistoricalStats = z7.object({
-  date: z7.preprocess((val, ctx) => {
+var VaultHistoricalStats = z8.object({
+  date: z8.preprocess((val, ctx) => {
     if (typeof val === "string") {
       const [year, month, day] = val.split("-").map(Number);
       return new Date(year, month - 1, day);
@@ -754,272 +752,272 @@ var VaultHistoricalStats = z7.object({
       code: "custom",
       message: "Not a valid date string"
     });
-    return z7.NEVER;
-  }, z7.date()),
+    return z8.NEVER;
+  }, z8.date()),
   supply: AmountWithUsdSchema,
   borrow: AmountWithUsdSchema,
-  supplyApy: z7.number(),
-  borrowApr: z7.number()
+  supplyApy: z8.number(),
+  borrowApr: z8.number()
 });
-var Pool = z7.object({
-  address: z7.string(),
+var Pool = z8.object({
+  address: z8.string(),
   provider: PoolProviderSchema,
-  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()
+  tokenAMint: z8.string(),
+  tokenBMint: z8.string(),
+  tokenAVault: z8.string(),
+  tokenBVault: z8.string(),
+  tvlUsdc: z8.coerce.number(),
+  priceChange24H: z8.number(),
+  tickSpacing: z8.number(),
+  feeRate: z8.number(),
+  olpFeeRate: z8.nullable(z8.number()),
+  protocolFeeRate: z8.number(),
+  liquidity: z8.coerce.bigint(),
+  sqrtPrice: z8.coerce.bigint(),
+  tickCurrentIndex: z8.number(),
+  stats: z8.object({
+    "24h": z8.object({
+      volume: z8.coerce.number(),
+      fees: z8.coerce.number(),
+      rewards: z8.coerce.number(),
+      yieldOverTvl: z8.coerce.number()
     }),
-    "7d": z7.object({
-      volume: z7.coerce.number(),
-      fees: z7.coerce.number(),
-      rewards: z7.coerce.number(),
-      yieldOverTvl: z7.coerce.number()
+    "7d": z8.object({
+      volume: z8.coerce.number(),
+      fees: z8.coerce.number(),
+      rewards: z8.coerce.number(),
+      yieldOverTvl: z8.coerce.number()
     }),
-    "30d": z7.object({
-      volume: z7.coerce.number(),
-      fees: z7.coerce.number(),
-      rewards: z7.coerce.number(),
-      yieldOverTvl: z7.coerce.number()
+    "30d": z8.object({
+      volume: z8.coerce.number(),
+      fees: z8.coerce.number(),
+      rewards: z8.coerce.number(),
+      yieldOverTvl: z8.coerce.number()
     })
   })
 });
-var Tick = z7.object({
-  index: z7.number(),
-  liquidity: z7.coerce.bigint()
+var Tick = z8.object({
+  index: z8.number(),
+  liquidity: z8.coerce.bigint()
 });
-var PoolTicks = z7.object({
-  tickSpacing: z7.number(),
+var PoolTicks = z8.object({
+  tickSpacing: z8.number(),
   ticks: Tick.array()
 });
-var LendingPosition = z7.object({
-  address: z7.string(),
-  authority: z7.string(),
-  mint: z7.string(),
-  vault: z7.string(),
-  shares: z7.coerce.bigint(),
+var LendingPosition = z8.object({
+  address: z8.string(),
+  authority: z8.string(),
+  mint: z8.string(),
+  vault: z8.string(),
+  shares: z8.coerce.bigint(),
   funds: AmountWithUsdSchema,
   earned: AmountWithUsdSchema
 });
-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 PoolSwap = z8.object({
+  id: z8.string(),
+  amountIn: z8.coerce.bigint(),
+  amountOut: z8.coerce.bigint(),
+  amountUsd: z8.number(),
+  aToB: z8.boolean(),
+  pool: z8.string(),
+  time: z8.coerce.date()
 });
-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 OrderBookEntry = z8.object({
+  concentratedAmount: z8.coerce.bigint(),
+  concentratedAmountQuote: z8.coerce.bigint(),
+  concentratedTotal: z8.coerce.bigint(),
+  concentratedTotalQuote: z8.coerce.bigint(),
+  limitAmount: z8.coerce.bigint(),
+  limitAmountQuote: z8.coerce.bigint(),
+  limitTotal: z8.coerce.bigint(),
+  limitTotalQuote: z8.coerce.bigint(),
+  price: z8.number(),
+  askSide: z8.boolean()
 });
-var OrderBook = z7.object({
+var OrderBook = z8.object({
   entries: OrderBookEntry.array(),
-  poolPrice: z7.number()
+  poolPrice: z8.number()
 });
-var TradeHistoryEntry = z7.object({
+var TradeHistoryEntry = z8.object({
   // Internal entry ID
-  id: z7.string(),
-  pool: z7.string(),
-  authority: z7.string(),
-  aToB: z7.boolean(),
+  id: z8.string(),
+  pool: z8.string(),
+  authority: z8.string(),
+  aToB: z8.boolean(),
   // Trade action which created entry
   action: TradeHistoryActionSchema,
   // Trade direction formatted for ui display
   uiDirection: TradeHistoryUIDirectionSchema,
   // Trade price formatted for ui display
-  uiPrice: z7.number(),
+  uiPrice: z8.number(),
   baseToken: AmountWithUsdSchema,
   quoteToken: AmountWithUsdSchema,
   fee: AmountWithUsdSchema,
-  pnl: z7.nullable(
-    z7.object({
-      usd: z7.number(),
-      bps: z7.number()
+  pnl: z8.nullable(
+    z8.object({
+      usd: z8.number(),
+      bps: z8.number()
     })
   ),
-  txSignature: z7.nullable(z7.string()),
-  positionAddress: z7.nullable(z7.string()),
-  slot: z7.coerce.bigint(),
-  ts: z7.coerce.date()
+  txSignature: z8.nullable(z8.string()),
+  positionAddress: z8.nullable(z8.string()),
+  slot: z8.coerce.bigint(),
+  ts: z8.coerce.date()
 });
-var OrderHistoryEntry = z7.object({
+var OrderHistoryEntry = z8.object({
   // Internal entry ID
-  id: z7.string(),
-  pool: z7.string(),
-  authority: z7.string(),
+  id: z8.string(),
+  pool: z8.string(),
+  authority: z8.string(),
   orderType: OrderHistoryOrderTypeSchema,
-  isReduceOnly: z7.nullable(z7.boolean()),
-  aToB: z7.boolean(),
+  isReduceOnly: z8.nullable(z8.boolean()),
+  aToB: z8.boolean(),
   uiDirection: OrderHistoryUIDirectionSchema,
-  uiPrice: z7.nullable(z7.number()),
-  uiExecutionPrice: z7.nullable(z7.number()),
+  uiPrice: z8.nullable(z8.number()),
+  uiExecutionPrice: z8.nullable(z8.number()),
   status: OrderHistoryStatusSchema,
   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()
+  baseTokenConsumedAmount: z8.nullable(AmountWithUsdSchema),
+  quoteTokenFilledAmount: z8.nullable(AmountWithUsdSchema),
+  txSignature: z8.nullable(z8.string()),
+  positionAddress: z8.nullable(z8.string()),
+  slot: z8.coerce.bigint(),
+  ts: z8.coerce.date()
 });
-var StakingTreasury = z7.object({
-  address: z7.string(),
-  stakedTokenMint: z7.string(),
-  rewardTokenMint: z7.string(),
-  apy: z7.number(),
-  uniqueStakers: z7.number(),
+var StakingTreasury = z8.object({
+  address: z8.string(),
+  stakedTokenMint: z8.string(),
+  rewardTokenMint: z8.string(),
+  apy: z8.number(),
+  uniqueStakers: z8.number(),
   totalStaked: AmountWithUsdSchema,
   totalReward: AmountWithUsdSchema,
-  unstakeCooldownSeconds: z7.number(),
-  isStakingEnabled: z7.boolean(),
-  isUnstakingEnabled: z7.boolean(),
-  isWithdrawEnabled: z7.boolean()
+  unstakeCooldownSeconds: z8.number(),
+  isStakingEnabled: z8.boolean(),
+  isUnstakingEnabled: z8.boolean(),
+  isWithdrawEnabled: z8.boolean()
 });
-var StakingPosition = z7.object({
-  address: z7.string(),
-  owner: z7.string(),
+var StakingPosition = z8.object({
+  address: z8.string(),
+  owner: z8.string(),
   staked: AmountWithUsdSchema,
   unstaked: AmountWithUsdSchema,
   claimedReward: AmountWithUsdSchema,
   unclaimedReward: AmountWithUsdSchema,
-  rank: z7.nullable(z7.number()),
-  vesting: z7.object({
+  rank: z8.nullable(z8.number()),
+  vesting: z8.object({
     locked: AmountWithUsdSchema,
     unlocked: AmountWithUsdSchema,
-    unlockRate: z7.coerce.bigint(),
-    unlockEverySeconds: z7.number(),
-    unlockCliffSeconds: z7.number(),
-    lockedAt: z7.nullable(z7.coerce.date())
+    unlockRate: z8.coerce.bigint(),
+    unlockEverySeconds: z8.number(),
+    unlockCliffSeconds: z8.number(),
+    lockedAt: z8.nullable(z8.coerce.date())
   }),
-  lastUnstakedAt: z7.nullable(z7.coerce.date()),
-  withdrawAvailableAt: z7.nullable(z7.coerce.date())
+  lastUnstakedAt: z8.nullable(z8.coerce.date()),
+  withdrawAvailableAt: z8.nullable(z8.coerce.date())
 });
-var StakingLeaderboardPosition = z7.object({
-  rank: z7.number(),
-  address: z7.string(),
-  owner: z7.string(),
+var StakingLeaderboardPosition = z8.object({
+  rank: z8.number(),
+  address: z8.string(),
+  owner: z8.string(),
   staked: AmountWithUsdSchema
 });
-var StakingLeaderboardPage = z7.object({
+var StakingLeaderboardPage = z8.object({
   data: StakingLeaderboardPosition.array(),
   meta: PaginationMeta
 });
-var StakingPositionHistoryAction = z7.object({
-  position: z7.string(),
+var StakingPositionHistoryAction = z8.object({
+  position: z8.string(),
   action: StakingPositionHistoryActionTypeSchema,
-  txSignature: z7.string(),
-  amount: z7.coerce.bigint(),
-  time: z7.coerce.date()
+  txSignature: z8.string(),
+  amount: z8.coerce.bigint(),
+  time: z8.coerce.date()
 });
-var PoolPriceCandle = z7.object({
-  time: z7.number(),
-  open: z7.number(),
-  close: z7.number(),
-  high: z7.number(),
-  low: z7.number(),
-  volume: z7.number()
+var PoolPriceCandle = z8.object({
+  time: z8.number(),
+  open: z8.number(),
+  close: z8.number(),
+  high: z8.number(),
+  low: z8.number(),
+  volume: z8.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 FeesStatsGroup = z8.object({
+  time: z8.coerce.date(),
+  addLiquidityFees: z8.number(),
+  limitOrderFees: z8.number(),
+  yieldCompoundingFees: z8.number(),
+  liquidationFees: z8.number(),
+  totalLiquidationsNetworkFees: z8.number(),
+  totalLimitOrdersNetworkFees: z8.number(),
+  totalYieldCompoundingNetworkFees: z8.number(),
+  failedNetworkFees: z8.number(),
+  processedNetworkFees: z8.number(),
+  totalCollectedFees: z8.number(),
+  totalNetworkFees: z8.number(),
+  jitoLiquidationFees: z8.number(),
+  jitoLimitOrderFees: z8.number(),
+  jitoYieldCompoundingFees: z8.number(),
+  runningAddLiquidityFees: z8.number(),
+  runningLimitOrderFees: z8.number(),
+  runningYieldCompoundingFees: z8.number(),
+  runningLiquidationFees: z8.number(),
+  runningTotalLiquidationsNetworkFees: z8.number(),
+  runningTotalLimitOrdersNetworkFees: z8.number(),
+  runningTotalYieldCompoundingNetworkFees: z8.number(),
+  runningFailedNetworkFees: z8.number(),
+  runningProcessedNetworkFees: z8.number(),
+  runningJitoLiquidationFees: z8.number(),
+  runningJitoLimitOrderFees: z8.number(),
+  runningJitoYieldCompoundingFees: z8.number(),
+  runningTotalCollectedFees: z8.number(),
+  runningTotalNetworkFees: z8.number()
 });
-var StakingRevenueStatsGroup = z7.object({
-  time: z7.coerce.date(),
-  totalDepositsUsd: z7.number(),
-  totalDepositsSol: z7.coerce.bigint(),
-  runningTotalDepositsUsd: z7.number(),
-  runningTotalDepositsSol: z7.coerce.bigint()
+var StakingRevenueStatsGroup = z8.object({
+  time: z8.coerce.date(),
+  totalDepositsUsd: z8.number(),
+  totalDepositsSol: z8.coerce.bigint(),
+  runningTotalDepositsUsd: z8.number(),
+  runningTotalDepositsSol: z8.coerce.bigint()
 });
-var SwapQuoteByInput = z7.object({
-  estimatedAmountOut: z7.coerce.bigint(),
-  minAmountOut: z7.coerce.bigint(),
-  feeAmount: z7.coerce.bigint(),
-  feeUsd: z7.number(),
+var SwapQuoteByInput = z8.object({
+  estimatedAmountOut: z8.coerce.bigint(),
+  minAmountOut: z8.coerce.bigint(),
+  feeAmount: z8.coerce.bigint(),
+  feeUsd: z8.number(),
   /** Price impact in percents */
-  priceImpact: z7.number()
+  priceImpact: z8.number()
 });
-var SwapQuoteByOutput = z7.object({
-  estimatedAmountIn: z7.coerce.bigint(),
-  maxAmountIn: z7.coerce.bigint(),
-  feeAmount: z7.coerce.bigint(),
-  feeUsd: z7.number(),
+var SwapQuoteByOutput = z8.object({
+  estimatedAmountIn: z8.coerce.bigint(),
+  maxAmountIn: z8.coerce.bigint(),
+  feeAmount: z8.coerce.bigint(),
+  feeUsd: z8.number(),
   /** Price impact in percents */
-  priceImpact: z7.number()
+  priceImpact: z8.number()
 });
-var LimitOrderQuoteByInput = z7.object({
-  amountOut: z7.coerce.bigint()
+var LimitOrderQuoteByInput = z8.object({
+  amountOut: z8.coerce.bigint()
 });
-var LimitOrderQuoteByOutput = z7.object({
-  amountIn: z7.coerce.bigint()
+var LimitOrderQuoteByOutput = z8.object({
+  amountIn: z8.coerce.bigint()
 });
 var TradableAmount = AmountWithUsdSchema;
-var UpdateStreamSubscriptionResult = z7.object({
-  status: z7.string()
+var UpdateStreamSubscriptionResult = z8.object({
+  status: z8.string()
 });
-var createNotificationSchema = (dataSchema, metaSchema) => z7.object({
+var createNotificationSchema = (dataSchema, metaSchema) => z8.object({
   entity: NotificationEntitySchema,
   action: NotificationActionSchema,
   data: dataSchema,
-  id: z7.string(),
-  authority: z7.nullish(z7.string()),
-  ...metaSchema ? { meta: metaSchema } : { meta: z7.undefined().nullable() }
+  id: z8.string(),
+  authority: z8.nullish(z8.string()),
+  ...metaSchema ? { meta: metaSchema } : { meta: z8.undefined().nullable() }
 });
-var OrderBookNotificationMeta = z7.object({
-  pool: z7.string(),
-  priceStep: z7.number(),
-  inverted: z7.boolean()
+var OrderBookNotificationMeta = z8.object({
+  pool: z8.string(),
+  priceStep: z8.number(),
+  inverted: z8.boolean()
 });
 var PoolSwapNotification = createNotificationSchema(PoolSwap);
 var PoolPriceUpdateNotification = createNotificationSchema(PoolPriceUpdate);