@mobula_labs/types 0.1.8 → 0.1.10

package/dist/cjs/index.cjs

@@ -1328,6 +1328,10 @@ __export(exports_src, {
   TokenSecurityOutput: () => TokenSecurityOutput,
   TokenPriceResponseSchema: () => TokenPriceResponseSchema,
   TokenPriceParamsSchema: () => TokenPriceParamsSchema,
+  TokenPriceHistoryResponseSchema: () => TokenPriceHistoryResponseSchema,
+  TokenPriceHistoryParamsSchema: () => TokenPriceHistoryParamsSchema,
+  TokenPriceHistoryBatchResponseSchema: () => TokenPriceHistoryBatchResponseSchema,
+  TokenPriceHistoryBatchParamsSchema: () => TokenPriceHistoryBatchParamsSchema,
   TokenPriceBatchResponseSchema: () => TokenPriceBatchResponseSchema,
   TokenPriceBatchParamsSchema: () => TokenPriceBatchParamsSchema,
   TokenPositionsResponseSchema: () => TokenPositionsResponseSchema,
@@ -1361,6 +1365,9 @@ __export(exports_src, {
   TRADES_FILTERS_MAX_TIMEFRAME_MS: () => TRADES_FILTERS_MAX_TIMEFRAME_MS,
   TRADES_FILTERS_MAX_LIMIT: () => TRADES_FILTERS_MAX_LIMIT,
   TOKEN_METADATA_KEYS: () => TOKEN_METADATA_KEYS,
+  SystemMetadataV2ResponseSchema: () => SystemMetadataV2ResponseSchema,
+  SystemMetadataV2ParamsSchemaOpenAPI: () => SystemMetadataV2ParamsSchemaOpenAPI,
+  SystemMetadataV2ParamsSchema: () => SystemMetadataV2ParamsSchema,
   SystemMetadataResponseSchema: () => SystemMetadataResponseSchema,
   SwapType: () => SwapType,
   SwapSendSchema: () => SwapSendSchema,
@@ -4914,7 +4921,7 @@ var WalletRawTransactionsResponseSchema = import_zod53.z.object({
 });
 var RawNFTTransactionSchema = import_zod53.z.object({
   combined_id: import_zod53.z.string(),
-  combined_date: import_zod53.z.date().transform((d) => d.toISOString()),
+  combined_date: import_zod53.z.coerce.date().transform((d) => d.toISOString()),
   contract_address: import_zod53.z.string().nullable(),
   from_address: import_zod53.z.string().nullable(),
   to_address: import_zod53.z.string().nullable(),
@@ -4936,7 +4943,7 @@ var UnifiedNFTTransactionSchema = import_zod53.z.object({
   token: import_zod53.z.string(),
   symbol: import_zod53.z.string().optional(),
   tokenId: import_zod53.z.string().nullable(),
-  timestamp: import_zod53.z.date().transform((d) => d.toISOString()),
+  timestamp: import_zod53.z.coerce.date().transform((d) => d.toISOString()),
   block_number: import_zod53.z.number().nullable(),
   txn_fees: import_zod53.z.string().nullable(),
   status: import_zod53.z.boolean()
@@ -5026,7 +5033,7 @@ var WebhookResponseSchema = import_zod54.z.object({
   filters: import_zod54.z.any().nullable().optional(),
   webhookUrl: import_zod54.z.string().url(),
   apiKey: import_zod54.z.string(),
-  createdAt: import_zod54.z.union([import_zod54.z.string(), import_zod54.z.date()]).transform((val) => val instanceof Date ? val.toISOString() : val)
+  createdAt: import_zod54.z.union([import_zod54.z.string(), import_zod54.z.coerce.date()]).transform((val) => val instanceof Date ? val.toISOString() : val)
 });
 var CreateWebhookResponseSchema = WebhookResponseSchema.extend({
   webhookSecret: import_zod54.z.string()
@@ -5518,281 +5525,361 @@ var MarketOHLCVHistoryDataSchema = import_zod61.z.object({
 var MarketOHLCVHistoryBatchResponseSchema = import_zod61.z.object({
   data: import_zod61.z.array(MarketOHLCVHistoryDataSchema)
 });
-// src/v2/perp/PerpBlocksSchema.ts
+// src/v2/metadata/SystemMetadataV2Schema.ts
 var import_zod62 = require("zod");
-var PerpBlocksQueryParamsSchema = import_zod62.z.object({
-  exchange: import_zod62.z.string().optional(),
-  chain_id: import_zod62.z.string().optional(),
-  block_number: import_zod62.z.coerce.number().optional(),
-  batch_number: import_zod62.z.coerce.number().optional(),
-  block_status: import_zod62.z.string().optional(),
-  from_block_time: import_zod62.z.string().optional(),
-  to_block_time: import_zod62.z.string().optional(),
-  page: import_zod62.z.coerce.number().min(1).default(1),
-  limit: import_zod62.z.coerce.number().min(1).max(100).default(25)
-});
-var PerpBlockSchema = import_zod62.z.object({
-  exchange: import_zod62.z.string().nullable(),
-  chain_id: import_zod62.z.string().nullable(),
-  block_number: import_zod62.z.number(),
-  batch_number: import_zod62.z.number(),
-  block_status: import_zod62.z.string().nullable(),
-  block_time: import_zod62.z.string(),
-  total_transactions: import_zod62.z.number(),
-  logs_count: import_zod62.z.number(),
-  trades_count: import_zod62.z.number(),
-  commit_tx_hash: import_zod62.z.string().nullable(),
-  verify_tx_hash: import_zod62.z.string().nullable(),
-  execute_tx_hash: import_zod62.z.string().nullable(),
-  scraped_at: import_zod62.z.string()
-});
-var PerpBlocksResponseSchema = import_zod62.z.object({
-  data: import_zod62.z.array(PerpBlockSchema),
-  pagination: import_zod62.z.object({
-    page: import_zod62.z.number(),
-    totalPages: import_zod62.z.number(),
-    totalItems: import_zod62.z.number(),
-    limit: import_zod62.z.number()
+var booleanPreprocess = import_zod62.z.preprocess((val) => {
+  if (val === "true")
+    return true;
+  if (val === "false")
+    return false;
+  return val;
+}, import_zod62.z.boolean().optional());
+var SystemMetadataV2ParamsSchema = import_zod62.z.object({
+  factories: booleanPreprocess,
+  poolTypes: booleanPreprocess,
+  chains: booleanPreprocess,
+  hasMetadata: booleanPreprocess,
+  status: import_zod62.z.enum(["APPROVED", "WAITING_APPROVAL", "NOT_APPROVED"]).optional(),
+  chainId: import_zod62.z.string().optional(),
+  name: import_zod62.z.string().optional(),
+  indexed: booleanPreprocess,
+  type: import_zod62.z.string().optional()
+});
+var ChainOutputSchema = import_zod62.z.object({
+  id: import_zod62.z.string(),
+  name: import_zod62.z.string(),
+  type: import_zod62.z.string(),
+  chainId: import_zod62.z.union([import_zod62.z.number(), import_zod62.z.string()]),
+  testnet: import_zod62.z.boolean(),
+  indexing: import_zod62.z.boolean(),
+  averageBlockTimeInSeconds: import_zod62.z.number().nullable(),
+  native: import_zod62.z.object({
+    name: import_zod62.z.string(),
+    symbol: import_zod62.z.string(),
+    decimals: import_zod62.z.number(),
+    address: import_zod62.z.string()
+  }),
+  branding: import_zod62.z.object({
+    logo: import_zod62.z.string(),
+    color: import_zod62.z.string()
+  }),
+  blockExplorers: import_zod62.z.object({
+    default: import_zod62.z.object({
+      name: import_zod62.z.string(),
+      url: import_zod62.z.string(),
+      apiUrl: import_zod62.z.string().optional()
+    })
+  }).optional(),
+  integrations: import_zod62.z.object({
+    geckoterminal: import_zod62.z.string().optional(),
+    dexscreener: import_zod62.z.string().optional(),
+    coingecko: import_zod62.z.string().optional()
+  }).optional()
+});
+var FactoryOutputSchema = import_zod62.z.object({
+  chainId: import_zod62.z.string(),
+  address: import_zod62.z.string(),
+  status: import_zod62.z.string(),
+  name: import_zod62.z.string().optional(),
+  metadata: import_zod62.z.object({
+    ui_name: import_zod62.z.string().optional(),
+    logo: import_zod62.z.string().optional(),
+    website: import_zod62.z.string().optional()
+  }).optional()
+});
+var SystemMetadataV2ResponseSchema = import_zod62.z.object({
+  data: import_zod62.z.object({
+    poolTypes: import_zod62.z.array(import_zod62.z.string()).optional(),
+    chains: import_zod62.z.array(ChainOutputSchema).optional(),
+    factories: import_zod62.z.array(FactoryOutputSchema).optional()
   })
 });
-// src/v2/perp/PerpOrderQuotingSchema.ts
+var SystemMetadataV2ParamsSchemaOpenAPI = import_zod62.z.object({
+  factories: import_zod62.z.boolean().optional().describe("Include the list of registered factories."),
+  poolTypes: import_zod62.z.boolean().optional().describe("Include the list of supported pool types."),
+  chains: import_zod62.z.boolean().optional().describe("Include the list of supported chains."),
+  hasMetadata: import_zod62.z.boolean().optional().describe("Filter factories by metadata presence."),
+  status: import_zod62.z.enum(["APPROVED", "WAITING_APPROVAL", "NOT_APPROVED"]).optional().describe("Filter factories by approval status."),
+  chainId: import_zod62.z.string().optional().describe("Filter factories by chain ID."),
+  name: import_zod62.z.string().optional().describe("Case-insensitive partial match on factory name."),
+  indexed: import_zod62.z.boolean().optional().describe("Filter chains by indexing status."),
+  type: import_zod62.z.string().optional().describe('Filter chains by type (e.g. "evm", "solana").')
+});
+// src/v2/perp/PerpBlocksSchema.ts
 var import_zod63 = require("zod");
-var SupportedDexSchema = import_zod63.z.enum(["gains"]);
-var TradeTypeSchema = import_zod63.z.enum(["market", "limit", "stop_limit"]);
-var PerpOrderQuotingParamsSchema = import_zod63.z.object({
-  user: import_zod63.z.string(),
-  baseToken: import_zod63.z.string(),
-  quote: import_zod63.z.string(),
-  leverage: import_zod63.z.coerce.number(),
-  long: import_zod63.z.union([import_zod63.z.boolean(), import_zod63.z.string()]).transform((val) => typeof val === "string" ? val === "true" : val),
-  collateralAmount: import_zod63.z.coerce.number(),
-  openPrice: import_zod63.z.coerce.number().optional(),
-  tp: import_zod63.z.coerce.number().optional(),
-  sl: import_zod63.z.coerce.number().optional(),
+var PerpBlocksQueryParamsSchema = import_zod63.z.object({
+  exchange: import_zod63.z.string().optional(),
+  chain_id: import_zod63.z.string().optional(),
+  block_number: import_zod63.z.coerce.number().optional(),
+  batch_number: import_zod63.z.coerce.number().optional(),
+  block_status: import_zod63.z.string().optional(),
+  from_block_time: import_zod63.z.string().optional(),
+  to_block_time: import_zod63.z.string().optional(),
+  page: import_zod63.z.coerce.number().min(1).default(1),
+  limit: import_zod63.z.coerce.number().min(1).max(100).default(25)
+});
+var PerpBlockSchema = import_zod63.z.object({
+  exchange: import_zod63.z.string().nullable(),
+  chain_id: import_zod63.z.string().nullable(),
+  block_number: import_zod63.z.number(),
+  batch_number: import_zod63.z.number(),
+  block_status: import_zod63.z.string().nullable(),
+  block_time: import_zod63.z.string(),
+  total_transactions: import_zod63.z.number(),
+  logs_count: import_zod63.z.number(),
+  trades_count: import_zod63.z.number(),
+  commit_tx_hash: import_zod63.z.string().nullable(),
+  verify_tx_hash: import_zod63.z.string().nullable(),
+  execute_tx_hash: import_zod63.z.string().nullable(),
+  scraped_at: import_zod63.z.string()
+});
+var PerpBlocksResponseSchema = import_zod63.z.object({
+  data: import_zod63.z.array(PerpBlockSchema),
+  pagination: import_zod63.z.object({
+    page: import_zod63.z.number(),
+    totalPages: import_zod63.z.number(),
+    totalItems: import_zod63.z.number(),
+    limit: import_zod63.z.number()
+  })
+});
+// src/v2/perp/PerpOrderQuotingSchema.ts
+var import_zod64 = require("zod");
+var SupportedDexSchema = import_zod64.z.enum(["gains"]);
+var TradeTypeSchema = import_zod64.z.enum(["market", "limit", "stop_limit"]);
+var PerpOrderQuotingParamsSchema = import_zod64.z.object({
+  user: import_zod64.z.string(),
+  baseToken: import_zod64.z.string(),
+  quote: import_zod64.z.string(),
+  leverage: import_zod64.z.coerce.number(),
+  long: import_zod64.z.union([import_zod64.z.boolean(), import_zod64.z.string()]).transform((val) => typeof val === "string" ? val === "true" : val),
+  collateralAmount: import_zod64.z.coerce.number(),
+  openPrice: import_zod64.z.coerce.number().optional(),
+  tp: import_zod64.z.coerce.number().optional(),
+  sl: import_zod64.z.coerce.number().optional(),
   tradeType: TradeTypeSchema.optional().default("market"),
-  amountRaw: import_zod63.z.coerce.number().optional(),
-  maxSlippageP: import_zod63.z.coerce.number().optional(),
-  chainId: import_zod63.z.string().optional(),
+  amountRaw: import_zod64.z.coerce.number().optional(),
+  maxSlippageP: import_zod64.z.coerce.number().optional(),
+  chainId: import_zod64.z.string().optional(),
   dex: SupportedDexSchema.optional(),
-  referrer: import_zod63.z.string().optional()
+  referrer: import_zod64.z.string().optional()
 });
 // src/v2/swap/SwapQuotingBatchOutput.ts
-var import_zod65 = require("zod");
+var import_zod66 = require("zod");
 
 // src/v2/swap/SwapQuotingOutput.ts
 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({
-  serialized: import_zod64.z.string(),
-  variant: import_zod64.z.enum(["legacy", "versioned"])
-});
-var EVMTransactionSchema = import_zod64.z.object({
-  to: import_zod64.z.string(),
-  from: import_zod64.z.string(),
-  data: import_zod64.z.string(),
-  value: import_zod64.z.string(),
-  gasLimit: import_zod64.z.string().optional(),
-  gasPrice: import_zod64.z.string().optional(),
-  maxFeePerGas: import_zod64.z.string().optional(),
-  maxPriorityFeePerGas: import_zod64.z.string().optional(),
-  nonce: import_zod64.z.number().optional(),
-  chainId: import_zod64.z.number()
-});
-var TokenInfoSchema = import_zod64.z.object({
-  address: import_zod64.z.string(),
-  name: import_zod64.z.string().optional(),
-  symbol: import_zod64.z.string().optional(),
-  decimals: import_zod64.z.number(),
-  logo: import_zod64.z.string().nullable().optional()
-});
-var RouteHopSchema = import_zod64.z.object({
-  poolAddress: import_zod64.z.string(),
+var import_zod65 = require("zod");
+import_zod_to_openapi2.extendZodWithOpenApi(import_zod65.z);
+var SolanaTransactionSchema = import_zod65.z.object({
+  serialized: import_zod65.z.string(),
+  variant: import_zod65.z.enum(["legacy", "versioned"])
+});
+var EVMTransactionSchema = import_zod65.z.object({
+  to: import_zod65.z.string(),
+  from: import_zod65.z.string(),
+  data: import_zod65.z.string(),
+  value: import_zod65.z.string(),
+  gasLimit: import_zod65.z.string().optional(),
+  gasPrice: import_zod65.z.string().optional(),
+  maxFeePerGas: import_zod65.z.string().optional(),
+  maxPriorityFeePerGas: import_zod65.z.string().optional(),
+  nonce: import_zod65.z.number().optional(),
+  chainId: import_zod65.z.number()
+});
+var TokenInfoSchema = import_zod65.z.object({
+  address: import_zod65.z.string(),
+  name: import_zod65.z.string().optional(),
+  symbol: import_zod65.z.string().optional(),
+  decimals: import_zod65.z.number(),
+  logo: import_zod65.z.string().nullable().optional()
+});
+var RouteHopSchema = import_zod65.z.object({
+  poolAddress: import_zod65.z.string(),
   tokenIn: TokenInfoSchema,
   tokenOut: TokenInfoSchema,
-  amountInTokens: import_zod64.z.string(),
-  amountOutTokens: import_zod64.z.string(),
-  exchange: import_zod64.z.string().optional(),
-  poolType: import_zod64.z.string().optional(),
-  feePercentage: import_zod64.z.number().optional(),
-  feeBps: import_zod64.z.number().optional()
-});
-var RouteDetailsSchema = import_zod64.z.object({
-  hops: import_zod64.z.array(RouteHopSchema),
-  totalFeePercentage: import_zod64.z.number().optional(),
-  aggregator: import_zod64.z.string().optional()
-});
-var IntegrationFeeSchema = import_zod64.z.object({
-  amount: import_zod64.z.string(),
-  percentage: import_zod64.z.number(),
-  wallet: import_zod64.z.string(),
-  deductedFrom: import_zod64.z.enum(["input", "output"])
-});
-var BaseDataSchema = import_zod64.z.object({
-  amountOutTokens: import_zod64.z.string().optional(),
-  slippagePercentage: import_zod64.z.number().optional(),
-  amountInUSD: import_zod64.z.number().optional(),
-  amountOutUSD: import_zod64.z.number().optional(),
-  marketImpactPercentage: import_zod64.z.number().optional(),
-  poolFeesPercentage: import_zod64.z.number().optional(),
+  amountInTokens: import_zod65.z.string(),
+  amountOutTokens: import_zod65.z.string(),
+  exchange: import_zod65.z.string().optional(),
+  poolType: import_zod65.z.string().optional(),
+  feePercentage: import_zod65.z.number().optional(),
+  feeBps: import_zod65.z.number().optional()
+});
+var RouteDetailsSchema = import_zod65.z.object({
+  hops: import_zod65.z.array(RouteHopSchema),
+  totalFeePercentage: import_zod65.z.number().optional(),
+  aggregator: import_zod65.z.string().optional()
+});
+var IntegrationFeeSchema = import_zod65.z.object({
+  amount: import_zod65.z.string(),
+  percentage: import_zod65.z.number(),
+  wallet: import_zod65.z.string(),
+  deductedFrom: import_zod65.z.enum(["input", "output"])
+});
+var BaseDataSchema = import_zod65.z.object({
+  amountOutTokens: import_zod65.z.string().optional(),
+  slippagePercentage: import_zod65.z.number().optional(),
+  amountInUSD: import_zod65.z.number().optional(),
+  amountOutUSD: import_zod65.z.number().optional(),
+  marketImpactPercentage: import_zod65.z.number().optional(),
+  poolFeesPercentage: import_zod65.z.number().optional(),
   tokenIn: TokenInfoSchema.optional(),
   tokenOut: TokenInfoSchema.optional(),
-  requestId: import_zod64.z.string(),
-  details: import_zod64.z.object({
+  requestId: import_zod65.z.string(),
+  details: import_zod65.z.object({
     route: RouteDetailsSchema.optional(),
-    aggregator: import_zod64.z.string().optional(),
-    raw: import_zod64.z.record(import_zod64.z.unknown()).optional()
+    aggregator: import_zod65.z.string().optional(),
+    raw: import_zod65.z.record(import_zod65.z.unknown()).optional()
   }).optional(),
   fee: IntegrationFeeSchema.optional()
 });
 var DataWithSolanaSchema = BaseDataSchema.extend({
-  solana: import_zod64.z.object({
+  solana: import_zod65.z.object({
     transaction: SolanaTransactionSchema,
-    lastValidBlockHeight: import_zod64.z.number()
+    lastValidBlockHeight: import_zod65.z.number()
   }),
-  evm: import_zod64.z.null().optional()
+  evm: import_zod65.z.null().optional()
 });
 var DataWithEVMSchema = BaseDataSchema.extend({
-  evm: import_zod64.z.object({
+  evm: import_zod65.z.object({
     transaction: EVMTransactionSchema
   }),
-  solana: import_zod64.z.null().optional()
+  solana: import_zod65.z.null().optional()
 });
 var DataWithErrorSchema = BaseDataSchema.extend({
-  solana: import_zod64.z.null().optional(),
-  evm: import_zod64.z.null().optional()
+  solana: import_zod65.z.null().optional(),
+  evm: import_zod65.z.null().optional()
 });
-var SwapQuotingDataSchema = import_zod64.z.union([DataWithSolanaSchema, DataWithEVMSchema, DataWithErrorSchema]);
-var SwapQuotingOutputSchema = import_zod64.z.object({
+var SwapQuotingDataSchema = import_zod65.z.union([DataWithSolanaSchema, DataWithEVMSchema, DataWithErrorSchema]);
+var SwapQuotingOutputSchema = import_zod65.z.object({
   data: SwapQuotingDataSchema,
-  error: import_zod64.z.string().optional()
+  error: import_zod65.z.string().optional()
 });
 
 // src/v2/swap/SwapQuotingBatchOutput.ts
-var SwapQuotingBatchResultSchema = import_zod65.z.object({
+var SwapQuotingBatchResultSchema = import_zod66.z.object({
   data: SwapQuotingDataSchema,
-  error: import_zod65.z.string().optional(),
-  index: import_zod65.z.number()
+  error: import_zod66.z.string().optional(),
+  index: import_zod66.z.number()
 });
-var SwapQuotingBatchOutputSchema = import_zod65.z.object({
-  results: import_zod65.z.array(SwapQuotingBatchResultSchema),
-  totalRequests: import_zod65.z.number(),
-  successCount: import_zod65.z.number(),
-  errorCount: import_zod65.z.number()
+var SwapQuotingBatchOutputSchema = import_zod66.z.object({
+  results: import_zod66.z.array(SwapQuotingBatchResultSchema),
+  totalRequests: import_zod66.z.number(),
+  successCount: import_zod66.z.number(),
+  errorCount: import_zod66.z.number()
 });
 // src/v2/swap/SwapQuotingBatchSchema.ts
-var import_zod66 = require("zod");
-var SwapQuotingBatchItemSchema = import_zod66.z.object({
-  chainId: import_zod66.z.string(),
-  tokenIn: import_zod66.z.string().min(1, "tokenIn is required"),
-  tokenOut: import_zod66.z.string().min(1, "tokenOut is required"),
-  amount: import_zod66.z.number().positive("Amount must be a positive number").optional(),
-  amountRaw: import_zod66.z.string().regex(/^\d+$/, "amountRaw must be a positive integer string").refine((val) => BigInt(val) > 0n, "amountRaw must be positive").transform((val) => BigInt(val)).optional(),
-  slippage: import_zod66.z.number().min(0).max(100, "Slippage must be between 0 and 100").default(1),
-  walletAddress: import_zod66.z.string().min(1, "walletAddress is required"),
-  excludedProtocols: import_zod66.z.array(import_zod66.z.string()).optional(),
-  onlyProtocols: import_zod66.z.array(import_zod66.z.string()).optional(),
-  poolAddress: import_zod66.z.string().optional(),
-  onlyRouters: import_zod66.z.array(import_zod66.z.enum(["jupiter", "kyberswap", "lifi"])).optional().transform((val) => val?.length ? val : undefined),
-  priorityFee: import_zod66.z.union([
-    import_zod66.z.literal("auto"),
-    import_zod66.z.number().positive(),
-    import_zod66.z.object({
-      preset: import_zod66.z.enum(["low", "medium", "high", "veryHigh"])
+var import_zod67 = require("zod");
+var SwapQuotingBatchItemSchema = import_zod67.z.object({
+  chainId: import_zod67.z.string(),
+  tokenIn: import_zod67.z.string().min(1, "tokenIn is required"),
+  tokenOut: import_zod67.z.string().min(1, "tokenOut is required"),
+  amount: import_zod67.z.number().positive("Amount must be a positive number").optional(),
+  amountRaw: import_zod67.z.string().regex(/^\d+$/, "amountRaw must be a positive integer string").refine((val) => BigInt(val) > 0n, "amountRaw must be positive").transform((val) => BigInt(val)).optional(),
+  slippage: import_zod67.z.number().min(0).max(100, "Slippage must be between 0 and 100").default(1),
+  walletAddress: import_zod67.z.string().min(1, "walletAddress is required"),
+  excludedProtocols: import_zod67.z.array(import_zod67.z.string()).optional(),
+  onlyProtocols: import_zod67.z.array(import_zod67.z.string()).optional(),
+  poolAddress: import_zod67.z.string().optional(),
+  onlyRouters: import_zod67.z.array(import_zod67.z.enum(["jupiter", "kyberswap", "lifi"])).optional().transform((val) => val?.length ? val : undefined),
+  priorityFee: import_zod67.z.union([
+    import_zod67.z.literal("auto"),
+    import_zod67.z.number().positive(),
+    import_zod67.z.object({
+      preset: import_zod67.z.enum(["low", "medium", "high", "veryHigh"])
     })
   ]).optional(),
-  computeUnitLimit: import_zod66.z.union([import_zod66.z.literal(true), import_zod66.z.number().positive()]).optional(),
-  jitoTipLamports: import_zod66.z.number().positive().optional(),
-  feePercentage: import_zod66.z.number().min(0.01).max(99).optional(),
-  feeWallet: import_zod66.z.string().optional(),
-  payerAddress: import_zod66.z.string().optional()
+  computeUnitLimit: import_zod67.z.union([import_zod67.z.literal(true), import_zod67.z.number().positive()]).optional(),
+  jitoTipLamports: import_zod67.z.number().positive().optional(),
+  feePercentage: import_zod67.z.number().min(0.01).max(99).optional(),
+  feeWallet: import_zod67.z.string().optional(),
+  payerAddress: import_zod67.z.string().optional()
 }).refine((data) => data.amount !== undefined !== (data.amountRaw !== undefined), {
   message: "Either amount or amountRaw must be provided (but not both)",
   path: ["amount"]
 });
-var SwapQuotingBatchBodySchema = import_zod66.z.object({
-  requests: import_zod66.z.array(SwapQuotingBatchItemSchema).min(1, "At least one request is required").max(30, "Maximum 30 requests allowed per batch")
+var SwapQuotingBatchBodySchema = import_zod67.z.object({
+  requests: import_zod67.z.array(SwapQuotingBatchItemSchema).min(1, "At least one request is required").max(30, "Maximum 30 requests allowed per batch")
 });
 // src/v2/swap/SwapQuotingInstructionsOutput.ts
-var import_zod67 = require("zod");
-var SolanaInstructionSchema = import_zod67.z.object({
-  programId: import_zod67.z.string(),
-  accounts: import_zod67.z.array(import_zod67.z.object({
-    pubkey: import_zod67.z.string(),
-    isSigner: import_zod67.z.boolean(),
-    isWritable: import_zod67.z.boolean()
+var import_zod68 = require("zod");
+var SolanaInstructionSchema = import_zod68.z.object({
+  programId: import_zod68.z.string(),
+  accounts: import_zod68.z.array(import_zod68.z.object({
+    pubkey: import_zod68.z.string(),
+    isSigner: import_zod68.z.boolean(),
+    isWritable: import_zod68.z.boolean()
   })),
-  data: import_zod67.z.string()
-});
-var SolanaInstructionsSchema = import_zod67.z.object({
-  computeBudgetInstructions: import_zod67.z.array(SolanaInstructionSchema).optional(),
-  setupInstructions: import_zod67.z.array(SolanaInstructionSchema).optional(),
-  swapInstructions: import_zod67.z.array(SolanaInstructionSchema),
-  cleanupInstructions: import_zod67.z.array(SolanaInstructionSchema).optional(),
-  addressLookupTableAddresses: import_zod67.z.array(import_zod67.z.string()).optional()
-});
-var TokenInfoSchema2 = import_zod67.z.object({
-  address: import_zod67.z.string(),
-  name: import_zod67.z.string().optional(),
-  symbol: import_zod67.z.string().optional(),
-  decimals: import_zod67.z.number(),
-  logo: import_zod67.z.string().nullable().optional()
-});
-var RouteHopSchema2 = import_zod67.z.object({
-  poolAddress: import_zod67.z.string(),
+  data: import_zod68.z.string()
+});
+var SolanaInstructionsSchema = import_zod68.z.object({
+  computeBudgetInstructions: import_zod68.z.array(SolanaInstructionSchema).optional(),
+  setupInstructions: import_zod68.z.array(SolanaInstructionSchema).optional(),
+  swapInstructions: import_zod68.z.array(SolanaInstructionSchema),
+  cleanupInstructions: import_zod68.z.array(SolanaInstructionSchema).optional(),
+  addressLookupTableAddresses: import_zod68.z.array(import_zod68.z.string()).optional()
+});
+var TokenInfoSchema2 = import_zod68.z.object({
+  address: import_zod68.z.string(),
+  name: import_zod68.z.string().optional(),
+  symbol: import_zod68.z.string().optional(),
+  decimals: import_zod68.z.number(),
+  logo: import_zod68.z.string().nullable().optional()
+});
+var RouteHopSchema2 = import_zod68.z.object({
+  poolAddress: import_zod68.z.string(),
   tokenIn: TokenInfoSchema2,
   tokenOut: TokenInfoSchema2,
-  amountInTokens: import_zod67.z.string(),
-  amountOutTokens: import_zod67.z.string(),
-  exchange: import_zod67.z.string().optional(),
-  poolType: import_zod67.z.string().optional(),
-  feePercentage: import_zod67.z.number().optional(),
-  feeBps: import_zod67.z.number().optional()
-});
-var RouteDetailsSchema2 = import_zod67.z.object({
-  hops: import_zod67.z.array(RouteHopSchema2),
-  totalFeePercentage: import_zod67.z.number().optional(),
-  aggregator: import_zod67.z.string().optional()
-});
-var IntegrationFeeSchema2 = import_zod67.z.object({
-  amount: import_zod67.z.string(),
-  percentage: import_zod67.z.number(),
-  wallet: import_zod67.z.string(),
-  deductedFrom: import_zod67.z.enum(["input", "output"])
-});
-var SwapQuotingInstructionsDataSchema = import_zod67.z.object({
-  amountOutTokens: import_zod67.z.string().optional(),
-  slippagePercentage: import_zod67.z.number().optional(),
-  amountInUSD: import_zod67.z.number().optional(),
-  amountOutUSD: import_zod67.z.number().optional(),
-  marketImpactPercentage: import_zod67.z.number().optional(),
-  poolFeesPercentage: import_zod67.z.number().optional(),
+  amountInTokens: import_zod68.z.string(),
+  amountOutTokens: import_zod68.z.string(),
+  exchange: import_zod68.z.string().optional(),
+  poolType: import_zod68.z.string().optional(),
+  feePercentage: import_zod68.z.number().optional(),
+  feeBps: import_zod68.z.number().optional()
+});
+var RouteDetailsSchema2 = import_zod68.z.object({
+  hops: import_zod68.z.array(RouteHopSchema2),
+  totalFeePercentage: import_zod68.z.number().optional(),
+  aggregator: import_zod68.z.string().optional()
+});
+var IntegrationFeeSchema2 = import_zod68.z.object({
+  amount: import_zod68.z.string(),
+  percentage: import_zod68.z.number(),
+  wallet: import_zod68.z.string(),
+  deductedFrom: import_zod68.z.enum(["input", "output"])
+});
+var SwapQuotingInstructionsDataSchema = import_zod68.z.object({
+  amountOutTokens: import_zod68.z.string().optional(),
+  slippagePercentage: import_zod68.z.number().optional(),
+  amountInUSD: import_zod68.z.number().optional(),
+  amountOutUSD: import_zod68.z.number().optional(),
+  marketImpactPercentage: import_zod68.z.number().optional(),
+  poolFeesPercentage: import_zod68.z.number().optional(),
   tokenIn: TokenInfoSchema2.optional(),
   tokenOut: TokenInfoSchema2.optional(),
-  requestId: import_zod67.z.string(),
-  details: import_zod67.z.object({
+  requestId: import_zod68.z.string(),
+  details: import_zod68.z.object({
     route: RouteDetailsSchema2.optional(),
-    aggregator: import_zod67.z.string().optional(),
-    raw: import_zod67.z.record(import_zod67.z.unknown()).optional()
+    aggregator: import_zod68.z.string().optional(),
+    raw: import_zod68.z.record(import_zod68.z.unknown()).optional()
   }).optional(),
-  solana: import_zod67.z.object({
+  solana: import_zod68.z.object({
     instructions: SolanaInstructionsSchema,
-    lastValidBlockHeight: import_zod67.z.number(),
-    recentBlockhash: import_zod67.z.string()
+    lastValidBlockHeight: import_zod68.z.number(),
+    recentBlockhash: import_zod68.z.string()
   }),
   fee: IntegrationFeeSchema2.optional()
 });
-var SwapQuotingInstructionsOutputSchema = import_zod67.z.object({
+var SwapQuotingInstructionsOutputSchema = import_zod68.z.object({
   data: SwapQuotingInstructionsDataSchema,
-  error: import_zod67.z.string().optional()
+  error: import_zod68.z.string().optional()
 });
 // src/v2/swap/SwapQuotingSchema.ts
-var import_zod68 = require("zod");
-var SwapQuotingQuerySchema = import_zod68.z.object({
-  chainId: import_zod68.z.string(),
-  tokenIn: import_zod68.z.string().min(1, "tokenIn is required"),
-  tokenOut: import_zod68.z.string().min(1, "tokenOut is required"),
-  amount: import_zod68.z.string().optional().transform((val) => {
+var import_zod69 = require("zod");
+var SwapQuotingQuerySchema = import_zod69.z.object({
+  chainId: import_zod69.z.string(),
+  tokenIn: import_zod69.z.string().min(1, "tokenIn is required"),
+  tokenOut: import_zod69.z.string().min(1, "tokenOut is required"),
+  amount: import_zod69.z.string().optional().transform((val) => {
     if (!val)
       return;
     const parsed = Number.parseFloat(val);
@@ -5801,7 +5888,7 @@ var SwapQuotingQuerySchema = import_zod68.z.object({
     }
     return parsed;
   }),
-  amountRaw: import_zod68.z.string().optional().transform((val) => {
+  amountRaw: import_zod69.z.string().optional().transform((val) => {
     if (!val)
       return;
     if (!/^\d+$/.test(val)) {
@@ -5813,26 +5900,26 @@ var SwapQuotingQuerySchema = import_zod68.z.object({
     }
     return parsed;
   }),
-  slippage: import_zod68.z.string().optional().default("1").transform((val) => {
+  slippage: import_zod69.z.string().optional().default("1").transform((val) => {
     const parsed = Number.parseFloat(val);
     if (Number.isNaN(parsed) || parsed < 0 || parsed > 100) {
       throw new Error("Slippage must be between 0 and 100");
     }
     return parsed;
   }),
-  walletAddress: import_zod68.z.string().min(1, "walletAddress is required"),
-  excludedProtocols: import_zod68.z.string().optional().transform((val) => {
+  walletAddress: import_zod69.z.string().min(1, "walletAddress is required"),
+  excludedProtocols: import_zod69.z.string().optional().transform((val) => {
     if (!val)
       return;
     return val.split(",").map((f) => f.trim()).filter((f) => f.length > 0);
   }),
-  onlyProtocols: import_zod68.z.string().optional().transform((val) => {
+  onlyProtocols: import_zod69.z.string().optional().transform((val) => {
     if (!val)
       return;
     return val.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
   }),
-  poolAddress: import_zod68.z.string().optional(),
-  onlyRouters: import_zod68.z.string().optional().transform((val) => {
+  poolAddress: import_zod69.z.string().optional(),
+  onlyRouters: import_zod69.z.string().optional().transform((val) => {
     if (!val)
       return;
     const supportedRouters = ["jupiter", "kyberswap", "lifi"];
@@ -5846,7 +5933,7 @@ var SwapQuotingQuerySchema = import_zod68.z.object({
       return;
     return routers;
   }),
-  priorityFee: import_zod68.z.string().optional().transform((val) => {
+  priorityFee: import_zod69.z.string().optional().transform((val) => {
     if (!val)
       return;
     if (val === "auto")
@@ -5861,7 +5948,7 @@ var SwapQuotingQuerySchema = import_zod68.z.object({
     }
     throw new Error(`Invalid priorityFee "${val}". Must be 'auto', a preset (low, medium, high, veryHigh), or a positive number`);
   }),
-  computeUnitLimit: import_zod68.z.string().optional().transform((val) => {
+  computeUnitLimit: import_zod69.z.string().optional().transform((val) => {
     if (!val)
       return;
     if (val === "true")
@@ -5872,7 +5959,7 @@ var SwapQuotingQuerySchema = import_zod68.z.object({
     }
     throw new Error(`Invalid computeUnitLimit "${val}". Must be 'true' or a positive number`);
   }),
-  jitoTipLamports: import_zod68.z.string().optional().transform((val) => {
+  jitoTipLamports: import_zod69.z.string().optional().transform((val) => {
     if (!val)
       return;
     const numValue = Number.parseInt(val, 10);
@@ -5881,7 +5968,7 @@ var SwapQuotingQuerySchema = import_zod68.z.object({
     }
     throw new Error(`Invalid jitoTipLamports "${val}". Must be a positive number`);
   }),
-  feePercentage: import_zod68.z.string().optional().transform((val) => {
+  feePercentage: import_zod69.z.string().optional().transform((val) => {
     if (!val)
       return;
     const numValue = Number.parseFloat(val);
@@ -5890,8 +5977,8 @@ var SwapQuotingQuerySchema = import_zod68.z.object({
     }
     return numValue;
   }),
-  feeWallet: import_zod68.z.string().optional(),
-  payerAddress: import_zod68.z.string().optional()
+  feeWallet: import_zod69.z.string().optional(),
+  payerAddress: import_zod69.z.string().optional()
 }).refine((data) => {
   const hasAmount = data.amount !== undefined;
   const hasAmountRaw = data.amountRaw !== undefined;
@@ -5901,20 +5988,20 @@ var SwapQuotingQuerySchema = import_zod68.z.object({
   path: ["amount"]
 });
 // src/v2/swap/SwapSendOutput.ts
-var import_zod69 = require("zod");
-var SwapSendResponseSchema = import_zod69.z.object({
-  data: import_zod69.z.object({
-    success: import_zod69.z.boolean(),
-    transactionHash: import_zod69.z.string().optional(),
-    requestId: import_zod69.z.string()
+var import_zod70 = require("zod");
+var SwapSendResponseSchema = import_zod70.z.object({
+  data: import_zod70.z.object({
+    success: import_zod70.z.boolean(),
+    transactionHash: import_zod70.z.string().optional(),
+    requestId: import_zod70.z.string()
   }),
-  error: import_zod69.z.string().optional()
+  error: import_zod70.z.string().optional()
 });
 // src/v2/swap/SwapSendSchema.ts
-var import_zod70 = require("zod");
-var SwapSendSchema = import_zod70.z.object({
-  chainId: import_zod70.z.string(),
-  signedTransaction: import_zod70.z.string().min(1, "signedTransaction is required").transform((val) => {
+var import_zod71 = require("zod");
+var SwapSendSchema = import_zod71.z.object({
+  chainId: import_zod71.z.string(),
+  signedTransaction: import_zod71.z.string().min(1, "signedTransaction is required").transform((val) => {
     try {
       return Buffer.from(val, "base64");
     } catch {
@@ -5923,191 +6010,191 @@ var SwapSendSchema = import_zod70.z.object({
   })
 });
 // src/v2/token/TokenAthSchema.ts
-var import_zod71 = require("zod");
-var TokenAthItemParams = import_zod71.z.object({
-  blockchain: import_zod71.z.string().optional(),
-  address: import_zod71.z.string().optional(),
+var import_zod72 = require("zod");
+var TokenAthItemParams = import_zod72.z.object({
+  blockchain: import_zod72.z.string().optional(),
+  address: import_zod72.z.string().optional(),
   currencies: CurrenciesParamSchema,
-  instanceTracking: import_zod71.z.preprocess((val) => {
+  instanceTracking: import_zod72.z.preprocess((val) => {
     if (val === "true")
       return true;
     if (val === "false")
       return false;
     return val;
-  }, import_zod71.z.boolean().optional())
+  }, import_zod72.z.boolean().optional())
 });
 var TokenAthParamsSchema = TokenAthItemParams;
-var TokenAthBatchParamsSchema = import_zod71.z.union([
-  import_zod71.z.array(TokenAthItemParams),
-  import_zod71.z.object({
-    items: import_zod71.z.array(TokenAthItemParams),
-    instanceTracking: import_zod71.z.preprocess((val) => {
+var TokenAthBatchParamsSchema = import_zod72.z.union([
+  import_zod72.z.array(TokenAthItemParams),
+  import_zod72.z.object({
+    items: import_zod72.z.array(TokenAthItemParams),
+    instanceTracking: import_zod72.z.preprocess((val) => {
       if (val === "true")
         return true;
       if (val === "false")
         return false;
       return val;
-    }, import_zod71.z.boolean().optional())
+    }, import_zod72.z.boolean().optional())
   })
 ]);
-var TokenAthOutput = import_zod71.z.object({
-  address: import_zod71.z.string(),
-  chainId: import_zod71.z.string(),
-  symbol: import_zod71.z.string().nullable(),
-  name: import_zod71.z.string().nullable(),
-  athUSD: import_zod71.z.coerce.number().optional(),
-  atlUSD: import_zod71.z.coerce.number().optional(),
-  athDate: import_zod71.z.coerce.date().optional(),
-  atlDate: import_zod71.z.coerce.date().optional(),
-  priceUSD: import_zod71.z.coerce.number().default(0)
-});
-var TokenAthResponseSchema = import_zod71.z.object({
+var TokenAthOutput = import_zod72.z.object({
+  address: import_zod72.z.string(),
+  chainId: import_zod72.z.string(),
+  symbol: import_zod72.z.string().nullable(),
+  name: import_zod72.z.string().nullable(),
+  athUSD: import_zod72.z.coerce.number().optional(),
+  atlUSD: import_zod72.z.coerce.number().optional(),
+  athDate: import_zod72.z.coerce.date().optional(),
+  atlDate: import_zod72.z.coerce.date().optional(),
+  priceUSD: import_zod72.z.coerce.number().default(0)
+});
+var TokenAthResponseSchema = import_zod72.z.object({
   data: TokenAthOutput,
-  hostname: import_zod71.z.string().optional()
+  hostname: import_zod72.z.string().optional()
 });
-var TokenAthBatchResponseSchema = import_zod71.z.object({
-  payload: import_zod71.z.array(TokenAthOutput.or(import_zod71.z.object({ error: import_zod71.z.string().optional() })).nullable()),
-  hostname: import_zod71.z.string().optional()
+var TokenAthBatchResponseSchema = import_zod72.z.object({
+  payload: import_zod72.z.array(TokenAthOutput.or(import_zod72.z.object({ error: import_zod72.z.string().optional() })).nullable()),
+  hostname: import_zod72.z.string().optional()
 });
 // src/v2/token/TokenDetailsSchema.ts
-var import_zod72 = require("zod");
-var TokenDetailsItemParams = import_zod72.z.object({
-  blockchain: import_zod72.z.string().optional(),
-  address: import_zod72.z.string().optional(),
+var import_zod73 = require("zod");
+var TokenDetailsItemParams = import_zod73.z.object({
+  blockchain: import_zod73.z.string().optional(),
+  address: import_zod73.z.string().optional(),
   currencies: CurrenciesParamSchema,
-  instanceTracking: import_zod72.z.preprocess((val) => {
+  instanceTracking: import_zod73.z.preprocess((val) => {
     if (val === "true")
       return true;
     if (val === "false")
       return false;
     return val;
-  }, import_zod72.z.boolean().optional())
+  }, import_zod73.z.boolean().optional())
 });
 var TokenDetailsParamsSchema = TokenDetailsItemParams;
-var TokenDetailsBatchParamsSchema = import_zod72.z.union([
-  import_zod72.z.array(TokenDetailsItemParams),
-  import_zod72.z.object({
-    items: import_zod72.z.array(TokenDetailsItemParams),
-    instanceTracking: import_zod72.z.preprocess((val) => {
+var TokenDetailsBatchParamsSchema = import_zod73.z.union([
+  import_zod73.z.array(TokenDetailsItemParams),
+  import_zod73.z.object({
+    items: import_zod73.z.array(TokenDetailsItemParams),
+    instanceTracking: import_zod73.z.preprocess((val) => {
       if (val === "true")
         return true;
       if (val === "false")
         return false;
       return val;
-    }, import_zod72.z.boolean().optional())
+    }, import_zod73.z.boolean().optional())
   })
 ]);
-var TokenDetailsResponseSchema = import_zod72.z.object({
+var TokenDetailsResponseSchema = import_zod73.z.object({
   data: TokenDetailsOutput,
-  hostname: import_zod72.z.string().optional()
+  hostname: import_zod73.z.string().optional()
 });
-var TokenDetailsBatchResponseSchema = import_zod72.z.object({
-  payload: import_zod72.z.array(TokenDetailsOutput.or(import_zod72.z.object({ error: import_zod72.z.string().optional() })).nullable()),
-  hostname: import_zod72.z.string().optional()
+var TokenDetailsBatchResponseSchema = import_zod73.z.object({
+  payload: import_zod73.z.array(TokenDetailsOutput.or(import_zod73.z.object({ error: import_zod73.z.string().optional() })).nullable()),
+  hostname: import_zod73.z.string().optional()
 });
 // src/v2/token/TokenKlineBsPointSchema.ts
-var import_zod73 = require("zod");
-var TokenKlineBsPointParamsSchema = import_zod73.z.object({
-  blockchain: import_zod73.z.string(),
-  address: import_zod73.z.string(),
-  bar: import_zod73.z.string().transform((val) => normalizePeriod(val ?? "5m", "5m")),
+var import_zod74 = require("zod");
+var TokenKlineBsPointParamsSchema = import_zod74.z.object({
+  blockchain: import_zod74.z.string(),
+  address: import_zod74.z.string(),
+  bar: import_zod74.z.string().transform((val) => normalizePeriod(val ?? "5m", "5m")),
   fromDate: DateQuery_default.transform((val) => val ?? undefined),
   toDate: DateQuery_default.transform((val) => val ?? undefined),
   transactionSenderAddresses: stringOrArray.default([]),
   labels: stringOrArray.optional().transform((val) => val?.map((label) => String(label).trim()).filter((label) => label.length > 0) ?? [])
 });
-var TokenKlineBsBubblePoint = import_zod73.z.object({
-  volumeBuyToken: import_zod73.z.string(),
-  buys: import_zod73.z.string(),
-  avgBuyPriceUSD: import_zod73.z.string(),
-  volumeBuy: import_zod73.z.string(),
-  volumeSellToken: import_zod73.z.string(),
-  sells: import_zod73.z.string(),
-  avgSellPriceUSD: import_zod73.z.string(),
-  volumeSell: import_zod73.z.string(),
-  fromAddress: import_zod73.z.string(),
-  fromAddressTag: import_zod73.z.string(),
-  time: import_zod73.z.string()
-});
-var TokenKlineBsPointResponseSchema = import_zod73.z.object({
-  data: import_zod73.z.array(TokenKlineBsBubblePoint)
+var TokenKlineBsBubblePoint = import_zod74.z.object({
+  volumeBuyToken: import_zod74.z.string(),
+  buys: import_zod74.z.string(),
+  avgBuyPriceUSD: import_zod74.z.string(),
+  volumeBuy: import_zod74.z.string(),
+  volumeSellToken: import_zod74.z.string(),
+  sells: import_zod74.z.string(),
+  avgSellPriceUSD: import_zod74.z.string(),
+  volumeSell: import_zod74.z.string(),
+  fromAddress: import_zod74.z.string(),
+  fromAddressTag: import_zod74.z.string(),
+  time: import_zod74.z.string()
+});
+var TokenKlineBsPointResponseSchema = import_zod74.z.object({
+  data: import_zod74.z.array(TokenKlineBsBubblePoint)
 });
 // src/v2/token/TokenMarketsSchema.ts
-var import_zod74 = require("zod");
+var import_zod75 = require("zod");
 var DEFAULT_MARKETS_RES_LIMIT = 10;
 var MARKETS_MAX__RES_LIMIT = 25;
-var TokenMarketsParamsSchema = import_zod74.z.object({
-  blockchain: import_zod74.z.string().optional(),
-  address: import_zod74.z.string(),
-  limit: import_zod74.z.coerce.number().min(1).max(MARKETS_MAX__RES_LIMIT).default(DEFAULT_MARKETS_RES_LIMIT)
+var TokenMarketsParamsSchema = import_zod75.z.object({
+  blockchain: import_zod75.z.string().optional(),
+  address: import_zod75.z.string(),
+  limit: import_zod75.z.coerce.number().min(1).max(MARKETS_MAX__RES_LIMIT).default(DEFAULT_MARKETS_RES_LIMIT)
 });
-var TokenMarketsOutput = import_zod74.z.array(MarketDetailsOutput);
-var TokenMarketsResponseSchema = import_zod74.z.object({
+var TokenMarketsOutput = import_zod75.z.array(MarketDetailsOutput);
+var TokenMarketsResponseSchema = import_zod75.z.object({
   data: TokenMarketsOutput,
-  totalCount: import_zod74.z.number()
+  totalCount: import_zod75.z.number()
 });
 // src/v2/token/TokenOHLCVHistorySchema.ts
-var import_zod75 = require("zod");
-var booleanFromString2 = import_zod75.z.union([import_zod75.z.boolean(), import_zod75.z.string()]).optional().default(true).transform((val) => {
+var import_zod76 = require("zod");
+var booleanFromString2 = import_zod76.z.union([import_zod76.z.boolean(), import_zod76.z.string()]).optional().default(true).transform((val) => {
   if (typeof val === "boolean")
     return val;
   if (val === "false" || val === "0")
     return false;
   return true;
 });
-var TokenOHLCVHistoryItemSchema = import_zod75.z.object({
-  address: import_zod75.z.string(),
-  chainId: import_zod75.z.string(),
+var TokenOHLCVHistoryItemSchema = import_zod76.z.object({
+  address: import_zod76.z.string(),
+  chainId: import_zod76.z.string(),
   from: DateQuery_default.transform((val) => val ?? 0),
   to: DateQuery_default.transform((val) => val ?? new Date),
-  period: import_zod75.z.string().optional().transform((val) => val ? normalizePeriod(val) : "5m"),
-  amount: import_zod75.z.coerce.number().optional(),
+  period: import_zod76.z.string().optional().transform((val) => val ? normalizePeriod(val) : "5m"),
+  amount: import_zod76.z.coerce.number().optional(),
   usd: booleanFromString2
 });
 var TokenOHLCVHistoryParamsSchema = TokenOHLCVHistoryItemSchema.refine((data) => data.address && data.chainId, { message: "address and chainId are required" });
-var TokenOHLCVHistoryArraySchema = import_zod75.z.array(TokenOHLCVHistoryItemSchema).min(1, "At least one token is required").max(10, "Maximum 10 tokens per request");
-var TokenOHLCVHistoryBatchParamsSchema = import_zod75.z.union([
+var TokenOHLCVHistoryArraySchema = import_zod76.z.array(TokenOHLCVHistoryItemSchema).min(1, "At least one token is required").max(10, "Maximum 10 tokens per request");
+var TokenOHLCVHistoryBatchParamsSchema = import_zod76.z.union([
   TokenOHLCVHistoryArraySchema,
-  import_zod75.z.object({ tokens: TokenOHLCVHistoryArraySchema })
+  import_zod76.z.object({ tokens: TokenOHLCVHistoryArraySchema })
 ]);
-var OHLCVCandleSchema2 = import_zod75.z.object({
-  v: import_zod75.z.number(),
-  o: import_zod75.z.number(),
-  h: import_zod75.z.number(),
-  l: import_zod75.z.number(),
-  c: import_zod75.z.number(),
-  t: import_zod75.z.number()
-});
-var TokenOHLCVHistoryResponseSchema = import_zod75.z.object({
-  data: import_zod75.z.array(OHLCVCandleSchema2)
-});
-var TokenOHLCVHistoryDataSchema = import_zod75.z.object({
-  ohlcv: import_zod75.z.array(OHLCVCandleSchema2),
-  address: import_zod75.z.string(),
-  chainId: import_zod75.z.string(),
-  error: import_zod75.z.string().optional()
-});
-var TokenOHLCVHistoryBatchResponseSchema = import_zod75.z.object({
-  data: import_zod75.z.array(TokenOHLCVHistoryDataSchema)
+var OHLCVCandleSchema2 = import_zod76.z.object({
+  v: import_zod76.z.number(),
+  o: import_zod76.z.number(),
+  h: import_zod76.z.number(),
+  l: import_zod76.z.number(),
+  c: import_zod76.z.number(),
+  t: import_zod76.z.number()
+});
+var TokenOHLCVHistoryResponseSchema = import_zod76.z.object({
+  data: import_zod76.z.array(OHLCVCandleSchema2)
+});
+var TokenOHLCVHistoryDataSchema = import_zod76.z.object({
+  ohlcv: import_zod76.z.array(OHLCVCandleSchema2),
+  address: import_zod76.z.string(),
+  chainId: import_zod76.z.string(),
+  error: import_zod76.z.string().optional()
+});
+var TokenOHLCVHistoryBatchResponseSchema = import_zod76.z.object({
+  data: import_zod76.z.array(TokenOHLCVHistoryDataSchema)
 });
 // src/v2/token/TokenPositionsSchema.ts
-var import_zod77 = require("zod");
+var import_zod78 = require("zod");
 
 // src/v2/wallet/WalletAnalysisQuerySchema.ts
-var import_zod76 = require("zod");
-var PlatformMetadataSchema = import_zod76.z.object({
-  id: import_zod76.z.string(),
-  name: import_zod76.z.string(),
-  logo: import_zod76.z.string().nullable()
-});
-var WalletAnalysisParamsSchema = import_zod76.z.object({
-  wallet: import_zod76.z.string().min(1, "Wallet address is required"),
-  blockchain: import_zod76.z.string().optional(),
-  period: import_zod76.z.string().optional().transform((val) => val?.toLowerCase()).refine((val) => !val || ["1d", "7d", "30d", "90d"].includes(val), {
+var import_zod77 = require("zod");
+var PlatformMetadataSchema = import_zod77.z.object({
+  id: import_zod77.z.string(),
+  name: import_zod77.z.string(),
+  logo: import_zod77.z.string().nullable()
+});
+var WalletAnalysisParamsSchema = import_zod77.z.object({
+  wallet: import_zod77.z.string().min(1, "Wallet address is required"),
+  blockchain: import_zod77.z.string().optional(),
+  period: import_zod77.z.string().optional().transform((val) => val?.toLowerCase()).refine((val) => !val || ["1d", "7d", "30d", "90d"].includes(val), {
     message: "Period must be one of: 1d, 7d, 30d, 90d"
   }),
-  from: import_zod76.z.coerce.number().optional(),
-  to: import_zod76.z.coerce.number().optional()
+  from: import_zod77.z.coerce.number().optional(),
+  to: import_zod77.z.coerce.number().optional()
 }).transform((data) => {
   if (!data.period && (data.from === undefined || data.to === undefined)) {
     return { ...data, period: "7d" };
@@ -6121,540 +6208,566 @@ var WalletAnalysisParamsSchema = import_zod76.z.object({
 }, {
   message: "to must be greater than from"
 });
-var WalletAnalysisParamsSchemaOpenAPI = import_zod76.z.object({
-  wallet: import_zod76.z.string().min(1).describe("Wallet address to analyze"),
-  blockchain: import_zod76.z.string().optional().describe("Blockchain ID (e.g., ethereum, base, solana:solana)"),
-  period: import_zod76.z.string().optional().describe("Analysis period: 1d, 7d, 30d, or 90d (default: 7d)"),
-  from: import_zod76.z.number().optional().describe("Start timestamp in milliseconds (alternative to period)"),
-  to: import_zod76.z.number().optional().describe("End timestamp in milliseconds (alternative to period)")
-});
-var CalendarDayBreakdownSchema = import_zod76.z.object({
-  date: import_zod76.z.coerce.date(),
-  volumeBuy: import_zod76.z.number(),
-  volumeSell: import_zod76.z.number(),
-  totalVolume: import_zod76.z.number(),
-  buys: import_zod76.z.number(),
-  sells: import_zod76.z.number(),
-  realizedPnlUSD: import_zod76.z.number()
-});
-var WalletAnalysisResponseSchema = import_zod76.z.object({
-  data: import_zod76.z.object({
-    winRateDistribution: import_zod76.z.object({
-      ">500%": import_zod76.z.number(),
-      "200%-500%": import_zod76.z.number(),
-      "50%-200%": import_zod76.z.number(),
-      "0%-50%": import_zod76.z.number(),
-      "-50%-0%": import_zod76.z.number(),
-      "<-50%": import_zod76.z.number()
+var WalletAnalysisParamsSchemaOpenAPI = import_zod77.z.object({
+  wallet: import_zod77.z.string().min(1).describe("Wallet address to analyze"),
+  blockchain: import_zod77.z.string().optional().describe("Blockchain ID (e.g., ethereum, base, solana:solana)"),
+  period: import_zod77.z.string().optional().describe("Analysis period: 1d, 7d, 30d, or 90d (default: 7d)"),
+  from: import_zod77.z.number().optional().describe("Start timestamp in milliseconds (alternative to period)"),
+  to: import_zod77.z.number().optional().describe("End timestamp in milliseconds (alternative to period)")
+});
+var CalendarDayBreakdownSchema = import_zod77.z.object({
+  date: import_zod77.z.coerce.date(),
+  volumeBuy: import_zod77.z.number(),
+  volumeSell: import_zod77.z.number(),
+  totalVolume: import_zod77.z.number(),
+  buys: import_zod77.z.number(),
+  sells: import_zod77.z.number(),
+  realizedPnlUSD: import_zod77.z.number()
+});
+var WalletAnalysisResponseSchema = import_zod77.z.object({
+  data: import_zod77.z.object({
+    winRateDistribution: import_zod77.z.object({
+      ">500%": import_zod77.z.number(),
+      "200%-500%": import_zod77.z.number(),
+      "50%-200%": import_zod77.z.number(),
+      "0%-50%": import_zod77.z.number(),
+      "-50%-0%": import_zod77.z.number(),
+      "<-50%": import_zod77.z.number()
     }),
-    marketCapDistribution: import_zod76.z.object({
-      ">1000M": import_zod76.z.number(),
-      ">100M": import_zod76.z.number(),
-      "10M-100M": import_zod76.z.number(),
-      "1M-10M": import_zod76.z.number(),
-      "100k-1M": import_zod76.z.number(),
-      "<100k": import_zod76.z.number()
+    marketCapDistribution: import_zod77.z.object({
+      ">1000M": import_zod77.z.number(),
+      ">100M": import_zod77.z.number(),
+      "10M-100M": import_zod77.z.number(),
+      "1M-10M": import_zod77.z.number(),
+      "100k-1M": import_zod77.z.number(),
+      "<100k": import_zod77.z.number()
     }),
-    periodTimeframes: import_zod76.z.array(import_zod76.z.object({
-      date: import_zod76.z.coerce.date(),
-      realized: import_zod76.z.number()
+    periodTimeframes: import_zod77.z.array(import_zod77.z.object({
+      date: import_zod77.z.coerce.date(),
+      realized: import_zod77.z.number()
     })),
-    calendarBreakdown: import_zod76.z.array(CalendarDayBreakdownSchema),
-    stat: import_zod76.z.object({
-      totalValue: import_zod76.z.number(),
-      periodTotalPnlUSD: import_zod76.z.number(),
-      periodRealizedPnlUSD: import_zod76.z.number(),
-      periodRealizedRate: import_zod76.z.number(),
-      periodActiveTokensCount: import_zod76.z.number(),
-      periodWinCount: import_zod76.z.number(),
-      fundingInfo: import_zod76.z.object({
-        from: import_zod76.z.string().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(),
-        formattedAmount: import_zod76.z.number().nullable(),
-        currency: import_zod76.z.object({
-          name: import_zod76.z.string(),
-          symbol: import_zod76.z.string(),
-          logo: import_zod76.z.string().nullable(),
-          decimals: import_zod76.z.number(),
-          address: import_zod76.z.string()
+    calendarBreakdown: import_zod77.z.array(CalendarDayBreakdownSchema),
+    stat: import_zod77.z.object({
+      totalValue: import_zod77.z.number(),
+      periodTotalPnlUSD: import_zod77.z.number(),
+      periodRealizedPnlUSD: import_zod77.z.number(),
+      periodRealizedRate: import_zod77.z.number(),
+      periodActiveTokensCount: import_zod77.z.number(),
+      periodWinCount: import_zod77.z.number(),
+      fundingInfo: import_zod77.z.object({
+        from: import_zod77.z.string().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(),
+        formattedAmount: import_zod77.z.number().nullable(),
+        currency: import_zod77.z.object({
+          name: import_zod77.z.string(),
+          symbol: import_zod77.z.string(),
+          logo: import_zod77.z.string().nullable(),
+          decimals: import_zod77.z.number(),
+          address: import_zod77.z.string()
         }).nullable(),
-        fromWalletLogo: import_zod76.z.string().nullable(),
-        fromWalletTag: import_zod76.z.string().nullable()
+        fromWalletLogo: import_zod77.z.string().nullable(),
+        fromWalletTag: import_zod77.z.string().nullable()
       }),
-      periodVolumeBuy: import_zod76.z.number(),
-      periodVolumeSell: import_zod76.z.number(),
-      periodBuys: import_zod76.z.number(),
-      periodSells: import_zod76.z.number(),
-      nativeBalance: import_zod76.z.object({
-        rawBalance: import_zod76.z.string(),
-        formattedBalance: import_zod76.z.number(),
-        assetId: import_zod76.z.number().nullable(),
-        chainId: import_zod76.z.string(),
-        address: import_zod76.z.string(),
-        decimals: import_zod76.z.number(),
-        name: import_zod76.z.string(),
-        symbol: import_zod76.z.string(),
-        logo: import_zod76.z.string().nullable(),
-        price: import_zod76.z.number(),
-        balanceUSD: import_zod76.z.number()
+      periodVolumeBuy: import_zod77.z.number(),
+      periodVolumeSell: import_zod77.z.number(),
+      periodBuys: import_zod77.z.number(),
+      periodSells: import_zod77.z.number(),
+      nativeBalance: import_zod77.z.object({
+        rawBalance: import_zod77.z.string(),
+        formattedBalance: import_zod77.z.number(),
+        assetId: import_zod77.z.number().nullable(),
+        chainId: import_zod77.z.string(),
+        address: import_zod77.z.string(),
+        decimals: import_zod77.z.number(),
+        name: import_zod77.z.string(),
+        symbol: import_zod77.z.string(),
+        logo: import_zod77.z.string().nullable(),
+        price: import_zod77.z.number(),
+        balanceUSD: import_zod77.z.number()
       }).nullable(),
-      periodBuyTokens: import_zod76.z.number(),
-      periodSellTokens: import_zod76.z.number(),
-      periodTradingTokens: import_zod76.z.number(),
-      holdingTokensCount: import_zod76.z.number(),
-      holdingDuration: import_zod76.z.number(),
-      tradingTimeFrames: import_zod76.z.number(),
-      winRealizedPnl: import_zod76.z.number(),
-      winRealizedPnlRate: import_zod76.z.number(),
-      winToken: import_zod76.z.object({
-        address: import_zod76.z.string(),
-        chainId: import_zod76.z.string(),
-        name: import_zod76.z.string(),
-        symbol: import_zod76.z.string(),
-        logo: import_zod76.z.string().nullable(),
-        decimals: import_zod76.z.number()
+      periodBuyTokens: import_zod77.z.number(),
+      periodSellTokens: import_zod77.z.number(),
+      periodTradingTokens: import_zod77.z.number(),
+      holdingTokensCount: import_zod77.z.number(),
+      holdingDuration: import_zod77.z.number(),
+      tradingTimeFrames: import_zod77.z.number(),
+      winRealizedPnl: import_zod77.z.number(),
+      winRealizedPnlRate: import_zod77.z.number(),
+      winToken: import_zod77.z.object({
+        address: import_zod77.z.string(),
+        chainId: import_zod77.z.string(),
+        name: import_zod77.z.string(),
+        symbol: import_zod77.z.string(),
+        logo: import_zod77.z.string().nullable(),
+        decimals: import_zod77.z.number()
       }).nullable()
     }),
-    labels: import_zod76.z.array(import_zod76.z.string()),
+    labels: import_zod77.z.array(import_zod77.z.string()),
     walletMetadata: WalletMetadataOutput.nullable(),
     platform: PlatformMetadataSchema.nullable()
   })
 });
-var CalendarDayBreakdownSchemaOpenAPI = import_zod76.z.object({
-  date: import_zod76.z.string(),
-  volumeBuy: import_zod76.z.number(),
-  volumeSell: import_zod76.z.number(),
-  totalVolume: import_zod76.z.number(),
-  buys: import_zod76.z.number(),
-  sells: import_zod76.z.number(),
-  realizedPnlUSD: import_zod76.z.number()
-});
-var WalletAnalysisResponseSchemaOpenAPI = import_zod76.z.object({
-  data: import_zod76.z.object({
-    winRateDistribution: import_zod76.z.object({
-      ">500%": import_zod76.z.number(),
-      "200%-500%": import_zod76.z.number(),
-      "50%-200%": import_zod76.z.number(),
-      "0%-50%": import_zod76.z.number(),
-      "-50%-0%": import_zod76.z.number(),
-      "<-50%": import_zod76.z.number()
+var CalendarDayBreakdownSchemaOpenAPI = import_zod77.z.object({
+  date: import_zod77.z.string(),
+  volumeBuy: import_zod77.z.number(),
+  volumeSell: import_zod77.z.number(),
+  totalVolume: import_zod77.z.number(),
+  buys: import_zod77.z.number(),
+  sells: import_zod77.z.number(),
+  realizedPnlUSD: import_zod77.z.number()
+});
+var WalletAnalysisResponseSchemaOpenAPI = import_zod77.z.object({
+  data: import_zod77.z.object({
+    winRateDistribution: import_zod77.z.object({
+      ">500%": import_zod77.z.number(),
+      "200%-500%": import_zod77.z.number(),
+      "50%-200%": import_zod77.z.number(),
+      "0%-50%": import_zod77.z.number(),
+      "-50%-0%": import_zod77.z.number(),
+      "<-50%": import_zod77.z.number()
     }),
-    marketCapDistribution: import_zod76.z.object({
-      ">1000M": import_zod76.z.number(),
-      ">100M": import_zod76.z.number(),
-      "10M-100M": import_zod76.z.number(),
-      "1M-10M": import_zod76.z.number(),
-      "100k-1M": import_zod76.z.number(),
-      "<100k": import_zod76.z.number()
+    marketCapDistribution: import_zod77.z.object({
+      ">1000M": import_zod77.z.number(),
+      ">100M": import_zod77.z.number(),
+      "10M-100M": import_zod77.z.number(),
+      "1M-10M": import_zod77.z.number(),
+      "100k-1M": import_zod77.z.number(),
+      "<100k": import_zod77.z.number()
     }),
-    periodTimeframes: import_zod76.z.array(import_zod76.z.object({
-      date: import_zod76.z.string(),
-      realized: import_zod76.z.number()
+    periodTimeframes: import_zod77.z.array(import_zod77.z.object({
+      date: import_zod77.z.string(),
+      realized: import_zod77.z.number()
     })),
-    calendarBreakdown: import_zod76.z.array(CalendarDayBreakdownSchemaOpenAPI),
-    stat: import_zod76.z.object({
-      totalValue: import_zod76.z.number(),
-      periodTotalPnlUSD: import_zod76.z.number(),
-      periodRealizedPnlUSD: import_zod76.z.number(),
-      periodRealizedRate: import_zod76.z.number(),
-      periodActiveTokensCount: import_zod76.z.number(),
-      periodWinCount: import_zod76.z.number(),
-      fundingInfo: import_zod76.z.object({
-        from: import_zod76.z.string().nullable(),
-        date: import_zod76.z.string().nullable(),
-        chainId: import_zod76.z.string().nullable(),
-        txHash: import_zod76.z.string().nullable(),
-        amount: import_zod76.z.string().nullable(),
-        formattedAmount: import_zod76.z.number().nullable(),
-        currency: import_zod76.z.object({
-          name: import_zod76.z.string(),
-          symbol: import_zod76.z.string(),
-          logo: import_zod76.z.string().nullable(),
-          decimals: import_zod76.z.number(),
-          address: import_zod76.z.string()
+    calendarBreakdown: import_zod77.z.array(CalendarDayBreakdownSchemaOpenAPI),
+    stat: import_zod77.z.object({
+      totalValue: import_zod77.z.number(),
+      periodTotalPnlUSD: import_zod77.z.number(),
+      periodRealizedPnlUSD: import_zod77.z.number(),
+      periodRealizedRate: import_zod77.z.number(),
+      periodActiveTokensCount: import_zod77.z.number(),
+      periodWinCount: import_zod77.z.number(),
+      fundingInfo: import_zod77.z.object({
+        from: import_zod77.z.string().nullable(),
+        date: import_zod77.z.string().nullable(),
+        chainId: import_zod77.z.string().nullable(),
+        txHash: import_zod77.z.string().nullable(),
+        amount: import_zod77.z.string().nullable(),
+        formattedAmount: import_zod77.z.number().nullable(),
+        currency: import_zod77.z.object({
+          name: import_zod77.z.string(),
+          symbol: import_zod77.z.string(),
+          logo: import_zod77.z.string().nullable(),
+          decimals: import_zod77.z.number(),
+          address: import_zod77.z.string()
         }).nullable(),
-        fromWalletLogo: import_zod76.z.string().nullable(),
-        fromWalletTag: import_zod76.z.string().nullable()
+        fromWalletLogo: import_zod77.z.string().nullable(),
+        fromWalletTag: import_zod77.z.string().nullable()
       }),
-      periodVolumeBuy: import_zod76.z.number(),
-      periodVolumeSell: import_zod76.z.number(),
-      periodBuys: import_zod76.z.number(),
-      periodSells: import_zod76.z.number(),
-      nativeBalance: import_zod76.z.object({
-        rawBalance: import_zod76.z.string(),
-        formattedBalance: import_zod76.z.number(),
-        assetId: import_zod76.z.number().nullable(),
-        chainId: import_zod76.z.string(),
-        address: import_zod76.z.string(),
-        decimals: import_zod76.z.number(),
-        name: import_zod76.z.string(),
-        symbol: import_zod76.z.string(),
-        logo: import_zod76.z.string().nullable(),
-        price: import_zod76.z.number(),
-        balanceUSD: import_zod76.z.number()
+      periodVolumeBuy: import_zod77.z.number(),
+      periodVolumeSell: import_zod77.z.number(),
+      periodBuys: import_zod77.z.number(),
+      periodSells: import_zod77.z.number(),
+      nativeBalance: import_zod77.z.object({
+        rawBalance: import_zod77.z.string(),
+        formattedBalance: import_zod77.z.number(),
+        assetId: import_zod77.z.number().nullable(),
+        chainId: import_zod77.z.string(),
+        address: import_zod77.z.string(),
+        decimals: import_zod77.z.number(),
+        name: import_zod77.z.string(),
+        symbol: import_zod77.z.string(),
+        logo: import_zod77.z.string().nullable(),
+        price: import_zod77.z.number(),
+        balanceUSD: import_zod77.z.number()
       }).nullable(),
-      periodBuyTokens: import_zod76.z.number(),
-      periodSellTokens: import_zod76.z.number(),
-      periodTradingTokens: import_zod76.z.number(),
-      holdingTokensCount: import_zod76.z.number(),
-      holdingDuration: import_zod76.z.number(),
-      tradingTimeFrames: import_zod76.z.number(),
-      winRealizedPnl: import_zod76.z.number(),
-      winRealizedPnlRate: import_zod76.z.number(),
-      winToken: import_zod76.z.object({
-        address: import_zod76.z.string(),
-        chainId: import_zod76.z.string(),
-        name: import_zod76.z.string(),
-        symbol: import_zod76.z.string(),
-        logo: import_zod76.z.string().nullable(),
-        decimals: import_zod76.z.number()
+      periodBuyTokens: import_zod77.z.number(),
+      periodSellTokens: import_zod77.z.number(),
+      periodTradingTokens: import_zod77.z.number(),
+      holdingTokensCount: import_zod77.z.number(),
+      holdingDuration: import_zod77.z.number(),
+      tradingTimeFrames: import_zod77.z.number(),
+      winRealizedPnl: import_zod77.z.number(),
+      winRealizedPnlRate: import_zod77.z.number(),
+      winToken: import_zod77.z.object({
+        address: import_zod77.z.string(),
+        chainId: import_zod77.z.string(),
+        name: import_zod77.z.string(),
+        symbol: import_zod77.z.string(),
+        logo: import_zod77.z.string().nullable(),
+        decimals: import_zod77.z.number()
       }).nullable()
     }),
-    labels: import_zod76.z.array(import_zod76.z.string()),
+    labels: import_zod77.z.array(import_zod77.z.string()),
     walletMetadata: WalletMetadataOutput.nullable(),
-    platform: import_zod76.z.object({
-      id: import_zod76.z.string(),
-      name: import_zod76.z.string(),
-      logo: import_zod76.z.string().nullable()
+    platform: import_zod77.z.object({
+      id: import_zod77.z.string(),
+      name: import_zod77.z.string(),
+      logo: import_zod77.z.string().nullable()
     }).nullable()
   })
 });
 
 // src/v2/token/TokenPositionsSchema.ts
-var TokenPositionsParamsSchema = import_zod77.z.object({
-  blockchain: import_zod77.z.string().optional(),
-  address: import_zod77.z.string().optional(),
-  force: import_zod77.z.coerce.boolean().optional().default(false),
-  label: import_zod77.z.nativeEnum(Tags).optional(),
-  limit: import_zod77.z.coerce.number().optional().default(100),
-  offset: import_zod77.z.coerce.number().optional().default(0),
+var TokenPositionsParamsSchema = import_zod78.z.object({
+  blockchain: import_zod78.z.string().optional(),
+  address: import_zod78.z.string().optional(),
+  force: import_zod78.z.coerce.boolean().optional().default(false),
+  label: import_zod78.z.nativeEnum(Tags).optional(),
+  limit: import_zod78.z.coerce.number().optional().default(100),
+  offset: import_zod78.z.coerce.number().optional().default(0),
   walletAddresses: stringOrArray.optional()
 });
-var TokenPositionOutput = import_zod77.z.object({
-  chainId: import_zod77.z.string(),
-  walletAddress: import_zod77.z.string(),
-  tokenAddress: import_zod77.z.string(),
-  tokenAmount: import_zod77.z.string(),
-  tokenAmountRaw: import_zod77.z.string(),
-  tokenAmountUSD: import_zod77.z.string(),
-  percentageOfTotalSupply: import_zod77.z.string(),
-  pnlUSD: import_zod77.z.string(),
-  realizedPnlUSD: import_zod77.z.string(),
-  unrealizedPnlUSD: import_zod77.z.string(),
-  totalPnlUSD: import_zod77.z.string(),
-  buys: import_zod77.z.number(),
-  sells: import_zod77.z.number(),
-  volumeBuyToken: import_zod77.z.string(),
-  volumeSellToken: import_zod77.z.string(),
-  volumeBuyUSD: import_zod77.z.string(),
-  volumeSellUSD: import_zod77.z.string(),
-  avgBuyPriceUSD: import_zod77.z.string(),
-  avgSellPriceUSD: import_zod77.z.string(),
-  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([]),
+var TokenPositionOutput = import_zod78.z.object({
+  chainId: import_zod78.z.string(),
+  walletAddress: import_zod78.z.string(),
+  tokenAddress: import_zod78.z.string(),
+  tokenAmount: import_zod78.z.string(),
+  tokenAmountRaw: import_zod78.z.string(),
+  tokenAmountUSD: import_zod78.z.string(),
+  percentageOfTotalSupply: import_zod78.z.string(),
+  pnlUSD: import_zod78.z.string(),
+  realizedPnlUSD: import_zod78.z.string(),
+  unrealizedPnlUSD: import_zod78.z.string(),
+  totalPnlUSD: import_zod78.z.string(),
+  buys: import_zod78.z.number(),
+  sells: import_zod78.z.number(),
+  volumeBuyToken: import_zod78.z.string(),
+  volumeSellToken: import_zod78.z.string(),
+  volumeBuyUSD: import_zod78.z.string(),
+  volumeSellUSD: import_zod78.z.string(),
+  avgBuyPriceUSD: import_zod78.z.string(),
+  avgSellPriceUSD: import_zod78.z.string(),
+  walletFundAt: import_zod78.z.coerce.date().nullable(),
+  lastActivityAt: import_zod78.z.coerce.date().nullable(),
+  firstTradeAt: import_zod78.z.coerce.date().nullable(),
+  lastTradeAt: import_zod78.z.coerce.date().nullable(),
+  labels: import_zod78.z.array(import_zod78.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.coerce.date().nullable(),
-    chainId: import_zod77.z.string().nullable(),
-    txHash: import_zod77.z.string().nullable(),
-    amount: import_zod77.z.string().nullable(),
-    formattedAmount: import_zod77.z.number().nullable(),
-    currency: import_zod77.z.object({
-      name: import_zod77.z.string(),
-      symbol: import_zod77.z.string(),
-      logo: import_zod77.z.string().nullable(),
-      decimals: import_zod77.z.number(),
-      address: import_zod77.z.string()
+  fundingInfo: import_zod78.z.object({
+    from: import_zod78.z.string().nullable(),
+    date: import_zod78.z.coerce.date().nullable(),
+    chainId: import_zod78.z.string().nullable(),
+    txHash: import_zod78.z.string().nullable(),
+    amount: import_zod78.z.string().nullable(),
+    formattedAmount: import_zod78.z.number().nullable(),
+    currency: import_zod78.z.object({
+      name: import_zod78.z.string(),
+      symbol: import_zod78.z.string(),
+      logo: import_zod78.z.string().nullable(),
+      decimals: import_zod78.z.number(),
+      address: import_zod78.z.string()
     }).nullable(),
-    fromWalletLogo: import_zod77.z.string().nullable(),
-    fromWalletTag: import_zod77.z.string().nullable()
+    fromWalletLogo: import_zod78.z.string().nullable(),
+    fromWalletTag: import_zod78.z.string().nullable()
   })
 });
-var TokenPositionsResponseSchema = import_zod77.z.object({
-  data: import_zod77.z.array(TokenPositionOutput),
-  totalCount: import_zod77.z.number()
+var TokenPositionsResponseSchema = import_zod78.z.object({
+  data: import_zod78.z.array(TokenPositionOutput),
+  totalCount: import_zod78.z.number()
+});
+// src/v2/token/TokenPriceHistorySchema.ts
+var import_zod79 = require("zod");
+var PriceHistoryTimeframe = import_zod79.z.enum(["15m", "1h", "24h", "7d", "30d", "1y"]).default("24h");
+var TokenPriceHistoryItemSchema = import_zod79.z.object({
+  address: import_zod79.z.string(),
+  chainId: import_zod79.z.string(),
+  timeframe: PriceHistoryTimeframe
+});
+var TokenPriceHistoryParamsSchema = TokenPriceHistoryItemSchema.refine((data) => data.address && data.chainId, { message: "address and chainId are required" });
+var TokenPriceHistoryArraySchema = import_zod79.z.array(TokenPriceHistoryItemSchema).min(1, "At least one token is required").max(50, "Maximum 50 tokens per request");
+var TokenPriceHistoryBatchParamsSchema = import_zod79.z.union([
+  TokenPriceHistoryArraySchema,
+  import_zod79.z.object({ items: TokenPriceHistoryArraySchema })
+]);
+var TokenPriceHistoryDataSchema = import_zod79.z.object({
+  priceHistory: import_zod79.z.array(import_zod79.z.array(import_zod79.z.number())),
+  address: import_zod79.z.string(),
+  chainId: import_zod79.z.string(),
+  error: import_zod79.z.string().optional()
+});
+var TokenPriceHistoryResponseSchema = import_zod79.z.object({
+  data: TokenPriceHistoryDataSchema
+});
+var TokenPriceHistoryBatchResponseSchema = import_zod79.z.object({
+  data: import_zod79.z.array(TokenPriceHistoryDataSchema)
 });
 // src/v2/token/TokenPriceSchema.ts
-var import_zod78 = require("zod");
-var TokenPriceItemParams = import_zod78.z.object({
-  blockchain: import_zod78.z.string().optional(),
-  address: import_zod78.z.string().optional()
+var import_zod80 = require("zod");
+var TokenPriceItemParams = import_zod80.z.object({
+  blockchain: import_zod80.z.string().optional(),
+  address: import_zod80.z.string().optional()
 });
 var TokenPriceParamsSchema = TokenPriceItemParams;
-var TokenPriceBatchParamsSchema = import_zod78.z.union([
-  import_zod78.z.array(TokenPriceItemParams),
-  import_zod78.z.object({
-    items: import_zod78.z.array(TokenPriceItemParams)
+var TokenPriceBatchParamsSchema = import_zod80.z.union([
+  import_zod80.z.array(TokenPriceItemParams),
+  import_zod80.z.object({
+    items: import_zod80.z.array(TokenPriceItemParams)
   })
 ]);
-var TokenPriceItemResponseSchema = import_zod78.z.object({
-  name: import_zod78.z.string().nullable(),
-  symbol: import_zod78.z.string().nullable(),
-  logo: import_zod78.z.string().nullable(),
-  priceUSD: import_zod78.z.number().nullable(),
-  marketCapUSD: import_zod78.z.number().nullable(),
-  marketCapDilutedUSD: import_zod78.z.number().nullable(),
-  liquidityUSD: import_zod78.z.number().nullable(),
-  liquidityMaxUSD: import_zod78.z.number().nullable()
-});
-var TokenPriceResponseSchema = import_zod78.z.object({
+var TokenPriceItemResponseSchema = import_zod80.z.object({
+  name: import_zod80.z.string().nullable(),
+  symbol: import_zod80.z.string().nullable(),
+  logo: import_zod80.z.string().nullable(),
+  priceUSD: import_zod80.z.number().nullable(),
+  marketCapUSD: import_zod80.z.number().nullable(),
+  marketCapDilutedUSD: import_zod80.z.number().nullable(),
+  liquidityUSD: import_zod80.z.number().nullable(),
+  liquidityMaxUSD: import_zod80.z.number().nullable()
+});
+var TokenPriceResponseSchema = import_zod80.z.object({
   data: TokenPriceItemResponseSchema
 });
-var TokenPriceBatchResponseSchema = import_zod78.z.object({
-  payload: import_zod78.z.array(TokenPriceItemResponseSchema.or(import_zod78.z.object({ error: import_zod78.z.string().optional() })).nullable())
+var TokenPriceBatchResponseSchema = import_zod80.z.object({
+  payload: import_zod80.z.array(TokenPriceItemResponseSchema.or(import_zod80.z.object({ error: import_zod80.z.string().optional() })).nullable())
 });
 // src/v2/token/TokenSecurityOutput.ts
-var import_zod79 = require("zod");
-var StaticAnalysisStatusEnum = import_zod79.z.enum([
+var import_zod81 = require("zod");
+var StaticAnalysisStatusEnum = import_zod81.z.enum([
   "completed",
   "pending",
   "not_available",
   "insufficient_liquidity",
   "not_evm"
 ]);
-var TokenSecurityOutput = import_zod79.z.object({
-  address: import_zod79.z.string(),
-  chainId: import_zod79.z.string(),
-  contractHoldingsPercentage: import_zod79.z.number().nullable(),
-  contractBalanceRaw: import_zod79.z.string().nullable(),
-  burnedHoldingsPercentage: import_zod79.z.number().nullable(),
-  totalBurnedBalanceRaw: import_zod79.z.string().nullable(),
-  buyFeePercentage: import_zod79.z.number(),
-  sellFeePercentage: import_zod79.z.number(),
-  maxWalletAmountRaw: import_zod79.z.string().nullable(),
-  maxSellAmountRaw: import_zod79.z.string().nullable(),
-  maxBuyAmountRaw: import_zod79.z.string().nullable(),
-  maxTransferAmountRaw: import_zod79.z.string().nullable(),
-  isLaunchpadToken: import_zod79.z.boolean().nullable(),
-  top10HoldingsPercentage: import_zod79.z.number().nullable(),
-  top50HoldingsPercentage: import_zod79.z.number().nullable(),
-  top100HoldingsPercentage: import_zod79.z.number().nullable(),
-  top200HoldingsPercentage: import_zod79.z.number().nullable(),
-  isMintable: import_zod79.z.boolean().nullable(),
-  isFreezable: import_zod79.z.boolean().nullable(),
-  proTraderVolume24hPercentage: import_zod79.z.number().nullable(),
-  transferPausable: import_zod79.z.boolean().nullable(),
-  isBlacklisted: import_zod79.z.boolean().nullable(),
-  isHoneypot: import_zod79.z.boolean().nullable(),
-  isNotOpenSource: import_zod79.z.boolean().nullable(),
-  renounced: import_zod79.z.boolean().nullable(),
-  locked: import_zod79.z.string().nullable(),
-  isWhitelisted: import_zod79.z.boolean().nullable(),
-  balanceMutable: import_zod79.z.boolean().nullable(),
-  lowLiquidity: import_zod79.z.string().nullable(),
-  burnRate: import_zod79.z.string().nullable(),
-  modifyableTax: import_zod79.z.boolean().nullable(),
-  selfDestruct: import_zod79.z.boolean().nullable(),
+var TokenSecurityOutput = import_zod81.z.object({
+  address: import_zod81.z.string(),
+  chainId: import_zod81.z.string(),
+  contractHoldingsPercentage: import_zod81.z.number().nullable(),
+  contractBalanceRaw: import_zod81.z.string().nullable(),
+  burnedHoldingsPercentage: import_zod81.z.number().nullable(),
+  totalBurnedBalanceRaw: import_zod81.z.string().nullable(),
+  buyFeePercentage: import_zod81.z.number(),
+  sellFeePercentage: import_zod81.z.number(),
+  maxWalletAmountRaw: import_zod81.z.string().nullable(),
+  maxSellAmountRaw: import_zod81.z.string().nullable(),
+  maxBuyAmountRaw: import_zod81.z.string().nullable(),
+  maxTransferAmountRaw: import_zod81.z.string().nullable(),
+  isLaunchpadToken: import_zod81.z.boolean().nullable(),
+  top10HoldingsPercentage: import_zod81.z.number().nullable(),
+  top50HoldingsPercentage: import_zod81.z.number().nullable(),
+  top100HoldingsPercentage: import_zod81.z.number().nullable(),
+  top200HoldingsPercentage: import_zod81.z.number().nullable(),
+  isMintable: import_zod81.z.boolean().nullable(),
+  isFreezable: import_zod81.z.boolean().nullable(),
+  proTraderVolume24hPercentage: import_zod81.z.number().nullable(),
+  transferPausable: import_zod81.z.boolean().nullable(),
+  isBlacklisted: import_zod81.z.boolean().nullable(),
+  isHoneypot: import_zod81.z.boolean().nullable(),
+  isNotOpenSource: import_zod81.z.boolean().nullable(),
+  renounced: import_zod81.z.boolean().nullable(),
+  locked: import_zod81.z.string().nullable(),
+  isWhitelisted: import_zod81.z.boolean().nullable(),
+  balanceMutable: import_zod81.z.boolean().nullable(),
+  lowLiquidity: import_zod81.z.string().nullable(),
+  burnRate: import_zod81.z.string().nullable(),
+  modifyableTax: import_zod81.z.boolean().nullable(),
+  selfDestruct: import_zod81.z.boolean().nullable(),
   staticAnalysisStatus: StaticAnalysisStatusEnum.nullable(),
-  staticAnalysisDate: import_zod79.z.string().nullable()
+  staticAnalysisDate: import_zod81.z.string().nullable()
 });
-var TokenSecurityResponseSchema = import_zod79.z.object({
+var TokenSecurityResponseSchema = import_zod81.z.object({
   data: TokenSecurityOutput,
-  hostname: import_zod79.z.string().optional()
+  hostname: import_zod81.z.string().optional()
 });
 // src/v2/token/TokenSecurityQuery.ts
-var import_zod80 = require("zod");
-var TokenSecurityQuery = import_zod80.z.object({
-  blockchain: import_zod80.z.string().optional(),
-  address: import_zod80.z.string(),
-  instanceTracking: import_zod80.z.preprocess((val) => {
+var import_zod82 = require("zod");
+var TokenSecurityQuery = import_zod82.z.object({
+  blockchain: import_zod82.z.string().optional(),
+  address: import_zod82.z.string(),
+  instanceTracking: import_zod82.z.preprocess((val) => {
     if (val === "true")
       return true;
     if (val === "false")
       return false;
     return val;
-  }, import_zod80.z.boolean().optional()),
-  _forceAnalysis: import_zod80.z.preprocess((val) => {
+  }, import_zod82.z.boolean().optional()),
+  _forceAnalysis: import_zod82.z.preprocess((val) => {
     if (val === "true")
       return true;
     if (val === "false")
       return false;
     return val;
-  }, import_zod80.z.boolean().optional())
+  }, import_zod82.z.boolean().optional())
 });
 // src/v2/token/TokenTradesSchema.ts
-var import_zod81 = require("zod");
-var TokenTradesParamsSchema = import_zod81.z.object({
-  blockchain: import_zod81.z.string().optional(),
-  address: import_zod81.z.string().optional(),
-  offset: import_zod81.z.coerce.number().default(0),
-  limit: import_zod81.z.coerce.number().optional().default(10),
-  sortOrder: import_zod81.z.enum(["asc", "desc"]).default("desc"),
-  mode: import_zod81.z.enum(["pair", "pool", "asset"]).default("pair").transform((val) => val === "pool" ? "pair" : val),
-  label: import_zod81.z.nativeEnum(Tags).optional(),
+var import_zod83 = require("zod");
+var TokenTradesParamsSchema = import_zod83.z.object({
+  blockchain: import_zod83.z.string().optional(),
+  address: import_zod83.z.string().optional(),
+  offset: import_zod83.z.coerce.number().default(0),
+  limit: import_zod83.z.coerce.number().optional().default(10),
+  sortOrder: import_zod83.z.enum(["asc", "desc"]).default("desc"),
+  mode: import_zod83.z.enum(["pair", "pool", "asset"]).default("pair").transform((val) => val === "pool" ? "pair" : val),
+  label: import_zod83.z.nativeEnum(Tags).optional(),
   swapTypes: stringOrArray.optional().transform((val) => val?.filter((v) => Object.values(SwapType).includes(v))),
   transactionSenderAddresses: stringOrArray.optional().refine((arr) => !arr || arr.length <= 25, {
     message: "Maximum 25 transaction sender addresses allowed"
   }),
-  useSwapRecipient: import_zod81.z.coerce.boolean().optional().default(false),
-  maxAmountUSD: import_zod81.z.coerce.number().optional(),
-  minAmountUSD: import_zod81.z.coerce.number().optional(),
+  useSwapRecipient: import_zod83.z.coerce.boolean().optional().default(false),
+  maxAmountUSD: import_zod83.z.coerce.number().optional(),
+  minAmountUSD: import_zod83.z.coerce.number().optional(),
   fromDate: DateQuery_default.transform((val) => val ?? undefined),
   toDate: DateQuery_default.transform((val) => val ?? undefined)
 });
-var TokenTradeOutput = import_zod81.z.object({
-  id: import_zod81.z.string(),
-  operation: import_zod81.z.string(),
-  type: import_zod81.z.string(),
-  baseTokenAmount: import_zod81.z.number(),
-  baseTokenAmountRaw: import_zod81.z.string(),
-  baseTokenAmountUSD: import_zod81.z.number(),
-  quoteTokenAmount: import_zod81.z.number(),
-  quoteTokenAmountRaw: import_zod81.z.string(),
-  quoteTokenAmountUSD: import_zod81.z.number(),
-  preBalanceBaseToken: import_zod81.z.string().nullable().optional(),
-  preBalanceQuoteToken: import_zod81.z.string().nullable().optional(),
-  postBalanceBaseToken: import_zod81.z.string().nullable().optional(),
-  postBalanceQuoteToken: import_zod81.z.string().nullable().optional(),
-  date: import_zod81.z.number(),
-  swapSenderAddress: import_zod81.z.string(),
-  transactionSenderAddress: import_zod81.z.string(),
-  swapRecipient: import_zod81.z.string().nullable().optional(),
-  blockchain: import_zod81.z.string(),
-  transactionHash: import_zod81.z.string(),
-  marketAddress: import_zod81.z.string(),
-  marketAddresses: import_zod81.z.array(import_zod81.z.string()).optional(),
-  baseTokenPriceUSD: import_zod81.z.number(),
-  quoteTokenPriceUSD: import_zod81.z.number(),
-  labels: import_zod81.z.array(import_zod81.z.string()).nullable().optional().default([]),
+var TokenTradeOutput = import_zod83.z.object({
+  id: import_zod83.z.string(),
+  operation: import_zod83.z.string(),
+  type: import_zod83.z.string(),
+  baseTokenAmount: import_zod83.z.number(),
+  baseTokenAmountRaw: import_zod83.z.string(),
+  baseTokenAmountUSD: import_zod83.z.number(),
+  quoteTokenAmount: import_zod83.z.number(),
+  quoteTokenAmountRaw: import_zod83.z.string(),
+  quoteTokenAmountUSD: import_zod83.z.number(),
+  preBalanceBaseToken: import_zod83.z.string().nullable().optional(),
+  preBalanceQuoteToken: import_zod83.z.string().nullable().optional(),
+  postBalanceBaseToken: import_zod83.z.string().nullable().optional(),
+  postBalanceQuoteToken: import_zod83.z.string().nullable().optional(),
+  date: import_zod83.z.number(),
+  swapSenderAddress: import_zod83.z.string(),
+  transactionSenderAddress: import_zod83.z.string(),
+  swapRecipient: import_zod83.z.string().nullable().optional(),
+  blockchain: import_zod83.z.string(),
+  transactionHash: import_zod83.z.string(),
+  marketAddress: import_zod83.z.string(),
+  marketAddresses: import_zod83.z.array(import_zod83.z.string()).optional(),
+  baseTokenPriceUSD: import_zod83.z.number(),
+  quoteTokenPriceUSD: import_zod83.z.number(),
+  labels: import_zod83.z.array(import_zod83.z.string()).nullable().optional().default([]),
   walletMetadata: WalletMetadataOutput.nullable().optional(),
   baseToken: TokenMetadataMinimal.nullable().optional(),
   quoteToken: TokenMetadataMinimal.nullable().optional(),
   platform: PlatformMetadataOutput.nullable().optional(),
-  totalFeesUSD: import_zod81.z.number().nullable().optional(),
-  gasFeesUSD: import_zod81.z.number().nullable().optional(),
-  platformFeesUSD: import_zod81.z.number().nullable().optional(),
-  mevFeesUSD: import_zod81.z.number().nullable().optional()
-});
-var TokenTradeResponseSchema = import_zod81.z.object({
-  data: import_zod81.z.array(TokenTradeOutput)
-});
-var SingleTokenTradeOutput = import_zod81.z.object({
-  id: import_zod81.z.string(),
-  operation: import_zod81.z.string(),
-  type: import_zod81.z.string(),
-  baseTokenAmount: import_zod81.z.number(),
-  baseTokenAmountRaw: import_zod81.z.string(),
-  baseTokenAmountUSD: import_zod81.z.number(),
-  quoteTokenAmount: import_zod81.z.number(),
-  quoteTokenAmountRaw: import_zod81.z.string(),
-  quoteTokenAmountUSD: import_zod81.z.number(),
-  preBalanceBaseToken: import_zod81.z.string().nullable().optional(),
-  preBalanceQuoteToken: import_zod81.z.string().nullable().optional(),
-  postBalanceBaseToken: import_zod81.z.string().nullable().optional(),
-  postBalanceQuoteToken: import_zod81.z.string().nullable().optional(),
-  date: import_zod81.z.number(),
-  swapSenderAddress: import_zod81.z.string(),
-  transactionSenderAddress: import_zod81.z.string(),
-  swapRecipient: import_zod81.z.string().nullable().optional(),
-  blockchain: import_zod81.z.string(),
-  transactionHash: import_zod81.z.string(),
-  marketAddress: import_zod81.z.string(),
-  marketAddresses: import_zod81.z.array(import_zod81.z.string()).optional(),
-  baseTokenPriceUSD: import_zod81.z.number(),
-  quoteTokenPriceUSD: import_zod81.z.number(),
-  labels: import_zod81.z.array(import_zod81.z.string()).nullable().optional().default([]),
+  totalFeesUSD: import_zod83.z.number().nullable().optional(),
+  gasFeesUSD: import_zod83.z.number().nullable().optional(),
+  platformFeesUSD: import_zod83.z.number().nullable().optional(),
+  mevFeesUSD: import_zod83.z.number().nullable().optional()
+});
+var TokenTradeResponseSchema = import_zod83.z.object({
+  data: import_zod83.z.array(TokenTradeOutput)
+});
+var SingleTokenTradeOutput = import_zod83.z.object({
+  id: import_zod83.z.string(),
+  operation: import_zod83.z.string(),
+  type: import_zod83.z.string(),
+  baseTokenAmount: import_zod83.z.number(),
+  baseTokenAmountRaw: import_zod83.z.string(),
+  baseTokenAmountUSD: import_zod83.z.number(),
+  quoteTokenAmount: import_zod83.z.number(),
+  quoteTokenAmountRaw: import_zod83.z.string(),
+  quoteTokenAmountUSD: import_zod83.z.number(),
+  preBalanceBaseToken: import_zod83.z.string().nullable().optional(),
+  preBalanceQuoteToken: import_zod83.z.string().nullable().optional(),
+  postBalanceBaseToken: import_zod83.z.string().nullable().optional(),
+  postBalanceQuoteToken: import_zod83.z.string().nullable().optional(),
+  date: import_zod83.z.number(),
+  swapSenderAddress: import_zod83.z.string(),
+  transactionSenderAddress: import_zod83.z.string(),
+  swapRecipient: import_zod83.z.string().nullable().optional(),
+  blockchain: import_zod83.z.string(),
+  transactionHash: import_zod83.z.string(),
+  marketAddress: import_zod83.z.string(),
+  marketAddresses: import_zod83.z.array(import_zod83.z.string()).optional(),
+  baseTokenPriceUSD: import_zod83.z.number(),
+  quoteTokenPriceUSD: import_zod83.z.number(),
+  labels: import_zod83.z.array(import_zod83.z.string()).nullable().optional().default([]),
   walletMetadata: WalletMetadataOutput.nullable().optional(),
   baseToken: TokenDetailsOutput.optional(),
   quoteToken: TokenDetailsOutput.optional(),
   platform: PlatformMetadataOutput.nullable().optional(),
-  totalFeesUSD: import_zod81.z.number().nullable().optional(),
-  gasFeesUSD: import_zod81.z.number().nullable().optional(),
-  platformFeesUSD: import_zod81.z.number().nullable().optional(),
-  mevFeesUSD: import_zod81.z.number().nullable().optional()
+  totalFeesUSD: import_zod83.z.number().nullable().optional(),
+  gasFeesUSD: import_zod83.z.number().nullable().optional(),
+  platformFeesUSD: import_zod83.z.number().nullable().optional(),
+  mevFeesUSD: import_zod83.z.number().nullable().optional()
 });
-var SingleTokenTradeResponseSchema = import_zod81.z.object({
+var SingleTokenTradeResponseSchema = import_zod83.z.object({
   data: SingleTokenTradeOutput
 });
-var FormattedTokenTradeOutput = import_zod81.z.object({
-  labels: import_zod81.z.array(import_zod81.z.string()).nullable().optional().default([]),
+var FormattedTokenTradeOutput = import_zod83.z.object({
+  labels: import_zod83.z.array(import_zod83.z.string()).nullable().optional().default([]),
   walletMetadata: WalletMetadataOutput.nullable().optional(),
-  pair: import_zod81.z.string(),
-  date: import_zod81.z.number(),
-  tokenPrice: import_zod81.z.number(),
-  tokenPriceVs: import_zod81.z.number(),
-  tokenAmount: import_zod81.z.number(),
-  tokenAmountVs: import_zod81.z.number(),
-  tokenAmountUsd: import_zod81.z.number(),
-  tokenAmountVsUsd: import_zod81.z.number(),
-  type: import_zod81.z.string(),
-  operation: import_zod81.z.string(),
-  blockchain: import_zod81.z.string(),
-  hash: import_zod81.z.string(),
-  sender: import_zod81.z.string(),
-  swapRecipient: import_zod81.z.string().nullable().optional(),
-  tokenAmountRaw: import_zod81.z.string(),
-  tokenAmountRawVs: import_zod81.z.string(),
+  pair: import_zod83.z.string(),
+  date: import_zod83.z.number(),
+  tokenPrice: import_zod83.z.number(),
+  tokenPriceVs: import_zod83.z.number(),
+  tokenAmount: import_zod83.z.number(),
+  tokenAmountVs: import_zod83.z.number(),
+  tokenAmountUsd: import_zod83.z.number(),
+  tokenAmountVsUsd: import_zod83.z.number(),
+  type: import_zod83.z.string(),
+  operation: import_zod83.z.string(),
+  blockchain: import_zod83.z.string(),
+  hash: import_zod83.z.string(),
+  sender: import_zod83.z.string(),
+  swapRecipient: import_zod83.z.string().nullable().optional(),
+  tokenAmountRaw: import_zod83.z.string(),
+  tokenAmountRawVs: import_zod83.z.string(),
   platform: PlatformMetadataOutput.nullable().optional(),
-  totalFeesUSD: import_zod81.z.number().nullable().optional(),
-  gasFeesUSD: import_zod81.z.number().nullable().optional(),
-  platformFeesUSD: import_zod81.z.number().nullable().optional(),
-  mevFeesUSD: import_zod81.z.number().nullable().optional()
-});
-var FormattedTokenTradeResponseSchema = import_zod81.z.object({
-  data: import_zod81.z.array(FormattedTokenTradeOutput)
-});
-var TokenTradeParamsSchema = import_zod81.z.object({
-  blockchain: import_zod81.z.string().optional(),
-  transactionHash: import_zod81.z.string().min(1, "Transaction hash is required")
-});
-var TokenTradeParamsSchemaOpenAPI = import_zod81.z.object({
-  blockchain: import_zod81.z.string().describe("Blockchain name or chain ID"),
-  transactionHash: import_zod81.z.string().min(1).describe("Transaction hash")
-});
-var TokenTradeOutputOpenAPI = import_zod81.z.object({
-  id: import_zod81.z.string(),
-  operation: import_zod81.z.string(),
-  type: import_zod81.z.string(),
-  baseTokenAmount: import_zod81.z.number(),
-  baseTokenAmountRaw: import_zod81.z.string(),
-  baseTokenAmountUSD: import_zod81.z.number(),
-  quoteTokenAmount: import_zod81.z.number(),
-  quoteTokenAmountRaw: import_zod81.z.string(),
-  quoteTokenAmountUSD: import_zod81.z.number(),
-  date: import_zod81.z.number(),
-  swapSenderAddress: import_zod81.z.string(),
-  transactionSenderAddress: import_zod81.z.string(),
-  swapRecipient: import_zod81.z.string().nullable().optional().describe("The actual beneficiary wallet of the swap. Most important address for AA wallets and accurate PnL tracking."),
-  blockchain: import_zod81.z.string(),
-  transactionHash: import_zod81.z.string(),
-  marketAddress: import_zod81.z.string(),
-  marketAddresses: import_zod81.z.array(import_zod81.z.string()).optional(),
-  baseTokenPriceUSD: import_zod81.z.number(),
-  quoteTokenPriceUSD: import_zod81.z.number(),
-  labels: import_zod81.z.array(import_zod81.z.string()).nullable().optional().default([]),
+  totalFeesUSD: import_zod83.z.number().nullable().optional(),
+  gasFeesUSD: import_zod83.z.number().nullable().optional(),
+  platformFeesUSD: import_zod83.z.number().nullable().optional(),
+  mevFeesUSD: import_zod83.z.number().nullable().optional()
+});
+var FormattedTokenTradeResponseSchema = import_zod83.z.object({
+  data: import_zod83.z.array(FormattedTokenTradeOutput)
+});
+var TokenTradeParamsSchema = import_zod83.z.object({
+  blockchain: import_zod83.z.string().optional(),
+  transactionHash: import_zod83.z.string().min(1, "Transaction hash is required")
+});
+var TokenTradeParamsSchemaOpenAPI = import_zod83.z.object({
+  blockchain: import_zod83.z.string().describe("Blockchain name or chain ID"),
+  transactionHash: import_zod83.z.string().min(1).describe("Transaction hash")
+});
+var TokenTradeOutputOpenAPI = import_zod83.z.object({
+  id: import_zod83.z.string(),
+  operation: import_zod83.z.string(),
+  type: import_zod83.z.string(),
+  baseTokenAmount: import_zod83.z.number(),
+  baseTokenAmountRaw: import_zod83.z.string(),
+  baseTokenAmountUSD: import_zod83.z.number(),
+  quoteTokenAmount: import_zod83.z.number(),
+  quoteTokenAmountRaw: import_zod83.z.string(),
+  quoteTokenAmountUSD: import_zod83.z.number(),
+  date: import_zod83.z.number(),
+  swapSenderAddress: import_zod83.z.string(),
+  transactionSenderAddress: import_zod83.z.string(),
+  swapRecipient: import_zod83.z.string().nullable().optional().describe("The actual beneficiary wallet of the swap. Most important address for AA wallets and accurate PnL tracking."),
+  blockchain: import_zod83.z.string(),
+  transactionHash: import_zod83.z.string(),
+  marketAddress: import_zod83.z.string(),
+  marketAddresses: import_zod83.z.array(import_zod83.z.string()).optional(),
+  baseTokenPriceUSD: import_zod83.z.number(),
+  quoteTokenPriceUSD: import_zod83.z.number(),
+  labels: import_zod83.z.array(import_zod83.z.string()).nullable().optional().default([]),
   walletMetadata: WalletMetadataOutput.nullable().optional(),
   baseToken: TokenMetadataMinimal.nullable().optional(),
   quoteToken: TokenMetadataMinimal.nullable().optional(),
   platform: PlatformMetadataOutput.nullable().optional(),
-  totalFeesUSD: import_zod81.z.number().nullable().optional(),
-  gasFeesUSD: import_zod81.z.number().nullable().optional(),
-  platformFeesUSD: import_zod81.z.number().nullable().optional(),
-  mevFeesUSD: import_zod81.z.number().nullable().optional()
+  totalFeesUSD: import_zod83.z.number().nullable().optional(),
+  gasFeesUSD: import_zod83.z.number().nullable().optional(),
+  platformFeesUSD: import_zod83.z.number().nullable().optional(),
+  mevFeesUSD: import_zod83.z.number().nullable().optional()
 });
-var SingleTokenTradeResponseSchemaOpenAPI = import_zod81.z.object({
+var SingleTokenTradeResponseSchemaOpenAPI = import_zod83.z.object({
   data: TokenTradeOutputOpenAPI
 });
 // src/v2/trades/TradesFiltersSchema.ts
-var import_zod82 = require("zod");
+var import_zod84 = require("zod");
 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(),
+var TradesFiltersParamsSchema = import_zod84.z.object({
+  tokenAddress: import_zod84.z.string().optional(),
+  blockchain: import_zod84.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")
+  limit: import_zod84.z.coerce.number().min(1).max(TRADES_FILTERS_MAX_LIMIT).optional().default(1000),
+  cursor: import_zod84.z.string().optional(),
+  sortOrder: import_zod84.z.enum(["asc", "desc"]).default("asc")
 }).refine((data) => {
   if (!data.from || !data.to)
     return false;
@@ -6670,186 +6783,186 @@ var TradesFiltersParamsSchema = import_zod82.z.object({
 }, {
   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 TradesFiltersPaginationSchema = import_zod84.z.object({
+  count: import_zod84.z.number(),
+  nextCursor: import_zod84.z.string().nullable(),
+  hasMore: import_zod84.z.boolean(),
+  from: import_zod84.z.number(),
+  to: import_zod84.z.number()
 });
-var TradesFiltersResponseSchema = import_zod82.z.object({
-  data: import_zod82.z.array(TokenTradeOutput),
+var TradesFiltersResponseSchema = import_zod84.z.object({
+  data: import_zod84.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) => {
+var import_zod85 = require("zod");
+var WalletActivityV2ParamsSchema = import_zod85.z.object({
+  wallet: import_zod85.z.string(),
+  blockchains: import_zod85.z.string().optional().transform((val) => {
     if (val) {
       return val.split(",").map((b) => b.trim()).filter((b) => b.length > 0);
     }
     return [];
   }),
-  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()
+  blacklist: import_zod85.z.string().optional().transform((val) => val ? val.split(",").map((addr) => addr.trim().toLowerCase()) : []),
+  offset: import_zod85.z.coerce.number().optional().default(0),
+  limit: import_zod85.z.coerce.number().optional().default(100),
+  order: import_zod85.z.enum(["asc", "desc"]).optional().default("desc"),
+  pagination: import_zod85.z.union([import_zod85.z.boolean(), import_zod85.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
+  unlistedAssets: import_zod85.z.union([import_zod85.z.boolean(), import_zod85.z.string()]).optional().transform((val) => val === true || val === "true").default(true),
+  filterSpam: import_zod85.z.union([import_zod85.z.boolean(), import_zod85.z.string()]).optional().transform((val) => val === true || val === "true").default(true),
+  backfillTransfers: import_zod85.z.union([import_zod85.z.boolean(), import_zod85.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
+  backfillBalances: import_zod85.z.union([import_zod85.z.boolean(), import_zod85.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
+  cursorHash: import_zod85.z.string().optional(),
+  cursorDirection: import_zod85.z.enum(["before", "after"]).optional(),
+  cursor_hash: import_zod85.z.string().optional(),
+  cursor_direction: import_zod85.z.enum(["before", "after"]).optional(),
+  withTokens: import_zod85.z.union([import_zod85.z.boolean(), import_zod85.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
+  enrichSwaps: import_zod85.z.union([import_zod85.z.boolean(), import_zod85.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
+  from: import_zod85.z.coerce.number().optional(),
+  to: import_zod85.z.coerce.number().optional()
 }).transform((data) => ({
   ...data,
   cursorHash: data.cursorHash ?? data.cursor_hash,
   cursorDirection: data.cursorDirection ?? data.cursor_direction ?? "before"
 }));
-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(),
+var ActivityAssetSchema = import_zod85.z.object({
+  id: import_zod85.z.number().nullable(),
+  name: import_zod85.z.string(),
+  symbol: import_zod85.z.string(),
+  decimals: import_zod85.z.number(),
+  totalSupply: import_zod85.z.number(),
+  circulatingSupply: import_zod85.z.number(),
+  price: import_zod85.z.number(),
+  liquidity: import_zod85.z.number(),
+  priceChange24hPercent: import_zod85.z.number(),
+  marketCapUsd: import_zod85.z.number(),
+  logo: import_zod85.z.string().nullable(),
+  contract: import_zod85.z.string()
+});
+var WalletActivityV2TransactionActivitySchema = import_zod85.z.object({
+  model: import_zod85.z.enum(["swap", "transfer"]),
+  swapType: import_zod85.z.enum(["REGULAR", "MEV", "SANDWICHED_MEV", "DEPOSIT", "WITHDRAW"]).optional(),
+  swapRawAmountOut: import_zod85.z.number().optional(),
+  swapRawAmountIn: import_zod85.z.number().optional(),
+  swapAmountOut: import_zod85.z.number().optional(),
+  swapAmountIn: import_zod85.z.number().optional(),
+  swapPriceUsdTokenOut: import_zod85.z.number().optional(),
+  swapPriceUsdTokenIn: import_zod85.z.number().optional(),
+  swapAmountUsd: import_zod85.z.number().optional(),
+  swapTransactionSenderAddress: import_zod85.z.string().optional(),
+  swapBaseAddress: import_zod85.z.string().optional(),
+  swapQuoteAddress: import_zod85.z.string().optional(),
+  swapAmountQuote: import_zod85.z.number().optional(),
+  swapAmountBase: import_zod85.z.number().optional(),
   swapAssetIn: ActivityAssetSchema.optional(),
   swapAssetOut: ActivityAssetSchema.optional(),
   swapPlatform: PlatformMetadataOutput.nullable().optional(),
-  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(),
+  swapTotalFeesUsd: import_zod85.z.number().nullable().optional(),
+  swapGasFeesUsd: import_zod85.z.number().nullable().optional(),
+  swapPlatformFeesUsd: import_zod85.z.number().nullable().optional(),
+  swapMevFeesUsd: import_zod85.z.number().nullable().optional(),
+  transferRawAmount: import_zod85.z.string().optional(),
+  transferAmount: import_zod85.z.number().optional(),
+  transferAmountUsd: import_zod85.z.number().optional(),
+  transferType: import_zod85.z.enum(["VAULT_DEPOSIT", "VAULT_WITHDRAW", "VAULT_UNSTAKE", "TOKEN_IN", "TOKEN_OUT", "NATIVE_IN", "NATIVE_OUT"]).optional(),
+  transferFromAddress: import_zod85.z.string().optional().nullable(),
+  transferToAddress: import_zod85.z.string().optional().nullable(),
   transferAsset: ActivityAssetSchema.optional()
 });
-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({
+var WalletActivityV2TransactionSchema = import_zod85.z.object({
+  chainId: import_zod85.z.string(),
+  txDateMs: import_zod85.z.number(),
+  txDateIso: import_zod85.z.string(),
+  txHash: import_zod85.z.string(),
+  txRawFeesNative: import_zod85.z.string(),
+  txFeesNativeUsd: import_zod85.z.number(),
+  txBlockNumber: import_zod85.z.number(),
+  txIndex: import_zod85.z.number(),
+  txAction: import_zod85.z.string().optional().nullable(),
+  actions: import_zod85.z.array(WalletActivityV2TransactionActivitySchema)
+});
+var WalletActivityV2OutputDataSchema = import_zod85.z.array(WalletActivityV2TransactionSchema);
+var WalletActivityV2OutputPaginationSchema = import_zod85.z.object({
+  page: import_zod85.z.number(),
+  offset: import_zod85.z.number(),
+  limit: import_zod85.z.number(),
+  pageEntries: import_zod85.z.number()
+});
+var WalletActivityV2ResponseSchema = import_zod85.z.object({
   data: WalletActivityV2OutputDataSchema,
   pagination: WalletActivityV2OutputPaginationSchema,
-  backfillStatus: import_zod83.z.enum(["processed", "processing", "pending"]).optional(),
-  tokens: import_zod83.z.array(TokenDetailsOutput).optional()
+  backfillStatus: import_zod85.z.enum(["processed", "processing", "pending"]).optional(),
+  tokens: import_zod85.z.array(TokenDetailsOutput).optional()
 });
 // src/v2/wallet/WalletDefiPositionsSchema.ts
-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({
+var import_zod86 = require("zod");
+var walletAddressSchema = import_zod86.z.string().min(32, "Invalid wallet address").max(44, "Invalid wallet address").or(import_zod86.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid EVM wallet address"));
+var WalletDefiPositionsParamsSchema = import_zod86.z.object({
   wallet: walletAddressSchema.describe("Wallet address (EVM or Solana)"),
-  blockchains: import_zod84.z.string().describe('Blockchain to fetch positions from (e.g., "solana", "ethereum")')
+  blockchains: import_zod86.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_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()
+var import_zod87 = require("zod");
+var WalletFundingParamsSchema = import_zod87.z.object({
+  wallet: import_zod87.z.string().min(1, "Wallet address is required")
+});
+var WalletFundingResponseSchema = import_zod87.z.object({
+  data: import_zod87.z.object({
+    from: import_zod87.z.string().nullable(),
+    chainId: import_zod87.z.string().nullable(),
+    date: import_zod87.z.coerce.date().nullable(),
+    txHash: import_zod87.z.string().nullable(),
+    amount: import_zod87.z.string().nullable(),
+    fromWalletLogo: import_zod87.z.string().nullable(),
+    fromWalletTag: import_zod87.z.string().nullable()
   })
 });
 // src/v2/wallet/WalletPerpsPositionsSchema.ts
-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(),
+var import_zod88 = require("zod");
+var ExchangesIds = import_zod88.z.enum(["gains", "hyperliquid", "gte", "lighter", "drift"]);
+var tpSlSchema = import_zod88.z.object({ size: import_zod88.z.bigint(), price: import_zod88.z.number(), id: import_zod88.z.number() });
+var PerpsPositionSchema = import_zod88.z.object({
+  id: import_zod88.z.string(),
+  entryPriceQuote: import_zod88.z.number(),
+  currentLeverage: import_zod88.z.number(),
+  amountUSD: import_zod88.z.number(),
+  amountRaw: import_zod88.z.bigint(),
+  side: import_zod88.z.enum(["BUY", "SELL"]),
+  liquidationPriceQuote: import_zod88.z.number(),
+  currentPriceQuote: import_zod88.z.number(),
+  realizedPnlUSD: import_zod88.z.number(),
+  unrealizedPnlUSD: import_zod88.z.number(),
+  realizedPnlPercent: import_zod88.z.number(),
+  unrealizedPnlPercent: import_zod88.z.number(),
+  tp: import_zod88.z.array(tpSlSchema),
+  sl: import_zod88.z.array(tpSlSchema),
+  marketId: import_zod88.z.string(),
   exchange: ExchangesIds,
-  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()
+  feesOpeningUSD: import_zod88.z.number(),
+  feesClosingUSD: import_zod88.z.number(),
+  feesFundingUSD: import_zod88.z.number(),
+  openDate: import_zod88.z.coerce.date(),
+  lastUpdate: import_zod88.z.coerce.date(),
+  address: import_zod88.z.string(),
+  chainId: import_zod88.z.string(),
+  collateralAsset: import_zod88.z.string()
 });
 var PerpsPositionNonExecutedSchema = PerpsPositionSchema.extend({
-  type: import_zod86.z.enum(["STOP", "LIMIT"])
+  type: import_zod88.z.enum(["STOP", "LIMIT"])
 });
-var WalletPerpsPositionsResponseSchema = import_zod86.z.object({
-  data: import_zod86.z.array(PerpsPositionSchema)
+var WalletPerpsPositionsResponseSchema = import_zod88.z.object({
+  data: import_zod88.z.array(PerpsPositionSchema)
 });
-var WalletPerpsPositionsNonExecutedResponseSchema = import_zod86.z.object({
-  data: import_zod86.z.array(PerpsPositionNonExecutedSchema)
+var WalletPerpsPositionsNonExecutedResponseSchema = import_zod88.z.object({
+  data: import_zod88.z.array(PerpsPositionNonExecutedSchema)
 });
 // src/v2/wallet/WalletPositionsSchema.ts
-var import_zod87 = require("zod");
-var PositionSortBySchema = import_zod87.z.enum(["lastActivity", "realizedPnl"]).default("lastActivity");
+var import_zod89 = require("zod");
+var PositionSortBySchema = import_zod89.z.enum(["lastActivity", "realizedPnl"]).default("lastActivity");
 var positionSortByToInternal = (sortBy) => {
   const mapping = {
     lastActivity: "last_activity",
@@ -6857,287 +6970,287 @@ var positionSortByToInternal = (sortBy) => {
   };
   return mapping[sortBy];
 };
-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"),
+var WalletPositionsParamsSchema = import_zod89.z.object({
+  wallet: import_zod89.z.string(),
+  blockchain: import_zod89.z.string().optional(),
+  limit: import_zod89.z.coerce.number().min(1).max(500).optional().default(100),
+  offset: import_zod89.z.coerce.number().min(0).optional().default(0),
+  cursor: import_zod89.z.string().optional(),
+  cursorDirection: import_zod89.z.enum(["before", "after"]).optional().default("after"),
   sortBy: PositionSortBySchema.optional(),
-  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) => {
+  order: import_zod89.z.enum(["asc", "desc"]).optional().default("desc"),
+  _backfillPositions: import_zod89.z.union([import_zod89.z.boolean(), import_zod89.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  _backfillSwapsAndPositions: import_zod89.z.union([import_zod89.z.boolean(), import_zod89.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  includeFees: import_zod89.z.union([import_zod89.z.boolean(), import_zod89.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  useSwapRecipient: import_zod89.z.union([import_zod89.z.boolean(), import_zod89.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+});
+var SinglePositionQuery = import_zod89.z.object({
+  wallet: import_zod89.z.string(),
+  asset: import_zod89.z.string(),
+  blockchain: import_zod89.z.string(),
+  includeFees: import_zod89.z.union([import_zod89.z.boolean(), import_zod89.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  useSwapRecipient: import_zod89.z.union([import_zod89.z.boolean(), import_zod89.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+});
+var SinglePositionItemSchema = import_zod89.z.object({
+  wallet: import_zod89.z.string(),
+  asset: import_zod89.z.string(),
+  blockchain: import_zod89.z.string(),
+  includeFees: import_zod89.z.union([import_zod89.z.boolean(), import_zod89.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  useSwapRecipient: import_zod89.z.union([import_zod89.z.boolean(), import_zod89.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+});
+var SinglePositionBatchParamsSchema = import_zod89.z.union([
+  import_zod89.z.array(SinglePositionItemSchema),
+  import_zod89.z.object({
+    items: import_zod89.z.array(SinglePositionItemSchema),
+    instanceTracking: import_zod89.z.preprocess((val) => {
       if (val === "true")
         return true;
       if (val === "false")
         return false;
       return val;
-    }, import_zod87.z.boolean().optional())
+    }, import_zod89.z.boolean().optional())
   })
 ]);
-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),
+var WalletPositionsPaginationSchema = import_zod89.z.object({
+  page: import_zod89.z.number(),
+  offset: import_zod89.z.number(),
+  limit: import_zod89.z.number(),
+  pageEntries: import_zod89.z.number()
+});
+var WalletPositionsResponseSchema = import_zod89.z.object({
+  data: import_zod89.z.array(tokenPositionSchema),
   wallet: WalletMetadataSchema.optional(),
   pagination: WalletPositionsPaginationSchema.optional()
 });
-var singlePositionOutputSchema = import_zod87.z.object({
+var singlePositionOutputSchema = import_zod89.z.object({
   data: tokenPositionSchema,
   wallet: WalletMetadataSchema.optional()
 });
 var batchPositionItemSchema = tokenPositionSchema.extend({
-  wallet: import_zod87.z.string()
+  wallet: import_zod89.z.string()
 });
-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()
+var SinglePositionBatchResponseSchema = import_zod89.z.object({
+  payload: import_zod89.z.array(batchPositionItemSchema.or(import_zod89.z.object({ error: import_zod89.z.string().optional(), wallet: import_zod89.z.string().optional() })).nullable()),
+  hostname: import_zod89.z.string().optional()
 });
 // src/v2/wallet/WalletTokenBalancesSchema.ts
-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(),
+var import_zod90 = require("zod");
+var tokenHoldingSchema = import_zod90.z.object({
+  token: import_zod90.z.object({
+    address: import_zod90.z.string(),
+    chainId: import_zod90.z.string(),
+    name: import_zod90.z.string().nullable(),
+    symbol: import_zod90.z.string().nullable(),
+    logo: import_zod90.z.string().nullable(),
+    decimals: import_zod90.z.coerce.number().default(0),
+    holdersCount: import_zod90.z.coerce.number().default(0),
+    deployer: import_zod90.z.string().nullable(),
+    website: import_zod90.z.string().nullable(),
+    x: import_zod90.z.string().nullable(),
+    telegram: import_zod90.z.string().nullable(),
+    description: import_zod90.z.string().nullable(),
     security: SecurityFlagsSchema.nullable()
   }),
-  balance: import_zod88.z.number(),
-  rawBalance: import_zod88.z.string(),
-  lamports: import_zod88.z.string().nullable().optional()
+  balance: import_zod90.z.number(),
+  rawBalance: import_zod90.z.string(),
+  lamports: import_zod90.z.string().nullable().optional()
 });
-var WalletHoldingsResponseSchema = import_zod88.z.object({
-  data: import_zod88.z.array(tokenHoldingSchema)
+var WalletHoldingsResponseSchema = import_zod90.z.object({
+  data: import_zod90.z.array(tokenHoldingSchema)
 });
 // src/wss/aggregated-feed/FeedSchema.ts
-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()
+var import_zod91 = require("zod");
+var FeedPayloadSchema = import_zod91.z.discriminatedUnion("kind", [
+  import_zod91.z.object({
+    kind: import_zod91.z.literal("asset_ids"),
+    asset_ids: import_zod91.z.array(import_zod91.z.number()).optional(),
+    quote_id: import_zod91.z.number().optional().nullable()
   }),
-  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()
+  import_zod91.z.object({
+    kind: import_zod91.z.literal("address"),
+    tokens: import_zod91.z.array(import_zod91.z.object({
+      blockchain: import_zod91.z.string(),
+      address: import_zod91.z.string()
     })),
-    quote: import_zod89.z.object({
-      address: import_zod89.z.string(),
-      blockchain: import_zod89.z.string()
+    quote: import_zod91.z.object({
+      address: import_zod91.z.string(),
+      blockchain: import_zod91.z.string()
     }).optional()
   }),
-  import_zod89.z.object({
-    kind: import_zod89.z.literal("all")
+  import_zod91.z.object({
+    kind: import_zod91.z.literal("all")
   })
 ]);
-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()
+var FeedAssetIdSchema = import_zod91.z.object({
+  asset_ids: import_zod91.z.array(import_zod91.z.number()).optional(),
+  quote_id: import_zod91.z.number().optional().nullable()
+});
+var FeedTokenSchema = import_zod91.z.object({
+  tokens: import_zod91.z.array(import_zod91.z.object({
+    blockchain: import_zod91.z.string(),
+    address: import_zod91.z.string()
   })),
-  quote: import_zod89.z.object({
-    address: import_zod89.z.string(),
-    blockchain: import_zod89.z.string()
+  quote: import_zod91.z.object({
+    address: import_zod91.z.string(),
+    blockchain: import_zod91.z.string()
   }).optional()
 });
 // src/wss/BalancePayloadSchema.ts
-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 import_zod92 = require("zod");
+var BalanceItemSchema = import_zod92.z.object({
+  wallet: import_zod92.z.string(),
+  token: import_zod92.z.string(),
+  blockchain: import_zod92.z.string()
 });
-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)
+var BalancePayloadSchema = import_zod92.z.object({
+  items: import_zod92.z.array(BalanceItemSchema),
+  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)
 });
 // src/wss/FastTradePayloadSchema.ts
-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()
+var import_zod93 = require("zod");
+var FastTradesPayloadSchema = import_zod93.z.object({
+  assetMode: import_zod93.z.coerce.boolean().default(false),
+  items: import_zod93.z.array(import_zod93.z.object({
+    address: import_zod93.z.string(),
+    blockchain: import_zod93.z.string()
   })),
-  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)
+  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/FundingPayloadSchema.ts
-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) => {
+var import_zod94 = require("zod");
+var FundingPayloadSchema = import_zod94.z.object({
+  symbol: import_zod94.z.string(),
+  quote: import_zod94.z.string().optional(),
+  exchange: import_zod94.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_zod92.z.number().optional().default(5),
-  subscriptionId: import_zod92.z.string().optional(),
-  subscriptionTracking: import_zod92.z.string().optional()
+  interval: import_zod94.z.number().optional().default(5),
+  subscriptionId: import_zod94.z.string().optional(),
+  subscriptionTracking: import_zod94.z.string().optional()
 });
 // src/wss/HoldersPayloadSchema.ts
-var import_zod93 = require("zod");
-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()
+var import_zod95 = require("zod");
+var HoldersPayloadSchema = import_zod95.z.object({
+  tokens: import_zod95.z.array(import_zod95.z.object({
+    address: import_zod95.z.string(),
+    blockchain: import_zod95.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)
+  subscriptionId: import_zod95.z.string().optional(),
+  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/MarketDetailsPayloadSchema.ts
-var import_zod94 = require("zod");
-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()
+var import_zod96 = require("zod");
+var MarketDetailsPayloadSchema = import_zod96.z.object({
+  pools: import_zod96.z.array(import_zod96.z.object({
+    address: import_zod96.z.string(),
+    blockchain: import_zod96.z.string()
   })),
-  subscriptionId: import_zod94.z.string().optional(),
-  subscriptionTracking: import_zod94.z.union([import_zod94.z.boolean(), import_zod94.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+  subscriptionId: import_zod96.z.string().optional(),
+  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/MarketPayloadSchema.ts
-var import_zod95 = require("zod");
-var MarketPayloadSchema = import_zod95.z.object({
-  interval: import_zod95.z.number().default(30),
-  subscriptionId: import_zod95.z.string().optional(),
-  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()
+var import_zod97 = require("zod");
+var MarketPayloadSchema = import_zod97.z.object({
+  interval: import_zod97.z.number().default(30),
+  subscriptionId: import_zod97.z.string().optional(),
+  assets: import_zod97.z.array(import_zod97.z.union([
+    import_zod97.z.object({ name: import_zod97.z.string() }),
+    import_zod97.z.object({ symbol: import_zod97.z.string() }),
+    import_zod97.z.object({
+      address: import_zod97.z.string(),
+      blockchain: import_zod97.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)
+  subscriptionTracking: import_zod97.z.union([import_zod97.z.boolean(), import_zod97.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 // src/wss/OhlcvPayloadSchema.ts
-var import_zod96 = require("zod");
-var OhlcvPayloadSchema = import_zod96.z.object({
-  address: import_zod96.z.string().optional(),
-  subscriptionId: import_zod96.z.string().optional(),
-  blockchain: import_zod96.z.string().optional(),
-  chainId: import_zod96.z.string().optional(),
-  period: import_zod96.z.string().optional().transform((val) => {
+var import_zod98 = require("zod");
+var OhlcvPayloadSchema = import_zod98.z.object({
+  address: import_zod98.z.string().optional(),
+  subscriptionId: import_zod98.z.string().optional(),
+  blockchain: import_zod98.z.string().optional(),
+  chainId: import_zod98.z.string().optional(),
+  period: import_zod98.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)
+  asset: import_zod98.z.string().optional(),
+  currentPrice: import_zod98.z.string().optional(),
+  mode: import_zod98.z.enum(["asset", "pair", "pool"]).optional().transform((val) => val === "pool" ? "pair" : val),
+  subscriptionTracking: import_zod98.z.union([import_zod98.z.boolean(), import_zod98.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 // src/wss/PairsPayloadSchema.ts
-var import_zod97 = require("zod");
-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(),
-  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 import_zod99 = require("zod");
+var PairsPayloadSchema = import_zod99.z.object({
+  mode: import_zod99.z.enum(["asset", "pair", "pool"]).optional().default("pair").transform((val) => val === "pool" ? "pair" : val),
+  subscriptionId: import_zod99.z.string().optional(),
+  blockchain: import_zod99.z.string().optional(),
+  factory: import_zod99.z.string().optional(),
+  interval: import_zod99.z.number().default(30),
+  address: import_zod99.z.string().optional(),
+  asset: import_zod99.z.string().optional(),
+  subscriptionTracking: import_zod99.z.union([import_zod99.z.boolean(), import_zod99.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)
+var import_zod100 = require("zod");
+var PositionPayloadSchema = import_zod100.z.object({
+  wallet: import_zod100.z.string(),
+  token: import_zod100.z.string(),
+  blockchain: import_zod100.z.string(),
+  subscriptionId: import_zod100.z.string().optional(),
+  subscriptionTracking: import_zod100.z.union([import_zod100.z.boolean(), import_zod100.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  includeFees: import_zod100.z.union([import_zod100.z.boolean(), import_zod100.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  useSwapRecipient: import_zod100.z.union([import_zod100.z.boolean(), import_zod100.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+});
+var PositionsPayloadSchema = import_zod100.z.object({
+  wallet: import_zod100.z.string(),
+  blockchain: import_zod100.z.string(),
+  subscriptionId: import_zod100.z.string().optional(),
+  subscriptionTracking: import_zod100.z.union([import_zod100.z.boolean(), import_zod100.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  includeFees: import_zod100.z.union([import_zod100.z.boolean(), import_zod100.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  useSwapRecipient: import_zod100.z.union([import_zod100.z.boolean(), import_zod100.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 // src/wss/pulse/PausePulsePayloadSchema.ts
-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)
+var import_zod101 = require("zod");
+var PausePulsePayloadSchema = import_zod101.z.object({
+  action: import_zod101.z.enum(["pause", "unpause"]),
+  views: import_zod101.z.array(import_zod101.z.string()).min(1)
 });
 // src/wss/stream/StreamPayloadSchema.ts
-var import_zod101 = require("zod");
+var import_zod103 = require("zod");
 
 // src/utils/schemas/Filter.ts
-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()]))
+var import_zod102 = require("zod");
+var BaseFilter2 = import_zod102.z.object({
+  eq: import_zod102.z.tuple([import_zod102.z.string(), import_zod102.z.union([import_zod102.z.string(), import_zod102.z.number(), import_zod102.z.boolean(), import_zod102.z.null()])]).optional(),
+  neq: import_zod102.z.tuple([import_zod102.z.string(), import_zod102.z.union([import_zod102.z.string(), import_zod102.z.number(), import_zod102.z.boolean(), import_zod102.z.null()])]).optional(),
+  lt: import_zod102.z.tuple([import_zod102.z.string(), import_zod102.z.coerce.number()]).optional(),
+  lte: import_zod102.z.tuple([import_zod102.z.string(), import_zod102.z.coerce.number()]).optional(),
+  gt: import_zod102.z.tuple([import_zod102.z.string(), import_zod102.z.coerce.number()]).optional(),
+  gte: import_zod102.z.tuple([import_zod102.z.string(), import_zod102.z.coerce.number()]).optional(),
+  in: import_zod102.z.tuple([
+    import_zod102.z.string(),
+    import_zod102.z.union([
+      import_zod102.z.string(),
+      import_zod102.z.number(),
+      import_zod102.z.boolean(),
+      import_zod102.z.null(),
+      import_zod102.z.array(import_zod102.z.union([import_zod102.z.string(), import_zod102.z.number(), import_zod102.z.boolean(), import_zod102.z.null()]))
     ])
   ]).optional()
 });
-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)) })
+var Filter2 = BaseFilter2.and(import_zod102.z.union([
+  BaseFilter2.extend({ and: import_zod102.z.undefined(), or: import_zod102.z.undefined() }),
+  BaseFilter2.extend({ and: import_zod102.z.array(import_zod102.z.lazy(() => Filter2)), or: import_zod102.z.undefined() }),
+  BaseFilter2.extend({ and: import_zod102.z.undefined(), or: import_zod102.z.array(import_zod102.z.lazy(() => Filter2)) })
 ]));
 function countOperations2(filter) {
   if (!filter)
@@ -7164,7 +7277,7 @@ var FilterWithLimit2 = Filter2.superRefine((val, ctx) => {
   const max = 1000;
   if (total > max) {
     ctx.addIssue({
-      code: import_zod100.z.ZodIssueCode.custom,
+      code: import_zod102.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.`
     });
   }
@@ -7172,21 +7285,21 @@ var FilterWithLimit2 = Filter2.superRefine((val, ctx) => {
 var Filter_default = FilterWithLimit2;
 
 // src/wss/stream/StreamPayloadSchema.ts
-var StreamPayloadSchema = import_zod101.z.object({
+var StreamPayloadSchema = import_zod103.z.object({
   filters: Filter_default.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()
+  chainIds: import_zod103.z.array(import_zod103.z.string()).nonempty(),
+  name: import_zod103.z.string().optional(),
+  events: import_zod103.z.array(import_zod103.z.enum(["swap", "transfer", "swap-enriched", "block", "order"])).nonempty(),
+  authorization: import_zod103.z.string(),
+  subscriptionId: import_zod103.z.string().optional(),
+  subscriptionTracking: import_zod103.z.string().optional(),
+  debugSubscriptionId: import_zod103.z.string().optional()
+});
+var UnsubscribeStreamPayloadSchema = import_zod103.z.object({
+  type: import_zod103.z.enum(["stream"]).optional(),
+  subscriptionId: import_zod103.z.string().optional(),
+  personalizedId: import_zod103.z.string().optional(),
+  viewName: import_zod103.z.string().optional()
 }).transform((data) => {
   if (data.personalizedId && !data.subscriptionId) {
     return {
@@ -7196,24 +7309,24 @@ var UnsubscribeStreamPayloadSchema = import_zod101.z.object({
   }
   return data;
 }).optional();
-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"),
+var UpdateStreamPayloadSchema = import_zod103.z.object({
+  subscriptionId: import_zod103.z.string(),
+  authorization: import_zod103.z.string(),
+  mode: import_zod103.z.enum(["merge", "replace"]).default("replace"),
   filters: Filter_default.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()
+  chainIds: import_zod103.z.array(import_zod103.z.string()).optional(),
+  events: import_zod103.z.array(import_zod103.z.string()).optional(),
+  subscriptionTracking: import_zod103.z.string().optional()
 });
 // src/wss/TokenDetailsPayloadSchema.ts
-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()
+var import_zod104 = require("zod");
+var TokenDetailsPayloadSchema = import_zod104.z.object({
+  tokens: import_zod104.z.array(import_zod104.z.object({
+    address: import_zod104.z.string(),
+    blockchain: import_zod104.z.string()
   })),
-  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)
+  subscriptionId: import_zod104.z.string().optional(),
+  subscriptionTracking: import_zod104.z.union([import_zod104.z.boolean(), import_zod104.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 
-//# debugId=C3F75296A2CCEE0E64756E2164756E21
+//# debugId=E7DF349132AB53D264756E2164756E21