@mobula_labs/types 0.1.7 → 0.1.8

package/dist/cjs/index.cjs

@@ -1310,6 +1310,9 @@ __export(exports_src, {
   UpdateWebhook: () => UpdateWebhook,
   UpdateStreamPayloadSchema: () => UpdateStreamPayloadSchema,
   UnsubscribeStreamPayloadSchema: () => UnsubscribeStreamPayloadSchema,
+  TradesFiltersResponseSchema: () => TradesFiltersResponseSchema,
+  TradesFiltersParamsSchema: () => TradesFiltersParamsSchema,
+  TradesFiltersPaginationSchema: () => TradesFiltersPaginationSchema,
   TokenTypeValues: () => TokenTypeValues,
   TokenTypeSchema: () => TokenTypeSchema,
   TokenTradesParamsSchema: () => TokenTradesParamsSchema,
@@ -1355,6 +1358,8 @@ __export(exports_src, {
   TokenAthBatchResponseSchema: () => TokenAthBatchResponseSchema,
   TokenAthBatchParamsSchema: () => TokenAthBatchParamsSchema,
   Tags: () => Tags,
+  TRADES_FILTERS_MAX_TIMEFRAME_MS: () => TRADES_FILTERS_MAX_TIMEFRAME_MS,
+  TRADES_FILTERS_MAX_LIMIT: () => TRADES_FILTERS_MAX_LIMIT,
   TOKEN_METADATA_KEYS: () => TOKEN_METADATA_KEYS,
   SystemMetadataResponseSchema: () => SystemMetadataResponseSchema,
   SwapType: () => SwapType,
@@ -2744,8 +2749,8 @@ var MarketBlockchainPairsResponseSchema = import_zod15.z.object({
     price_change_6h: import_zod15.z.number(),
     price_change_12h: import_zod15.z.number(),
     price_change_24h: import_zod15.z.number(),
-    last_trade: import_zod15.z.date().nullable(),
-    created_at: import_zod15.z.date().nullable(),
+    last_trade: import_zod15.z.coerce.date().nullable(),
+    created_at: import_zod15.z.coerce.date().nullable(),
     holders_count: import_zod15.z.number(),
     volume_1min: import_zod15.z.number(),
     volume_5min: import_zod15.z.number(),
@@ -3414,7 +3419,7 @@ var MetadataNewsResponseSchema = import_zod34.z.object({
   }))
 });
 // src/v1/metadata/MetadataSchema.ts
-var import_zod_to_openapi = __toESM(require_dist());
+var import_zod_to_openapi = __toESM(require_dist(), 1);
 var import_zod35 = require("zod");
 import_zod_to_openapi.extendZodWithOpenApi(import_zod35.z);
 var MetadataParamsSchema = import_zod35.z.object({
@@ -3487,7 +3492,7 @@ var MetadataResponseSchema = import_zod35.z.object({
       name: import_zod35.z.string().nullable(),
       id: import_zod35.z.string()
     })),
-    listed_at: import_zod35.z.date().nullable(),
+    listed_at: import_zod35.z.coerce.date().nullable(),
     deployer: import_zod35.z.string().nullable(),
     source: import_zod35.z.string().nullable(),
     others: import_zod35.z.record(import_zod35.z.string(), import_zod35.z.unknown()).nullable().optional(),
@@ -4139,7 +4144,7 @@ var PairSchema = import_zod43.z.object({
   liquidity: import_zod43.z.number(),
   blockchain: import_zod43.z.string(),
   address: import_zod43.z.string(),
-  createdAt: import_zod43.z.date().nullable(),
+  createdAt: import_zod43.z.coerce.date().nullable(),
   type: import_zod43.z.string(),
   baseToken: import_zod43.z.string(),
   exchange: import_zod43.z.object({
@@ -4208,9 +4213,9 @@ var TokenFirstBuyersResponseSchema = import_zod44.z.object({
     blockchain: import_zod44.z.string(),
     initialAmount: import_zod44.z.string(),
     currentBalance: import_zod44.z.string(),
-    firstHoldingDate: import_zod44.z.date(),
+    firstHoldingDate: import_zod44.z.coerce.date(),
     tags: import_zod44.z.array(import_zod44.z.string()),
-    lastUpdate: import_zod44.z.date().nullable().optional()
+    lastUpdate: import_zod44.z.coerce.date().nullable().optional()
   }))
 });
 // src/v1/wallet/BalanceUSDSchema.ts
@@ -4225,7 +4230,7 @@ var WalletBalanceUSDResponseSchema = import_zod45.z.object({
 var import_zod46 = require("zod");
 var FundingInfoSchema = import_zod46.z.object({
   from: import_zod46.z.string().nullable(),
-  date: import_zod46.z.date().nullable(),
+  date: import_zod46.z.coerce.date().nullable(),
   chainId: import_zod46.z.string().nullable(),
   txHash: import_zod46.z.string().nullable(),
   amount: import_zod46.z.string().nullable(),
@@ -4262,8 +4267,8 @@ var tokenPositionSchema = import_zod46.z.object({
   unrealizedPnlUSD: import_zod46.z.number(),
   totalPnlUSD: import_zod46.z.number(),
   totalFeesPaidUSD: import_zod46.z.number().optional(),
-  firstDate: import_zod46.z.date().nullable(),
-  lastDate: import_zod46.z.date().nullable(),
+  firstDate: import_zod46.z.coerce.date().nullable(),
+  lastDate: import_zod46.z.coerce.date().nullable(),
   labels: import_zod46.z.array(import_zod46.z.string()).nullable().default([])
 });
 var walletDeployerOutputSchema = import_zod46.z.object({
@@ -4441,28 +4446,28 @@ var PortfolioResponseSchema = import_zod50.z.object({
     }).optional(),
     pnl_history: import_zod50.z.object({
       "1y": import_zod50.z.array(import_zod50.z.tuple([
-        import_zod50.z.date(),
+        import_zod50.z.coerce.date(),
         import_zod50.z.object({
           realized: import_zod50.z.number(),
           unrealized: import_zod50.z.number()
         })
       ])),
       "7d": import_zod50.z.array(import_zod50.z.tuple([
-        import_zod50.z.date(),
+        import_zod50.z.coerce.date(),
         import_zod50.z.object({
           realized: import_zod50.z.number(),
           unrealized: import_zod50.z.number()
         })
       ])),
       "24h": import_zod50.z.array(import_zod50.z.tuple([
-        import_zod50.z.date(),
+        import_zod50.z.coerce.date(),
         import_zod50.z.object({
           realized: import_zod50.z.number(),
           unrealized: import_zod50.z.number()
         })
       ])),
       "30d": import_zod50.z.array(import_zod50.z.tuple([
-        import_zod50.z.date(),
+        import_zod50.z.coerce.date(),
         import_zod50.z.object({
           realized: import_zod50.z.number(),
           unrealized: import_zod50.z.number()
@@ -4550,28 +4555,28 @@ var MultiPortfolioResponseSchema = import_zod50.z.object({
     }).optional(),
     pnl_history: import_zod50.z.object({
       "1y": import_zod50.z.array(import_zod50.z.tuple([
-        import_zod50.z.date(),
+        import_zod50.z.coerce.date(),
         import_zod50.z.object({
           realized: import_zod50.z.number(),
           unrealized: import_zod50.z.number()
         })
       ])),
       "7d": import_zod50.z.array(import_zod50.z.tuple([
-        import_zod50.z.date(),
+        import_zod50.z.coerce.date(),
         import_zod50.z.object({
           realized: import_zod50.z.number(),
           unrealized: import_zod50.z.number()
         })
       ])),
       "24h": import_zod50.z.array(import_zod50.z.tuple([
-        import_zod50.z.date(),
+        import_zod50.z.coerce.date(),
         import_zod50.z.object({
           realized: import_zod50.z.number(),
           unrealized: import_zod50.z.number()
         })
       ])),
       "30d": import_zod50.z.array(import_zod50.z.tuple([
-        import_zod50.z.date(),
+        import_zod50.z.coerce.date(),
         import_zod50.z.object({
           realized: import_zod50.z.number(),
           unrealized: import_zod50.z.number()
@@ -4735,7 +4740,7 @@ var WalletTradesResponseSchema = import_zod52.z.object({
     ratio: import_zod52.z.number(),
     price_usd_token0: import_zod52.z.number(),
     price_usd_token1: import_zod52.z.number(),
-    date: import_zod52.z.date(),
+    date: import_zod52.z.coerce.date(),
     amount_usd: import_zod52.z.number(),
     pool_address: import_zod52.z.string(),
     token0_address: import_zod52.z.string(),
@@ -4816,7 +4821,7 @@ var WalletTransactionsResponseSchema = import_zod53.z.object({
         chainId: import_zod53.z.string(),
         fees: import_zod53.z.string(),
         feesUSD: import_zod53.z.number(),
-        date: import_zod53.z.date()
+        date: import_zod53.z.coerce.date()
       }),
       asset: import_zod53.z.object({
         id: import_zod53.z.number().nullable(),
@@ -4862,7 +4867,7 @@ var RawTransactionSchema = import_zod53.z.object({
     chainId: import_zod53.z.string(),
     fees: import_zod53.z.string(),
     feesUSD: import_zod53.z.number(),
-    date: import_zod53.z.date()
+    date: import_zod53.z.coerce.date()
   }),
   asset: import_zod53.z.object({
     id: import_zod53.z.number().nullable(),
@@ -5575,7 +5580,7 @@ var PerpOrderQuotingParamsSchema = import_zod63.z.object({
 var import_zod65 = require("zod");
 
 // src/v2/swap/SwapQuotingOutput.ts
-var import_zod_to_openapi2 = __toESM(require_dist());
+var import_zod_to_openapi2 = __toESM(require_dist(), 1);
 var import_zod64 = require("zod");
 import_zod_to_openapi2.extendZodWithOpenApi(import_zod64.z);
 var SolanaTransactionSchema = import_zod64.z.object({
@@ -6103,12 +6108,11 @@ var WalletAnalysisParamsSchema = import_zod76.z.object({
   }),
   from: import_zod76.z.coerce.number().optional(),
   to: import_zod76.z.coerce.number().optional()
-}).refine((data) => {
-  const hasPeriod = !!data.period;
-  const hasCustomRange = data.from !== undefined && data.to !== undefined;
-  return hasPeriod || hasCustomRange;
-}, {
-  message: "Either period or both from/to timestamps must be provided"
+}).transform((data) => {
+  if (!data.period && (data.from === undefined || data.to === undefined)) {
+    return { ...data, period: "7d" };
+  }
+  return data;
 }).refine((data) => {
   if (data.from !== undefined && data.to !== undefined) {
     return data.to > data.from;
@@ -6125,7 +6129,7 @@ var WalletAnalysisParamsSchemaOpenAPI = import_zod76.z.object({
   to: import_zod76.z.number().optional().describe("End timestamp in milliseconds (alternative to period)")
 });
 var CalendarDayBreakdownSchema = import_zod76.z.object({
-  date: import_zod76.z.date(),
+  date: import_zod76.z.coerce.date(),
   volumeBuy: import_zod76.z.number(),
   volumeSell: import_zod76.z.number(),
   totalVolume: import_zod76.z.number(),
@@ -6152,7 +6156,7 @@ var WalletAnalysisResponseSchema = import_zod76.z.object({
       "<100k": import_zod76.z.number()
     }),
     periodTimeframes: import_zod76.z.array(import_zod76.z.object({
-      date: import_zod76.z.date(),
+      date: import_zod76.z.coerce.date(),
       realized: import_zod76.z.number()
     })),
     calendarBreakdown: import_zod76.z.array(CalendarDayBreakdownSchema),
@@ -6165,7 +6169,7 @@ var WalletAnalysisResponseSchema = import_zod76.z.object({
       periodWinCount: import_zod76.z.number(),
       fundingInfo: import_zod76.z.object({
         from: import_zod76.z.string().nullable(),
-        date: import_zod76.z.date().nullable(),
+        date: import_zod76.z.coerce.date().nullable(),
         chainId: import_zod76.z.string().nullable(),
         txHash: import_zod76.z.string().nullable(),
         amount: import_zod76.z.string().nullable(),
@@ -6349,16 +6353,16 @@ var TokenPositionOutput = import_zod77.z.object({
   volumeSellUSD: import_zod77.z.string(),
   avgBuyPriceUSD: import_zod77.z.string(),
   avgSellPriceUSD: import_zod77.z.string(),
-  walletFundAt: import_zod77.z.date().nullable(),
-  lastActivityAt: import_zod77.z.date().nullable(),
-  firstTradeAt: import_zod77.z.date().nullable(),
-  lastTradeAt: import_zod77.z.date().nullable(),
+  walletFundAt: import_zod77.z.coerce.date().nullable(),
+  lastActivityAt: import_zod77.z.coerce.date().nullable(),
+  firstTradeAt: import_zod77.z.coerce.date().nullable(),
+  lastTradeAt: import_zod77.z.coerce.date().nullable(),
   labels: import_zod77.z.array(import_zod77.z.string()).nullable().optional().default([]),
   walletMetadata: WalletMetadataOutput.nullable().optional(),
   platform: PlatformMetadataSchema.nullable().optional(),
   fundingInfo: import_zod77.z.object({
     from: import_zod77.z.string().nullable(),
-    date: import_zod77.z.date().nullable(),
+    date: import_zod77.z.coerce.date().nullable(),
     chainId: import_zod77.z.string().nullable(),
     txHash: import_zod77.z.string().nullable(),
     amount: import_zod77.z.string().nullable(),
@@ -6639,175 +6643,213 @@ var TokenTradeOutputOpenAPI = import_zod81.z.object({
 var SingleTokenTradeResponseSchemaOpenAPI = import_zod81.z.object({
   data: TokenTradeOutputOpenAPI
 });
-// src/v2/wallet/WalletActivityV2Schema.ts
+// src/v2/trades/TradesFiltersSchema.ts
 var import_zod82 = require("zod");
-var WalletActivityV2ParamsSchema = import_zod82.z.object({
-  wallet: import_zod82.z.string(),
-  blockchains: import_zod82.z.string().optional().transform((val) => {
+var TRADES_FILTERS_MAX_TIMEFRAME_MS = Number(process.env["TRADES_FILTERS_MAX_TIMEFRAME_MS"]) || 60 * 60 * 1000;
+var TRADES_FILTERS_MAX_LIMIT = Number(process.env["TRADES_FILTERS_MAX_LIMIT"]) || 5000;
+var TradesFiltersParamsSchema = import_zod82.z.object({
+  tokenAddress: import_zod82.z.string().optional(),
+  blockchain: import_zod82.z.string().optional(),
+  from: DateQuery_default.refine((val) => val !== undefined, { message: "from date is required" }),
+  to: DateQuery_default.refine((val) => val !== undefined, { message: "to date is required" }),
+  limit: import_zod82.z.coerce.number().min(1).max(TRADES_FILTERS_MAX_LIMIT).optional().default(1000),
+  cursor: import_zod82.z.string().optional(),
+  sortOrder: import_zod82.z.enum(["asc", "desc"]).default("asc")
+}).refine((data) => {
+  if (!data.from || !data.to)
+    return false;
+  const fromTime = data.from.getTime();
+  const toTime = data.to.getTime();
+  return toTime - fromTime <= TRADES_FILTERS_MAX_TIMEFRAME_MS;
+}, {
+  message: `Timeframe cannot exceed 1 hour (${TRADES_FILTERS_MAX_TIMEFRAME_MS}ms)`
+}).refine((data) => {
+  if (!data.from || !data.to)
+    return false;
+  return data.from.getTime() < data.to.getTime();
+}, {
+  message: "from date must be before to date"
+});
+var TradesFiltersPaginationSchema = import_zod82.z.object({
+  count: import_zod82.z.number(),
+  nextCursor: import_zod82.z.string().nullable(),
+  hasMore: import_zod82.z.boolean(),
+  from: import_zod82.z.number(),
+  to: import_zod82.z.number()
+});
+var TradesFiltersResponseSchema = import_zod82.z.object({
+  data: import_zod82.z.array(TokenTradeOutput),
+  pagination: TradesFiltersPaginationSchema
+});
+// src/v2/wallet/WalletActivityV2Schema.ts
+var import_zod83 = require("zod");
+var WalletActivityV2ParamsSchema = import_zod83.z.object({
+  wallet: import_zod83.z.string(),
+  blockchains: import_zod83.z.string().optional().transform((val) => {
     if (val) {
       return val.split(",").map((b) => b.trim()).filter((b) => b.length > 0);
     }
     return [];
   }),
-  blacklist: import_zod82.z.string().optional().transform((val) => val ? val.split(",").map((addr) => addr.trim().toLowerCase()) : []),
-  offset: import_zod82.z.coerce.number().optional().default(0),
-  limit: import_zod82.z.coerce.number().optional().default(100),
-  order: import_zod82.z.enum(["asc", "desc"]).optional().default("desc"),
-  pagination: import_zod82.z.union([import_zod82.z.boolean(), import_zod82.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
-  unlistedAssets: import_zod82.z.union([import_zod82.z.boolean(), import_zod82.z.string()]).optional().transform((val) => val === true || val === "true").default(true),
-  filterSpam: import_zod82.z.union([import_zod82.z.boolean(), import_zod82.z.string()]).optional().transform((val) => val === true || val === "true").default(true),
-  backfillTransfers: import_zod82.z.union([import_zod82.z.boolean(), import_zod82.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
-  backfillBalances: import_zod82.z.union([import_zod82.z.boolean(), import_zod82.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
-  cursorHash: import_zod82.z.string().optional(),
-  cursorDirection: import_zod82.z.enum(["before", "after"]).optional(),
-  cursor_hash: import_zod82.z.string().optional(),
-  cursor_direction: import_zod82.z.enum(["before", "after"]).optional(),
-  withTokens: import_zod82.z.union([import_zod82.z.boolean(), import_zod82.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
-  enrichSwaps: import_zod82.z.union([import_zod82.z.boolean(), import_zod82.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
-  from: import_zod82.z.coerce.number().optional(),
-  to: import_zod82.z.coerce.number().optional()
+  blacklist: import_zod83.z.string().optional().transform((val) => val ? val.split(",").map((addr) => addr.trim().toLowerCase()) : []),
+  offset: import_zod83.z.coerce.number().optional().default(0),
+  limit: import_zod83.z.coerce.number().optional().default(100),
+  order: import_zod83.z.enum(["asc", "desc"]).optional().default("desc"),
+  pagination: import_zod83.z.union([import_zod83.z.boolean(), import_zod83.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
+  unlistedAssets: import_zod83.z.union([import_zod83.z.boolean(), import_zod83.z.string()]).optional().transform((val) => val === true || val === "true").default(true),
+  filterSpam: import_zod83.z.union([import_zod83.z.boolean(), import_zod83.z.string()]).optional().transform((val) => val === true || val === "true").default(true),
+  backfillTransfers: import_zod83.z.union([import_zod83.z.boolean(), import_zod83.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
+  backfillBalances: import_zod83.z.union([import_zod83.z.boolean(), import_zod83.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
+  cursorHash: import_zod83.z.string().optional(),
+  cursorDirection: import_zod83.z.enum(["before", "after"]).optional(),
+  cursor_hash: import_zod83.z.string().optional(),
+  cursor_direction: import_zod83.z.enum(["before", "after"]).optional(),
+  withTokens: import_zod83.z.union([import_zod83.z.boolean(), import_zod83.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
+  enrichSwaps: import_zod83.z.union([import_zod83.z.boolean(), import_zod83.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
+  from: import_zod83.z.coerce.number().optional(),
+  to: import_zod83.z.coerce.number().optional()
 }).transform((data) => ({
   ...data,
   cursorHash: data.cursorHash ?? data.cursor_hash,
   cursorDirection: data.cursorDirection ?? data.cursor_direction ?? "before"
 }));
-var ActivityAssetSchema = import_zod82.z.object({
-  id: import_zod82.z.number().nullable(),
-  name: import_zod82.z.string(),
-  symbol: import_zod82.z.string(),
-  decimals: import_zod82.z.number(),
-  totalSupply: import_zod82.z.number(),
-  circulatingSupply: import_zod82.z.number(),
-  price: import_zod82.z.number(),
-  liquidity: import_zod82.z.number(),
-  priceChange24hPercent: import_zod82.z.number(),
-  marketCapUsd: import_zod82.z.number(),
-  logo: import_zod82.z.string().nullable(),
-  contract: import_zod82.z.string()
-});
-var WalletActivityV2TransactionActivitySchema = import_zod82.z.object({
-  model: import_zod82.z.enum(["swap", "transfer"]),
-  swapType: import_zod82.z.enum(["REGULAR", "MEV", "SANDWICHED_MEV", "DEPOSIT", "WITHDRAW"]).optional(),
-  swapRawAmountOut: import_zod82.z.number().optional(),
-  swapRawAmountIn: import_zod82.z.number().optional(),
-  swapAmountOut: import_zod82.z.number().optional(),
-  swapAmountIn: import_zod82.z.number().optional(),
-  swapPriceUsdTokenOut: import_zod82.z.number().optional(),
-  swapPriceUsdTokenIn: import_zod82.z.number().optional(),
-  swapAmountUsd: import_zod82.z.number().optional(),
-  swapTransactionSenderAddress: import_zod82.z.string().optional(),
-  swapBaseAddress: import_zod82.z.string().optional(),
-  swapQuoteAddress: import_zod82.z.string().optional(),
-  swapAmountQuote: import_zod82.z.number().optional(),
-  swapAmountBase: import_zod82.z.number().optional(),
+var ActivityAssetSchema = import_zod83.z.object({
+  id: import_zod83.z.number().nullable(),
+  name: import_zod83.z.string(),
+  symbol: import_zod83.z.string(),
+  decimals: import_zod83.z.number(),
+  totalSupply: import_zod83.z.number(),
+  circulatingSupply: import_zod83.z.number(),
+  price: import_zod83.z.number(),
+  liquidity: import_zod83.z.number(),
+  priceChange24hPercent: import_zod83.z.number(),
+  marketCapUsd: import_zod83.z.number(),
+  logo: import_zod83.z.string().nullable(),
+  contract: import_zod83.z.string()
+});
+var WalletActivityV2TransactionActivitySchema = import_zod83.z.object({
+  model: import_zod83.z.enum(["swap", "transfer"]),
+  swapType: import_zod83.z.enum(["REGULAR", "MEV", "SANDWICHED_MEV", "DEPOSIT", "WITHDRAW"]).optional(),
+  swapRawAmountOut: import_zod83.z.number().optional(),
+  swapRawAmountIn: import_zod83.z.number().optional(),
+  swapAmountOut: import_zod83.z.number().optional(),
+  swapAmountIn: import_zod83.z.number().optional(),
+  swapPriceUsdTokenOut: import_zod83.z.number().optional(),
+  swapPriceUsdTokenIn: import_zod83.z.number().optional(),
+  swapAmountUsd: import_zod83.z.number().optional(),
+  swapTransactionSenderAddress: import_zod83.z.string().optional(),
+  swapBaseAddress: import_zod83.z.string().optional(),
+  swapQuoteAddress: import_zod83.z.string().optional(),
+  swapAmountQuote: import_zod83.z.number().optional(),
+  swapAmountBase: import_zod83.z.number().optional(),
   swapAssetIn: ActivityAssetSchema.optional(),
   swapAssetOut: ActivityAssetSchema.optional(),
   swapPlatform: PlatformMetadataOutput.nullable().optional(),
-  swapTotalFeesUsd: import_zod82.z.number().nullable().optional(),
-  swapGasFeesUsd: import_zod82.z.number().nullable().optional(),
-  swapPlatformFeesUsd: import_zod82.z.number().nullable().optional(),
-  swapMevFeesUsd: import_zod82.z.number().nullable().optional(),
-  transferRawAmount: import_zod82.z.string().optional(),
-  transferAmount: import_zod82.z.number().optional(),
-  transferAmountUsd: import_zod82.z.number().optional(),
-  transferType: import_zod82.z.enum(["VAULT_DEPOSIT", "VAULT_WITHDRAW", "VAULT_UNSTAKE", "TOKEN_IN", "TOKEN_OUT", "NATIVE_IN", "NATIVE_OUT"]).optional(),
-  transferFromAddress: import_zod82.z.string().optional().nullable(),
-  transferToAddress: import_zod82.z.string().optional().nullable(),
+  swapTotalFeesUsd: import_zod83.z.number().nullable().optional(),
+  swapGasFeesUsd: import_zod83.z.number().nullable().optional(),
+  swapPlatformFeesUsd: import_zod83.z.number().nullable().optional(),
+  swapMevFeesUsd: import_zod83.z.number().nullable().optional(),
+  transferRawAmount: import_zod83.z.string().optional(),
+  transferAmount: import_zod83.z.number().optional(),
+  transferAmountUsd: import_zod83.z.number().optional(),
+  transferType: import_zod83.z.enum(["VAULT_DEPOSIT", "VAULT_WITHDRAW", "VAULT_UNSTAKE", "TOKEN_IN", "TOKEN_OUT", "NATIVE_IN", "NATIVE_OUT"]).optional(),
+  transferFromAddress: import_zod83.z.string().optional().nullable(),
+  transferToAddress: import_zod83.z.string().optional().nullable(),
   transferAsset: ActivityAssetSchema.optional()
 });
-var WalletActivityV2TransactionSchema = import_zod82.z.object({
-  chainId: import_zod82.z.string(),
-  txDateMs: import_zod82.z.number(),
-  txDateIso: import_zod82.z.string(),
-  txHash: import_zod82.z.string(),
-  txRawFeesNative: import_zod82.z.string(),
-  txFeesNativeUsd: import_zod82.z.number(),
-  txBlockNumber: import_zod82.z.number(),
-  txIndex: import_zod82.z.number(),
-  txAction: import_zod82.z.string().optional().nullable(),
-  actions: import_zod82.z.array(WalletActivityV2TransactionActivitySchema)
-});
-var WalletActivityV2OutputDataSchema = import_zod82.z.array(WalletActivityV2TransactionSchema);
-var WalletActivityV2OutputPaginationSchema = import_zod82.z.object({
-  page: import_zod82.z.number(),
-  offset: import_zod82.z.number(),
-  limit: import_zod82.z.number(),
-  pageEntries: import_zod82.z.number()
-});
-var WalletActivityV2ResponseSchema = import_zod82.z.object({
+var WalletActivityV2TransactionSchema = import_zod83.z.object({
+  chainId: import_zod83.z.string(),
+  txDateMs: import_zod83.z.number(),
+  txDateIso: import_zod83.z.string(),
+  txHash: import_zod83.z.string(),
+  txRawFeesNative: import_zod83.z.string(),
+  txFeesNativeUsd: import_zod83.z.number(),
+  txBlockNumber: import_zod83.z.number(),
+  txIndex: import_zod83.z.number(),
+  txAction: import_zod83.z.string().optional().nullable(),
+  actions: import_zod83.z.array(WalletActivityV2TransactionActivitySchema)
+});
+var WalletActivityV2OutputDataSchema = import_zod83.z.array(WalletActivityV2TransactionSchema);
+var WalletActivityV2OutputPaginationSchema = import_zod83.z.object({
+  page: import_zod83.z.number(),
+  offset: import_zod83.z.number(),
+  limit: import_zod83.z.number(),
+  pageEntries: import_zod83.z.number()
+});
+var WalletActivityV2ResponseSchema = import_zod83.z.object({
   data: WalletActivityV2OutputDataSchema,
   pagination: WalletActivityV2OutputPaginationSchema,
-  backfillStatus: import_zod82.z.enum(["processed", "processing", "pending"]).optional(),
-  tokens: import_zod82.z.array(TokenDetailsOutput).optional()
+  backfillStatus: import_zod83.z.enum(["processed", "processing", "pending"]).optional(),
+  tokens: import_zod83.z.array(TokenDetailsOutput).optional()
 });
 // src/v2/wallet/WalletDefiPositionsSchema.ts
-var import_zod83 = require("zod");
-var walletAddressSchema = import_zod83.z.string().min(32, "Invalid wallet address").max(44, "Invalid wallet address").or(import_zod83.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid EVM wallet address"));
-var WalletDefiPositionsParamsSchema = import_zod83.z.object({
+var import_zod84 = require("zod");
+var walletAddressSchema = import_zod84.z.string().min(32, "Invalid wallet address").max(44, "Invalid wallet address").or(import_zod84.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid EVM wallet address"));
+var WalletDefiPositionsParamsSchema = import_zod84.z.object({
   wallet: walletAddressSchema.describe("Wallet address (EVM or Solana)"),
-  blockchains: import_zod83.z.string().describe('Blockchain to fetch positions from (e.g., "solana", "ethereum")')
+  blockchains: import_zod84.z.string().describe('Blockchain to fetch positions from (e.g., "solana", "ethereum")')
 });
 // src/v2/wallet/WalletDeployerSchema.ts
 var WalletV2DeployerParamsSchema = WalletDeployerQuery;
 var WalletV2DeployerResponseSchema = walletDeployerOutputSchema;
 // src/v2/wallet/WalletFundingQuerySchema.ts
-var import_zod84 = require("zod");
-var WalletFundingParamsSchema = import_zod84.z.object({
-  wallet: import_zod84.z.string().min(1, "Wallet address is required")
-});
-var WalletFundingResponseSchema = import_zod84.z.object({
-  data: import_zod84.z.object({
-    from: import_zod84.z.string().nullable(),
-    chainId: import_zod84.z.string().nullable(),
-    date: import_zod84.z.date().nullable(),
-    txHash: import_zod84.z.string().nullable(),
-    amount: import_zod84.z.string().nullable(),
-    fromWalletLogo: import_zod84.z.string().nullable(),
-    fromWalletTag: import_zod84.z.string().nullable()
+var import_zod85 = require("zod");
+var WalletFundingParamsSchema = import_zod85.z.object({
+  wallet: import_zod85.z.string().min(1, "Wallet address is required")
+});
+var WalletFundingResponseSchema = import_zod85.z.object({
+  data: import_zod85.z.object({
+    from: import_zod85.z.string().nullable(),
+    chainId: import_zod85.z.string().nullable(),
+    date: import_zod85.z.coerce.date().nullable(),
+    txHash: import_zod85.z.string().nullable(),
+    amount: import_zod85.z.string().nullable(),
+    fromWalletLogo: import_zod85.z.string().nullable(),
+    fromWalletTag: import_zod85.z.string().nullable()
   })
 });
 // src/v2/wallet/WalletPerpsPositionsSchema.ts
-var import_zod85 = require("zod");
-var ExchangesIds = import_zod85.z.enum(["gains", "hyperliquid", "gte", "lighter", "drift"]);
-var tpSlSchema = import_zod85.z.object({ size: import_zod85.z.bigint(), price: import_zod85.z.number(), id: import_zod85.z.number() });
-var PerpsPositionSchema = import_zod85.z.object({
-  id: import_zod85.z.string(),
-  entryPriceQuote: import_zod85.z.number(),
-  currentLeverage: import_zod85.z.number(),
-  amountUSD: import_zod85.z.number(),
-  amountRaw: import_zod85.z.bigint(),
-  side: import_zod85.z.enum(["BUY", "SELL"]),
-  liquidationPriceQuote: import_zod85.z.number(),
-  currentPriceQuote: import_zod85.z.number(),
-  realizedPnlUSD: import_zod85.z.number(),
-  unrealizedPnlUSD: import_zod85.z.number(),
-  realizedPnlPercent: import_zod85.z.number(),
-  unrealizedPnlPercent: import_zod85.z.number(),
-  tp: import_zod85.z.array(tpSlSchema),
-  sl: import_zod85.z.array(tpSlSchema),
-  marketId: import_zod85.z.string(),
+var import_zod86 = require("zod");
+var ExchangesIds = import_zod86.z.enum(["gains", "hyperliquid", "gte", "lighter", "drift"]);
+var tpSlSchema = import_zod86.z.object({ size: import_zod86.z.bigint(), price: import_zod86.z.number(), id: import_zod86.z.number() });
+var PerpsPositionSchema = import_zod86.z.object({
+  id: import_zod86.z.string(),
+  entryPriceQuote: import_zod86.z.number(),
+  currentLeverage: import_zod86.z.number(),
+  amountUSD: import_zod86.z.number(),
+  amountRaw: import_zod86.z.bigint(),
+  side: import_zod86.z.enum(["BUY", "SELL"]),
+  liquidationPriceQuote: import_zod86.z.number(),
+  currentPriceQuote: import_zod86.z.number(),
+  realizedPnlUSD: import_zod86.z.number(),
+  unrealizedPnlUSD: import_zod86.z.number(),
+  realizedPnlPercent: import_zod86.z.number(),
+  unrealizedPnlPercent: import_zod86.z.number(),
+  tp: import_zod86.z.array(tpSlSchema),
+  sl: import_zod86.z.array(tpSlSchema),
+  marketId: import_zod86.z.string(),
   exchange: ExchangesIds,
-  feesOpeningUSD: import_zod85.z.number(),
-  feesClosingUSD: import_zod85.z.number(),
-  feesFundingUSD: import_zod85.z.number(),
-  openDate: import_zod85.z.date(),
-  lastUpdate: import_zod85.z.date(),
-  address: import_zod85.z.string(),
-  chainId: import_zod85.z.string(),
-  collateralAsset: import_zod85.z.string()
+  feesOpeningUSD: import_zod86.z.number(),
+  feesClosingUSD: import_zod86.z.number(),
+  feesFundingUSD: import_zod86.z.number(),
+  openDate: import_zod86.z.coerce.date(),
+  lastUpdate: import_zod86.z.coerce.date(),
+  address: import_zod86.z.string(),
+  chainId: import_zod86.z.string(),
+  collateralAsset: import_zod86.z.string()
 });
 var PerpsPositionNonExecutedSchema = PerpsPositionSchema.extend({
-  type: import_zod85.z.enum(["STOP", "LIMIT"])
+  type: import_zod86.z.enum(["STOP", "LIMIT"])
 });
-var WalletPerpsPositionsResponseSchema = import_zod85.z.object({
-  data: import_zod85.z.array(PerpsPositionSchema)
+var WalletPerpsPositionsResponseSchema = import_zod86.z.object({
+  data: import_zod86.z.array(PerpsPositionSchema)
 });
-var WalletPerpsPositionsNonExecutedResponseSchema = import_zod85.z.object({
-  data: import_zod85.z.array(PerpsPositionNonExecutedSchema)
+var WalletPerpsPositionsNonExecutedResponseSchema = import_zod86.z.object({
+  data: import_zod86.z.array(PerpsPositionNonExecutedSchema)
 });
 // src/v2/wallet/WalletPositionsSchema.ts
-var import_zod86 = require("zod");
-var PositionSortBySchema = import_zod86.z.enum(["lastActivity", "realizedPnl"]).default("lastActivity");
+var import_zod87 = require("zod");
+var PositionSortBySchema = import_zod87.z.enum(["lastActivity", "realizedPnl"]).default("lastActivity");
 var positionSortByToInternal = (sortBy) => {
   const mapping = {
     lastActivity: "last_activity",
@@ -6815,287 +6857,287 @@ var positionSortByToInternal = (sortBy) => {
   };
   return mapping[sortBy];
 };
-var WalletPositionsParamsSchema = import_zod86.z.object({
-  wallet: import_zod86.z.string(),
-  blockchain: import_zod86.z.string().optional(),
-  limit: import_zod86.z.coerce.number().min(1).max(500).optional().default(100),
-  offset: import_zod86.z.coerce.number().min(0).optional().default(0),
-  cursor: import_zod86.z.string().optional(),
-  cursorDirection: import_zod86.z.enum(["before", "after"]).optional().default("after"),
+var WalletPositionsParamsSchema = import_zod87.z.object({
+  wallet: import_zod87.z.string(),
+  blockchain: import_zod87.z.string().optional(),
+  limit: import_zod87.z.coerce.number().min(1).max(500).optional().default(100),
+  offset: import_zod87.z.coerce.number().min(0).optional().default(0),
+  cursor: import_zod87.z.string().optional(),
+  cursorDirection: import_zod87.z.enum(["before", "after"]).optional().default("after"),
   sortBy: PositionSortBySchema.optional(),
-  order: import_zod86.z.enum(["asc", "desc"]).optional().default("desc"),
-  _backfillPositions: import_zod86.z.union([import_zod86.z.boolean(), import_zod86.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
-  _backfillSwapsAndPositions: import_zod86.z.union([import_zod86.z.boolean(), import_zod86.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
-  includeFees: import_zod86.z.union([import_zod86.z.boolean(), import_zod86.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
-  useSwapRecipient: import_zod86.z.union([import_zod86.z.boolean(), import_zod86.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
-});
-var SinglePositionQuery = import_zod86.z.object({
-  wallet: import_zod86.z.string(),
-  asset: import_zod86.z.string(),
-  blockchain: import_zod86.z.string(),
-  includeFees: import_zod86.z.union([import_zod86.z.boolean(), import_zod86.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
-  useSwapRecipient: import_zod86.z.union([import_zod86.z.boolean(), import_zod86.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
-});
-var SinglePositionItemSchema = import_zod86.z.object({
-  wallet: import_zod86.z.string(),
-  asset: import_zod86.z.string(),
-  blockchain: import_zod86.z.string(),
-  includeFees: import_zod86.z.union([import_zod86.z.boolean(), import_zod86.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
-  useSwapRecipient: import_zod86.z.union([import_zod86.z.boolean(), import_zod86.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
-});
-var SinglePositionBatchParamsSchema = import_zod86.z.union([
-  import_zod86.z.array(SinglePositionItemSchema),
-  import_zod86.z.object({
-    items: import_zod86.z.array(SinglePositionItemSchema),
-    instanceTracking: import_zod86.z.preprocess((val) => {
+  order: import_zod87.z.enum(["asc", "desc"]).optional().default("desc"),
+  _backfillPositions: import_zod87.z.union([import_zod87.z.boolean(), import_zod87.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  _backfillSwapsAndPositions: import_zod87.z.union([import_zod87.z.boolean(), import_zod87.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  includeFees: import_zod87.z.union([import_zod87.z.boolean(), import_zod87.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  useSwapRecipient: import_zod87.z.union([import_zod87.z.boolean(), import_zod87.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+});
+var SinglePositionQuery = import_zod87.z.object({
+  wallet: import_zod87.z.string(),
+  asset: import_zod87.z.string(),
+  blockchain: import_zod87.z.string(),
+  includeFees: import_zod87.z.union([import_zod87.z.boolean(), import_zod87.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  useSwapRecipient: import_zod87.z.union([import_zod87.z.boolean(), import_zod87.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+});
+var SinglePositionItemSchema = import_zod87.z.object({
+  wallet: import_zod87.z.string(),
+  asset: import_zod87.z.string(),
+  blockchain: import_zod87.z.string(),
+  includeFees: import_zod87.z.union([import_zod87.z.boolean(), import_zod87.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  useSwapRecipient: import_zod87.z.union([import_zod87.z.boolean(), import_zod87.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+});
+var SinglePositionBatchParamsSchema = import_zod87.z.union([
+  import_zod87.z.array(SinglePositionItemSchema),
+  import_zod87.z.object({
+    items: import_zod87.z.array(SinglePositionItemSchema),
+    instanceTracking: import_zod87.z.preprocess((val) => {
       if (val === "true")
         return true;
       if (val === "false")
         return false;
       return val;
-    }, import_zod86.z.boolean().optional())
+    }, import_zod87.z.boolean().optional())
   })
 ]);
-var WalletPositionsPaginationSchema = import_zod86.z.object({
-  page: import_zod86.z.number(),
-  offset: import_zod86.z.number(),
-  limit: import_zod86.z.number(),
-  pageEntries: import_zod86.z.number()
-});
-var WalletPositionsResponseSchema = import_zod86.z.object({
-  data: import_zod86.z.array(tokenPositionSchema),
+var WalletPositionsPaginationSchema = import_zod87.z.object({
+  page: import_zod87.z.number(),
+  offset: import_zod87.z.number(),
+  limit: import_zod87.z.number(),
+  pageEntries: import_zod87.z.number()
+});
+var WalletPositionsResponseSchema = import_zod87.z.object({
+  data: import_zod87.z.array(tokenPositionSchema),
   wallet: WalletMetadataSchema.optional(),
   pagination: WalletPositionsPaginationSchema.optional()
 });
-var singlePositionOutputSchema = import_zod86.z.object({
+var singlePositionOutputSchema = import_zod87.z.object({
   data: tokenPositionSchema,
   wallet: WalletMetadataSchema.optional()
 });
 var batchPositionItemSchema = tokenPositionSchema.extend({
-  wallet: import_zod86.z.string()
+  wallet: import_zod87.z.string()
 });
-var SinglePositionBatchResponseSchema = import_zod86.z.object({
-  payload: import_zod86.z.array(batchPositionItemSchema.or(import_zod86.z.object({ error: import_zod86.z.string().optional(), wallet: import_zod86.z.string().optional() })).nullable()),
-  hostname: import_zod86.z.string().optional()
+var SinglePositionBatchResponseSchema = import_zod87.z.object({
+  payload: import_zod87.z.array(batchPositionItemSchema.or(import_zod87.z.object({ error: import_zod87.z.string().optional(), wallet: import_zod87.z.string().optional() })).nullable()),
+  hostname: import_zod87.z.string().optional()
 });
 // src/v2/wallet/WalletTokenBalancesSchema.ts
-var import_zod87 = require("zod");
-var tokenHoldingSchema = import_zod87.z.object({
-  token: import_zod87.z.object({
-    address: import_zod87.z.string(),
-    chainId: import_zod87.z.string(),
-    name: import_zod87.z.string().nullable(),
-    symbol: import_zod87.z.string().nullable(),
-    logo: import_zod87.z.string().nullable(),
-    decimals: import_zod87.z.coerce.number().default(0),
-    holdersCount: import_zod87.z.coerce.number().default(0),
-    deployer: import_zod87.z.string().nullable(),
-    website: import_zod87.z.string().nullable(),
-    x: import_zod87.z.string().nullable(),
-    telegram: import_zod87.z.string().nullable(),
-    description: import_zod87.z.string().nullable(),
+var import_zod88 = require("zod");
+var tokenHoldingSchema = import_zod88.z.object({
+  token: import_zod88.z.object({
+    address: import_zod88.z.string(),
+    chainId: import_zod88.z.string(),
+    name: import_zod88.z.string().nullable(),
+    symbol: import_zod88.z.string().nullable(),
+    logo: import_zod88.z.string().nullable(),
+    decimals: import_zod88.z.coerce.number().default(0),
+    holdersCount: import_zod88.z.coerce.number().default(0),
+    deployer: import_zod88.z.string().nullable(),
+    website: import_zod88.z.string().nullable(),
+    x: import_zod88.z.string().nullable(),
+    telegram: import_zod88.z.string().nullable(),
+    description: import_zod88.z.string().nullable(),
     security: SecurityFlagsSchema.nullable()
   }),
-  balance: import_zod87.z.number(),
-  rawBalance: import_zod87.z.string(),
-  lamports: import_zod87.z.string().nullable().optional()
+  balance: import_zod88.z.number(),
+  rawBalance: import_zod88.z.string(),
+  lamports: import_zod88.z.string().nullable().optional()
 });
-var WalletHoldingsResponseSchema = import_zod87.z.object({
-  data: import_zod87.z.array(tokenHoldingSchema)
+var WalletHoldingsResponseSchema = import_zod88.z.object({
+  data: import_zod88.z.array(tokenHoldingSchema)
 });
 // src/wss/aggregated-feed/FeedSchema.ts
-var import_zod88 = require("zod");
-var FeedPayloadSchema = import_zod88.z.discriminatedUnion("kind", [
-  import_zod88.z.object({
-    kind: import_zod88.z.literal("asset_ids"),
-    asset_ids: import_zod88.z.array(import_zod88.z.number()).optional(),
-    quote_id: import_zod88.z.number().optional().nullable()
+var import_zod89 = require("zod");
+var FeedPayloadSchema = import_zod89.z.discriminatedUnion("kind", [
+  import_zod89.z.object({
+    kind: import_zod89.z.literal("asset_ids"),
+    asset_ids: import_zod89.z.array(import_zod89.z.number()).optional(),
+    quote_id: import_zod89.z.number().optional().nullable()
   }),
-  import_zod88.z.object({
-    kind: import_zod88.z.literal("address"),
-    tokens: import_zod88.z.array(import_zod88.z.object({
-      blockchain: import_zod88.z.string(),
-      address: import_zod88.z.string()
+  import_zod89.z.object({
+    kind: import_zod89.z.literal("address"),
+    tokens: import_zod89.z.array(import_zod89.z.object({
+      blockchain: import_zod89.z.string(),
+      address: import_zod89.z.string()
     })),
-    quote: import_zod88.z.object({
-      address: import_zod88.z.string(),
-      blockchain: import_zod88.z.string()
+    quote: import_zod89.z.object({
+      address: import_zod89.z.string(),
+      blockchain: import_zod89.z.string()
     }).optional()
   }),
-  import_zod88.z.object({
-    kind: import_zod88.z.literal("all")
+  import_zod89.z.object({
+    kind: import_zod89.z.literal("all")
   })
 ]);
-var FeedAssetIdSchema = import_zod88.z.object({
-  asset_ids: import_zod88.z.array(import_zod88.z.number()).optional(),
-  quote_id: import_zod88.z.number().optional().nullable()
-});
-var FeedTokenSchema = import_zod88.z.object({
-  tokens: import_zod88.z.array(import_zod88.z.object({
-    blockchain: import_zod88.z.string(),
-    address: import_zod88.z.string()
+var FeedAssetIdSchema = import_zod89.z.object({
+  asset_ids: import_zod89.z.array(import_zod89.z.number()).optional(),
+  quote_id: import_zod89.z.number().optional().nullable()
+});
+var FeedTokenSchema = import_zod89.z.object({
+  tokens: import_zod89.z.array(import_zod89.z.object({
+    blockchain: import_zod89.z.string(),
+    address: import_zod89.z.string()
   })),
-  quote: import_zod88.z.object({
-    address: import_zod88.z.string(),
-    blockchain: import_zod88.z.string()
+  quote: import_zod89.z.object({
+    address: import_zod89.z.string(),
+    blockchain: import_zod89.z.string()
   }).optional()
 });
 // src/wss/BalancePayloadSchema.ts
-var import_zod89 = require("zod");
-var BalanceItemSchema = import_zod89.z.object({
-  wallet: import_zod89.z.string(),
-  token: import_zod89.z.string(),
-  blockchain: import_zod89.z.string()
+var import_zod90 = require("zod");
+var BalanceItemSchema = import_zod90.z.object({
+  wallet: import_zod90.z.string(),
+  token: import_zod90.z.string(),
+  blockchain: import_zod90.z.string()
 });
-var BalancePayloadSchema = import_zod89.z.object({
-  items: import_zod89.z.array(BalanceItemSchema),
-  subscriptionId: import_zod89.z.string().optional(),
-  subscriptionTracking: import_zod89.z.union([import_zod89.z.boolean(), import_zod89.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+var BalancePayloadSchema = import_zod90.z.object({
+  items: import_zod90.z.array(BalanceItemSchema),
+  subscriptionId: import_zod90.z.string().optional(),
+  subscriptionTracking: import_zod90.z.union([import_zod90.z.boolean(), import_zod90.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 // src/wss/FastTradePayloadSchema.ts
-var import_zod90 = require("zod");
-var FastTradesPayloadSchema = import_zod90.z.object({
-  assetMode: import_zod90.z.coerce.boolean().default(false),
-  items: import_zod90.z.array(import_zod90.z.object({
-    address: import_zod90.z.string(),
-    blockchain: import_zod90.z.string()
+var import_zod91 = require("zod");
+var FastTradesPayloadSchema = import_zod91.z.object({
+  assetMode: import_zod91.z.coerce.boolean().default(false),
+  items: import_zod91.z.array(import_zod91.z.object({
+    address: import_zod91.z.string(),
+    blockchain: import_zod91.z.string()
   })),
-  subscriptionId: import_zod90.z.string().optional(),
-  subscriptionTracking: import_zod90.z.union([import_zod90.z.boolean(), import_zod90.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+  subscriptionId: import_zod91.z.string().optional(),
+  subscriptionTracking: import_zod91.z.union([import_zod91.z.boolean(), import_zod91.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 // src/wss/FundingPayloadSchema.ts
-var import_zod91 = require("zod");
-var FundingPayloadSchema = import_zod91.z.object({
-  symbol: import_zod91.z.string(),
-  quote: import_zod91.z.string().optional(),
-  exchange: import_zod91.z.string().optional().transform((val) => {
+var import_zod92 = require("zod");
+var FundingPayloadSchema = import_zod92.z.object({
+  symbol: import_zod92.z.string(),
+  quote: import_zod92.z.string().optional(),
+  exchange: import_zod92.z.string().optional().transform((val) => {
     const validExchanges = ["binance", "bybit", "hyperliquid", "deribit", "okx", "gate", "lighter"];
     if (!val)
       return validExchanges;
     const requestedExchanges = val.split(",").map((ex) => ex.trim().toLowerCase()).filter((ex) => validExchanges.includes(ex));
     return requestedExchanges.length > 0 ? requestedExchanges : validExchanges;
   }),
-  interval: import_zod91.z.number().optional().default(5),
-  subscriptionId: import_zod91.z.string().optional(),
-  subscriptionTracking: import_zod91.z.string().optional()
-});
-// src/wss/HoldersPayloadSchema.ts
-var import_zod92 = require("zod");
-var HoldersPayloadSchema = import_zod92.z.object({
-  tokens: import_zod92.z.array(import_zod92.z.object({
-    address: import_zod92.z.string(),
-    blockchain: import_zod92.z.string()
-  })),
+  interval: import_zod92.z.number().optional().default(5),
   subscriptionId: import_zod92.z.string().optional(),
-  subscriptionTracking: import_zod92.z.union([import_zod92.z.boolean(), import_zod92.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+  subscriptionTracking: import_zod92.z.string().optional()
 });
-// src/wss/MarketDetailsPayloadSchema.ts
+// src/wss/HoldersPayloadSchema.ts
 var import_zod93 = require("zod");
-var MarketDetailsPayloadSchema = import_zod93.z.object({
-  pools: import_zod93.z.array(import_zod93.z.object({
+var HoldersPayloadSchema = import_zod93.z.object({
+  tokens: import_zod93.z.array(import_zod93.z.object({
     address: import_zod93.z.string(),
     blockchain: import_zod93.z.string()
   })),
   subscriptionId: import_zod93.z.string().optional(),
   subscriptionTracking: import_zod93.z.union([import_zod93.z.boolean(), import_zod93.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
-// src/wss/MarketPayloadSchema.ts
+// src/wss/MarketDetailsPayloadSchema.ts
 var import_zod94 = require("zod");
-var MarketPayloadSchema = import_zod94.z.object({
-  interval: import_zod94.z.number().default(30),
+var MarketDetailsPayloadSchema = import_zod94.z.object({
+  pools: import_zod94.z.array(import_zod94.z.object({
+    address: import_zod94.z.string(),
+    blockchain: import_zod94.z.string()
+  })),
   subscriptionId: import_zod94.z.string().optional(),
-  assets: import_zod94.z.array(import_zod94.z.union([
-    import_zod94.z.object({ name: import_zod94.z.string() }),
-    import_zod94.z.object({ symbol: import_zod94.z.string() }),
-    import_zod94.z.object({
-      address: import_zod94.z.string(),
-      blockchain: import_zod94.z.string()
-    })
-  ])).max(100),
   subscriptionTracking: import_zod94.z.union([import_zod94.z.boolean(), import_zod94.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
-// src/wss/OhlcvPayloadSchema.ts
+// src/wss/MarketPayloadSchema.ts
 var import_zod95 = require("zod");
-var OhlcvPayloadSchema = import_zod95.z.object({
-  address: import_zod95.z.string().optional(),
+var MarketPayloadSchema = import_zod95.z.object({
+  interval: import_zod95.z.number().default(30),
   subscriptionId: import_zod95.z.string().optional(),
-  blockchain: import_zod95.z.string().optional(),
-  chainId: import_zod95.z.string().optional(),
-  period: import_zod95.z.string().optional().transform((val) => {
-    if (val) {
-      return normalizePeriod(val);
-    }
-    return "5m";
-  }),
-  asset: import_zod95.z.string().optional(),
-  currentPrice: import_zod95.z.string().optional(),
-  mode: import_zod95.z.enum(["asset", "pair", "pool"]).optional().transform((val) => val === "pool" ? "pair" : val),
+  assets: import_zod95.z.array(import_zod95.z.union([
+    import_zod95.z.object({ name: import_zod95.z.string() }),
+    import_zod95.z.object({ symbol: import_zod95.z.string() }),
+    import_zod95.z.object({
+      address: import_zod95.z.string(),
+      blockchain: import_zod95.z.string()
+    })
+  ])).max(100),
   subscriptionTracking: import_zod95.z.union([import_zod95.z.boolean(), import_zod95.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
-// src/wss/PairsPayloadSchema.ts
+// src/wss/OhlcvPayloadSchema.ts
 var import_zod96 = require("zod");
-var PairsPayloadSchema = import_zod96.z.object({
-  mode: import_zod96.z.enum(["asset", "pair", "pool"]).optional().default("pair").transform((val) => val === "pool" ? "pair" : val),
+var OhlcvPayloadSchema = import_zod96.z.object({
+  address: import_zod96.z.string().optional(),
   subscriptionId: import_zod96.z.string().optional(),
   blockchain: import_zod96.z.string().optional(),
-  factory: import_zod96.z.string().optional(),
-  interval: import_zod96.z.number().default(30),
-  address: import_zod96.z.string().optional(),
+  chainId: import_zod96.z.string().optional(),
+  period: import_zod96.z.string().optional().transform((val) => {
+    if (val) {
+      return normalizePeriod(val);
+    }
+    return "5m";
+  }),
   asset: import_zod96.z.string().optional(),
+  currentPrice: import_zod96.z.string().optional(),
+  mode: import_zod96.z.enum(["asset", "pair", "pool"]).optional().transform((val) => val === "pool" ? "pair" : val),
   subscriptionTracking: import_zod96.z.union([import_zod96.z.boolean(), import_zod96.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
-// src/wss/PositionPayloadSchema.ts
+// src/wss/PairsPayloadSchema.ts
 var import_zod97 = require("zod");
-var PositionPayloadSchema = import_zod97.z.object({
-  wallet: import_zod97.z.string(),
-  token: import_zod97.z.string(),
-  blockchain: import_zod97.z.string(),
+var PairsPayloadSchema = import_zod97.z.object({
+  mode: import_zod97.z.enum(["asset", "pair", "pool"]).optional().default("pair").transform((val) => val === "pool" ? "pair" : val),
   subscriptionId: import_zod97.z.string().optional(),
-  subscriptionTracking: import_zod97.z.union([import_zod97.z.boolean(), import_zod97.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
-  includeFees: import_zod97.z.union([import_zod97.z.boolean(), import_zod97.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
-  useSwapRecipient: import_zod97.z.union([import_zod97.z.boolean(), import_zod97.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+  blockchain: import_zod97.z.string().optional(),
+  factory: import_zod97.z.string().optional(),
+  interval: import_zod97.z.number().default(30),
+  address: import_zod97.z.string().optional(),
+  asset: import_zod97.z.string().optional(),
+  subscriptionTracking: import_zod97.z.union([import_zod97.z.boolean(), import_zod97.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
-var PositionsPayloadSchema = import_zod97.z.object({
-  wallet: import_zod97.z.string(),
-  blockchain: import_zod97.z.string(),
-  subscriptionId: import_zod97.z.string().optional(),
-  subscriptionTracking: import_zod97.z.union([import_zod97.z.boolean(), import_zod97.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
-  includeFees: import_zod97.z.union([import_zod97.z.boolean(), import_zod97.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
-  useSwapRecipient: import_zod97.z.union([import_zod97.z.boolean(), import_zod97.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+// src/wss/PositionPayloadSchema.ts
+var import_zod98 = require("zod");
+var PositionPayloadSchema = import_zod98.z.object({
+  wallet: import_zod98.z.string(),
+  token: import_zod98.z.string(),
+  blockchain: import_zod98.z.string(),
+  subscriptionId: import_zod98.z.string().optional(),
+  subscriptionTracking: import_zod98.z.union([import_zod98.z.boolean(), import_zod98.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  includeFees: import_zod98.z.union([import_zod98.z.boolean(), import_zod98.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  useSwapRecipient: import_zod98.z.union([import_zod98.z.boolean(), import_zod98.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+});
+var PositionsPayloadSchema = import_zod98.z.object({
+  wallet: import_zod98.z.string(),
+  blockchain: import_zod98.z.string(),
+  subscriptionId: import_zod98.z.string().optional(),
+  subscriptionTracking: import_zod98.z.union([import_zod98.z.boolean(), import_zod98.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  includeFees: import_zod98.z.union([import_zod98.z.boolean(), import_zod98.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  useSwapRecipient: import_zod98.z.union([import_zod98.z.boolean(), import_zod98.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 // src/wss/pulse/PausePulsePayloadSchema.ts
-var import_zod98 = require("zod");
-var PausePulsePayloadSchema = import_zod98.z.object({
-  action: import_zod98.z.enum(["pause", "unpause"]),
-  views: import_zod98.z.array(import_zod98.z.string()).min(1)
+var import_zod99 = require("zod");
+var PausePulsePayloadSchema = import_zod99.z.object({
+  action: import_zod99.z.enum(["pause", "unpause"]),
+  views: import_zod99.z.array(import_zod99.z.string()).min(1)
 });
 // src/wss/stream/StreamPayloadSchema.ts
-var import_zod100 = require("zod");
+var import_zod101 = require("zod");
 
 // src/utils/schemas/Filter.ts
-var import_zod99 = require("zod");
-var BaseFilter2 = import_zod99.z.object({
-  eq: import_zod99.z.tuple([import_zod99.z.string(), import_zod99.z.union([import_zod99.z.string(), import_zod99.z.number(), import_zod99.z.boolean(), import_zod99.z.null()])]).optional(),
-  neq: import_zod99.z.tuple([import_zod99.z.string(), import_zod99.z.union([import_zod99.z.string(), import_zod99.z.number(), import_zod99.z.boolean(), import_zod99.z.null()])]).optional(),
-  lt: import_zod99.z.tuple([import_zod99.z.string(), import_zod99.z.coerce.number()]).optional(),
-  lte: import_zod99.z.tuple([import_zod99.z.string(), import_zod99.z.coerce.number()]).optional(),
-  gt: import_zod99.z.tuple([import_zod99.z.string(), import_zod99.z.coerce.number()]).optional(),
-  gte: import_zod99.z.tuple([import_zod99.z.string(), import_zod99.z.coerce.number()]).optional(),
-  in: import_zod99.z.tuple([
-    import_zod99.z.string(),
-    import_zod99.z.union([
-      import_zod99.z.string(),
-      import_zod99.z.number(),
-      import_zod99.z.boolean(),
-      import_zod99.z.null(),
-      import_zod99.z.array(import_zod99.z.union([import_zod99.z.string(), import_zod99.z.number(), import_zod99.z.boolean(), import_zod99.z.null()]))
+var import_zod100 = require("zod");
+var BaseFilter2 = import_zod100.z.object({
+  eq: import_zod100.z.tuple([import_zod100.z.string(), import_zod100.z.union([import_zod100.z.string(), import_zod100.z.number(), import_zod100.z.boolean(), import_zod100.z.null()])]).optional(),
+  neq: import_zod100.z.tuple([import_zod100.z.string(), import_zod100.z.union([import_zod100.z.string(), import_zod100.z.number(), import_zod100.z.boolean(), import_zod100.z.null()])]).optional(),
+  lt: import_zod100.z.tuple([import_zod100.z.string(), import_zod100.z.coerce.number()]).optional(),
+  lte: import_zod100.z.tuple([import_zod100.z.string(), import_zod100.z.coerce.number()]).optional(),
+  gt: import_zod100.z.tuple([import_zod100.z.string(), import_zod100.z.coerce.number()]).optional(),
+  gte: import_zod100.z.tuple([import_zod100.z.string(), import_zod100.z.coerce.number()]).optional(),
+  in: import_zod100.z.tuple([
+    import_zod100.z.string(),
+    import_zod100.z.union([
+      import_zod100.z.string(),
+      import_zod100.z.number(),
+      import_zod100.z.boolean(),
+      import_zod100.z.null(),
+      import_zod100.z.array(import_zod100.z.union([import_zod100.z.string(), import_zod100.z.number(), import_zod100.z.boolean(), import_zod100.z.null()]))
     ])
   ]).optional()
 });
-var Filter2 = BaseFilter2.and(import_zod99.z.union([
-  BaseFilter2.extend({ and: import_zod99.z.undefined(), or: import_zod99.z.undefined() }),
-  BaseFilter2.extend({ and: import_zod99.z.array(import_zod99.z.lazy(() => Filter2)), or: import_zod99.z.undefined() }),
-  BaseFilter2.extend({ and: import_zod99.z.undefined(), or: import_zod99.z.array(import_zod99.z.lazy(() => Filter2)) })
+var Filter2 = BaseFilter2.and(import_zod100.z.union([
+  BaseFilter2.extend({ and: import_zod100.z.undefined(), or: import_zod100.z.undefined() }),
+  BaseFilter2.extend({ and: import_zod100.z.array(import_zod100.z.lazy(() => Filter2)), or: import_zod100.z.undefined() }),
+  BaseFilter2.extend({ and: import_zod100.z.undefined(), or: import_zod100.z.array(import_zod100.z.lazy(() => Filter2)) })
 ]));
 function countOperations2(filter) {
   if (!filter)
@@ -7122,7 +7164,7 @@ var FilterWithLimit2 = Filter2.superRefine((val, ctx) => {
   const max = 1000;
   if (total > max) {
     ctx.addIssue({
-      code: import_zod99.z.ZodIssueCode.custom,
+      code: import_zod100.z.ZodIssueCode.custom,
       message: `Your filter contains ${total} leaf operations, exceeding the maximum of ${max}. Only leaf conditions like "eq", "neq", "lt", "lte", "gt", "gte", "in" are counted; logical operators ("and", "or") are ignored.`
     });
   }
@@ -7130,21 +7172,21 @@ var FilterWithLimit2 = Filter2.superRefine((val, ctx) => {
 var Filter_default = FilterWithLimit2;
 
 // src/wss/stream/StreamPayloadSchema.ts
-var StreamPayloadSchema = import_zod100.z.object({
+var StreamPayloadSchema = import_zod101.z.object({
   filters: Filter_default.optional(),
-  chainIds: import_zod100.z.array(import_zod100.z.string()).nonempty(),
-  name: import_zod100.z.string().optional(),
-  events: import_zod100.z.array(import_zod100.z.enum(["swap", "transfer", "swap-enriched", "block", "order"])).nonempty(),
-  authorization: import_zod100.z.string(),
-  subscriptionId: import_zod100.z.string().optional(),
-  subscriptionTracking: import_zod100.z.string().optional(),
-  debugSubscriptionId: import_zod100.z.string().optional()
-});
-var UnsubscribeStreamPayloadSchema = import_zod100.z.object({
-  type: import_zod100.z.enum(["stream"]).optional(),
-  subscriptionId: import_zod100.z.string().optional(),
-  personalizedId: import_zod100.z.string().optional(),
-  viewName: import_zod100.z.string().optional()
+  chainIds: import_zod101.z.array(import_zod101.z.string()).nonempty(),
+  name: import_zod101.z.string().optional(),
+  events: import_zod101.z.array(import_zod101.z.enum(["swap", "transfer", "swap-enriched", "block", "order"])).nonempty(),
+  authorization: import_zod101.z.string(),
+  subscriptionId: import_zod101.z.string().optional(),
+  subscriptionTracking: import_zod101.z.string().optional(),
+  debugSubscriptionId: import_zod101.z.string().optional()
+});
+var UnsubscribeStreamPayloadSchema = import_zod101.z.object({
+  type: import_zod101.z.enum(["stream"]).optional(),
+  subscriptionId: import_zod101.z.string().optional(),
+  personalizedId: import_zod101.z.string().optional(),
+  viewName: import_zod101.z.string().optional()
 }).transform((data) => {
   if (data.personalizedId && !data.subscriptionId) {
     return {
@@ -7154,24 +7196,24 @@ var UnsubscribeStreamPayloadSchema = import_zod100.z.object({
   }
   return data;
 }).optional();
-var UpdateStreamPayloadSchema = import_zod100.z.object({
-  subscriptionId: import_zod100.z.string(),
-  authorization: import_zod100.z.string(),
-  mode: import_zod100.z.enum(["merge", "replace"]).default("replace"),
+var UpdateStreamPayloadSchema = import_zod101.z.object({
+  subscriptionId: import_zod101.z.string(),
+  authorization: import_zod101.z.string(),
+  mode: import_zod101.z.enum(["merge", "replace"]).default("replace"),
   filters: Filter_default.optional(),
-  chainIds: import_zod100.z.array(import_zod100.z.string()).optional(),
-  events: import_zod100.z.array(import_zod100.z.string()).optional(),
-  subscriptionTracking: import_zod100.z.string().optional()
+  chainIds: import_zod101.z.array(import_zod101.z.string()).optional(),
+  events: import_zod101.z.array(import_zod101.z.string()).optional(),
+  subscriptionTracking: import_zod101.z.string().optional()
 });
 // src/wss/TokenDetailsPayloadSchema.ts
-var import_zod101 = require("zod");
-var TokenDetailsPayloadSchema = import_zod101.z.object({
-  tokens: import_zod101.z.array(import_zod101.z.object({
-    address: import_zod101.z.string(),
-    blockchain: import_zod101.z.string()
+var import_zod102 = require("zod");
+var TokenDetailsPayloadSchema = import_zod102.z.object({
+  tokens: import_zod102.z.array(import_zod102.z.object({
+    address: import_zod102.z.string(),
+    blockchain: import_zod102.z.string()
   })),
-  subscriptionId: import_zod101.z.string().optional(),
-  subscriptionTracking: import_zod101.z.union([import_zod101.z.boolean(), import_zod101.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+  subscriptionId: import_zod102.z.string().optional(),
+  subscriptionTracking: import_zod102.z.union([import_zod102.z.boolean(), import_zod102.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 
-//# debugId=3458D3048CE28F8964756E2164756E21
+//# debugId=C3F75296A2CCEE0E64756E2164756E21