@mobula_labs/types 0.1.2 → 0.1.4

package/dist/cjs/index.cjs

@@ -1226,6 +1226,7 @@ var require_dist = __commonJS((exports2) => {
 var exports_src = {};
 __export(exports_src, {
   walletSchema: () => walletSchema,
+  updateWebhookResponseSchema: () => updateWebhookResponseSchema,
   updatePoolMessageSchema: () => updatePoolMessageSchema,
   tokenHoldingSchema: () => tokenHoldingSchema,
   tokenDataSchema: () => tokenDataSchema,
@@ -1241,6 +1242,8 @@ __export(exports_src, {
   nonNumericPoolValues: () => nonNumericPoolValues,
   newPoolMessageSchema: () => newPoolMessageSchema,
   logoUrlSchema: () => logoUrlSchema,
+  listWebhooksQueryParams: () => listWebhooksQueryParams,
+  listWebhookResponseSchema: () => listWebhookResponseSchema,
   keysToRemoveTokenToPulse: () => keysToRemoveTokenToPulse,
   keysToRemovePoolToPulse: () => keysToRemovePoolToPulse,
   getZodSchemaKeys: () => getZodSchemaKeys,
@@ -1254,10 +1257,14 @@ __export(exports_src, {
   formattedJSONSchema: () => formattedJSONSchema,
   extractZodSchemaKeys: () => extractZodSchemaKeys,
   extractAllZodKeys: () => extractAllZodKeys,
+  deleteWebhookResponseSchema: () => deleteWebhookResponseSchema,
+  deleteWebhookParams: () => deleteWebhookParams,
   dateFields: () => dateFields,
   createFeedQuery: () => createFeedQuery,
+  countOperations: () => countOperations,
   bigintAbs: () => bigintAbs,
   batchPositionItemSchema: () => batchPositionItemSchema,
+  WebhookResponseSchema: () => WebhookResponseSchema,
   WebSocketMessageSchema: () => WebSocketMessageSchema,
   WalletV2DeployerResponseSchema: () => WalletV2DeployerResponseSchema,
   WalletV2DeployerParamsSchema: () => WalletV2DeployerParamsSchema,
@@ -1297,6 +1304,7 @@ __export(exports_src, {
   WalletActivityV2ParamsSchema: () => WalletActivityV2ParamsSchema,
   WalletActivityV2OutputPaginationSchema: () => WalletActivityV2OutputPaginationSchema,
   WalletActivityV2OutputDataSchema: () => WalletActivityV2OutputDataSchema,
+  UpdateWebhook: () => UpdateWebhook,
   UpdateStreamPayloadSchema: () => UpdateStreamPayloadSchema,
   UnsubscribeStreamPayloadSchema: () => UnsubscribeStreamPayloadSchema,
   TokenTypeValues: () => TokenTypeValues,
@@ -1312,6 +1320,10 @@ __export(exports_src, {
   TokenSecurityQuery: () => TokenSecurityQuery,
   TokenSecurityParamsSchema: () => TokenSecurityQuery,
   TokenSecurityOutput: () => TokenSecurityOutput,
+  TokenPriceResponseSchema: () => TokenPriceResponseSchema,
+  TokenPriceParamsSchema: () => TokenPriceParamsSchema,
+  TokenPriceBatchResponseSchema: () => TokenPriceBatchResponseSchema,
+  TokenPriceBatchParamsSchema: () => TokenPriceBatchParamsSchema,
   TokenPositionsResponseSchema: () => TokenPositionsResponseSchema,
   TokenPositionsParamsSchema: () => TokenPositionsParamsSchema,
   TokenPositionOutput: () => TokenPositionOutput,
@@ -1461,6 +1473,8 @@ __export(exports_src, {
   DEFAULT_CURRENCY: () => DEFAULT_CURRENCY,
   CurrenciesParamSchema: () => CurrenciesParamSchema,
   CryptoNewsDataSchema: () => CryptoNewsDataSchema,
+  CreateWebhookResponseSchema: () => CreateWebhookResponseSchema,
+  CreateWebhook: () => CreateWebhook,
   BlockchainsResponseSchema: () => BlockchainsResponseSchema,
   BlockQueryParamsSchema: () => BlockQueryParamsSchema,
   BalancePayloadSchema: () => BalancePayloadSchema,
@@ -2584,6 +2598,12 @@ var FundingRateResponseSchema = import_zod10.z.object({
       epochDurationMs: import_zod10.z.number()
     }))
   ]).optional(),
+  gateFundingRate: import_zod10.z.object({
+    symbol: import_zod10.z.string(),
+    fundingTime: import_zod10.z.number(),
+    fundingRate: import_zod10.z.number(),
+    epochDurationMs: import_zod10.z.number()
+  }).optional(),
   queryDetails: import_zod10.z.object({
     base: import_zod10.z.string(),
     quote: import_zod10.z.string().nullable()
@@ -3006,7 +3026,11 @@ var MarketMultiPricesResponseSchema = import_zod21.z.object({
     price: import_zod21.z.number().nullable(),
     name: import_zod21.z.string().nullable(),
     symbol: import_zod21.z.string().nullable(),
-    logo: import_zod21.z.string().nullable()
+    logo: import_zod21.z.string().nullable(),
+    marketCap: import_zod21.z.number().nullable(),
+    marketCapDiluted: import_zod21.z.number().nullable(),
+    liquidity: import_zod21.z.number().nullable(),
+    liquidityMax: import_zod21.z.number().nullable()
   }))
 });
 // src/v1/market/MarketNftSchema.ts
@@ -4277,7 +4301,9 @@ var PortfolioResponseSchema = import_zod47.z.object({
         chainId: import_zod47.z.string(),
         decimals: import_zod47.z.number(),
         tokenType: WalletTokenTypeSchema,
-        security: ContractBalanceSecuritySchema
+        security: ContractBalanceSecuritySchema,
+        lamports: import_zod47.z.string().nullable().optional(),
+        tokenAccount: import_zod47.z.string().nullable().optional()
       })),
       cross_chain_balances: import_zod47.z.record(import_zod47.z.string(), import_zod47.z.object({
         balance: import_zod47.z.number(),
@@ -4383,7 +4409,9 @@ var MultiPortfolioResponseSchema = import_zod47.z.object({
         chainId: import_zod47.z.string(),
         decimals: import_zod47.z.number(),
         tokenType: WalletTokenTypeSchema,
-        security: ContractBalanceSecuritySchema
+        security: ContractBalanceSecuritySchema,
+        lamports: import_zod47.z.string().nullable().optional(),
+        tokenAccount: import_zod47.z.string().nullable().optional()
       })),
       cross_chain_balances: import_zod47.z.record(import_zod47.z.string(), import_zod47.z.object({
         balance: import_zod47.z.number(),
@@ -4816,88 +4844,182 @@ var WalletNFTTransactionsResponseSchema = import_zod50.z.object({
     limit: import_zod50.z.number()
   }).nullable()
 }).strict();
-// src/v2/asset/AssetDetailsSchema.ts
+// src/v1/webhook/WebhookSchema.ts
 var import_zod51 = require("zod");
-var AssetTokenDetailsOutput = TokenDetailsOutput;
-var AssetDataOutput = import_zod51.z.object({
-  id: import_zod51.z.number(),
+var BaseFilter = import_zod51.z.object({
+  eq: import_zod51.z.tuple([import_zod51.z.string(), import_zod51.z.union([import_zod51.z.string(), import_zod51.z.number(), import_zod51.z.boolean(), import_zod51.z.null()])]).optional(),
+  neq: import_zod51.z.tuple([import_zod51.z.string(), import_zod51.z.union([import_zod51.z.string(), import_zod51.z.number(), import_zod51.z.boolean(), import_zod51.z.null()])]).optional(),
+  lt: import_zod51.z.tuple([import_zod51.z.string(), import_zod51.z.coerce.number()]).optional(),
+  lte: import_zod51.z.tuple([import_zod51.z.string(), import_zod51.z.coerce.number()]).optional(),
+  gt: import_zod51.z.tuple([import_zod51.z.string(), import_zod51.z.coerce.number()]).optional(),
+  gte: import_zod51.z.tuple([import_zod51.z.string(), import_zod51.z.coerce.number()]).optional(),
+  in: import_zod51.z.tuple([import_zod51.z.string(), import_zod51.z.union([import_zod51.z.string(), import_zod51.z.number(), import_zod51.z.boolean(), import_zod51.z.null()])]).optional()
+});
+var Filter = BaseFilter.and(import_zod51.z.union([
+  BaseFilter.extend({ and: import_zod51.z.undefined(), or: import_zod51.z.undefined() }),
+  BaseFilter.extend({ and: import_zod51.z.array(import_zod51.z.lazy(() => Filter)), or: import_zod51.z.undefined() }),
+  BaseFilter.extend({ and: import_zod51.z.undefined(), or: import_zod51.z.array(import_zod51.z.lazy(() => Filter)) })
+]));
+function countOperations(filter) {
+  if (!filter)
+    return 0;
+  let count = 0;
+  for (const key of ["eq", "neq", "lt", "lte", "gt", "gte", "in"]) {
+    if (filter[key])
+      count += 1;
+  }
+  if ("and" in filter && Array.isArray(filter.and)) {
+    for (const child of filter.and) {
+      count += countOperations(child);
+    }
+  }
+  if ("or" in filter && Array.isArray(filter.or)) {
+    for (const child of filter.or) {
+      count += countOperations(child);
+    }
+  }
+  return count;
+}
+var FilterWithLimit = Filter.superRefine((val, ctx) => {
+  const total = countOperations(val);
+  const max = 1000;
+  if (total > max) {
+    ctx.addIssue({
+      code: import_zod51.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.`
+    });
+  }
+});
+var UpdateWebhook = import_zod51.z.object({
+  streamId: import_zod51.z.string(),
+  apiKey: import_zod51.z.string(),
+  mode: import_zod51.z.enum(["replace", "merge"]).default("replace"),
+  filters: FilterWithLimit.optional()
+});
+var CreateWebhook = import_zod51.z.object({
   name: import_zod51.z.string(),
-  symbol: import_zod51.z.string(),
-  logo: import_zod51.z.string().nullable(),
-  description: import_zod51.z.string().nullable(),
-  rank: import_zod51.z.number().nullable(),
-  nativeChainId: import_zod51.z.string().nullable(),
-  priceUSD: import_zod51.z.number().nullable(),
-  totalSupply: import_zod51.z.number().default(0),
-  circulatingSupply: import_zod51.z.number().default(0),
-  marketCapUSD: import_zod51.z.number().default(0),
-  marketCapDilutedUSD: import_zod51.z.number().default(0),
-  athPriceDate: import_zod51.z.coerce.date().nullable(),
-  athPriceUSD: import_zod51.z.number().nullable(),
-  atlPriceDate: import_zod51.z.coerce.date().nullable(),
-  atlPriceUSD: import_zod51.z.number().nullable(),
-  isStablecoin: import_zod51.z.boolean().default(false),
-  createdAt: import_zod51.z.coerce.date(),
-  listedAt: import_zod51.z.coerce.date().nullable(),
-  socials: import_zod51.z.object({
-    audit: import_zod51.z.string().nullable(),
-    github: import_zod51.z.string().nullable(),
-    twitter: import_zod51.z.string().nullable(),
-    website: import_zod51.z.string().nullable(),
-    kyc: import_zod51.z.string().nullable(),
-    chat: import_zod51.z.string().nullable(),
-    discord: import_zod51.z.string().nullable()
+  chainIds: import_zod51.z.array(import_zod51.z.string()),
+  events: import_zod51.z.array(import_zod51.z.string()),
+  apiKey: import_zod51.z.string(),
+  filters: FilterWithLimit.optional(),
+  url: import_zod51.z.string().url()
+}).strict();
+var listWebhooksQueryParams = import_zod51.z.object({
+  apiKey: import_zod51.z.string().trim().min(1, { message: "API key is required" })
+});
+var deleteWebhookParams = import_zod51.z.object({
+  id: import_zod51.z.string().trim().min(1, { message: "Webhook ID is required" })
+});
+var WebhookResponseSchema = import_zod51.z.object({
+  id: import_zod51.z.string(),
+  name: import_zod51.z.string(),
+  chainIds: import_zod51.z.array(import_zod51.z.string()),
+  events: import_zod51.z.array(import_zod51.z.string()),
+  filters: import_zod51.z.any().nullable().optional(),
+  webhookUrl: import_zod51.z.string().url(),
+  apiKey: import_zod51.z.string(),
+  createdAt: import_zod51.z.union([import_zod51.z.string(), import_zod51.z.date()]).transform((val) => val instanceof Date ? val.toISOString() : val)
+});
+var CreateWebhookResponseSchema = WebhookResponseSchema.extend({
+  webhookSecret: import_zod51.z.string()
+});
+var listWebhookResponseSchema = import_zod51.z.object({
+  success: import_zod51.z.boolean(),
+  count: import_zod51.z.number(),
+  data: import_zod51.z.array(WebhookResponseSchema)
+});
+var updateWebhookResponseSchema = import_zod51.z.object({
+  success: import_zod51.z.boolean(),
+  message: import_zod51.z.string(),
+  data: WebhookResponseSchema
+});
+var deleteWebhookResponseSchema = import_zod51.z.object({
+  success: import_zod51.z.boolean(),
+  message: import_zod51.z.string(),
+  id: import_zod51.z.string()
+});
+// src/v2/asset/AssetDetailsSchema.ts
+var import_zod52 = require("zod");
+var AssetTokenDetailsOutput = TokenDetailsOutput;
+var AssetDataOutput = import_zod52.z.object({
+  id: import_zod52.z.number(),
+  name: import_zod52.z.string(),
+  symbol: import_zod52.z.string(),
+  logo: import_zod52.z.string().nullable(),
+  description: import_zod52.z.string().nullable(),
+  rank: import_zod52.z.number().nullable(),
+  nativeChainId: import_zod52.z.string().nullable(),
+  priceUSD: import_zod52.z.number().nullable(),
+  totalSupply: import_zod52.z.number().default(0),
+  circulatingSupply: import_zod52.z.number().default(0),
+  marketCapUSD: import_zod52.z.number().default(0),
+  marketCapDilutedUSD: import_zod52.z.number().default(0),
+  athPriceDate: import_zod52.z.coerce.date().nullable(),
+  athPriceUSD: import_zod52.z.number().nullable(),
+  atlPriceDate: import_zod52.z.coerce.date().nullable(),
+  atlPriceUSD: import_zod52.z.number().nullable(),
+  isStablecoin: import_zod52.z.boolean().default(false),
+  createdAt: import_zod52.z.coerce.date(),
+  listedAt: import_zod52.z.coerce.date().nullable(),
+  socials: import_zod52.z.object({
+    audit: import_zod52.z.string().nullable(),
+    github: import_zod52.z.string().nullable(),
+    twitter: import_zod52.z.string().nullable(),
+    website: import_zod52.z.string().nullable(),
+    kyc: import_zod52.z.string().nullable(),
+    chat: import_zod52.z.string().nullable(),
+    discord: import_zod52.z.string().nullable()
   }).nullable()
 });
-var AssetDetailsDataOutput = import_zod51.z.object({
+var AssetDetailsDataOutput = import_zod52.z.object({
   asset: AssetDataOutput,
-  tokens: import_zod51.z.array(TokenDetailsOutput.or(import_zod51.z.object({ error: import_zod51.z.string().optional() })).nullable()),
-  tokensCount: import_zod51.z.number()
-});
-var AssetDetailsParamsSchema = import_zod51.z.object({
-  id: import_zod51.z.coerce.number().optional(),
-  address: import_zod51.z.string().optional(),
-  blockchain: import_zod51.z.string().optional(),
-  tokensLimit: import_zod51.z.coerce.number().min(1).max(50).default(10),
-  instanceTracking: import_zod51.z.preprocess((val) => {
+  tokens: import_zod52.z.array(TokenDetailsOutput.or(import_zod52.z.object({ error: import_zod52.z.string().optional() })).nullable()),
+  tokensCount: import_zod52.z.number()
+});
+var AssetDetailsParamsSchema = import_zod52.z.object({
+  id: import_zod52.z.coerce.number().optional(),
+  address: import_zod52.z.string().optional(),
+  blockchain: import_zod52.z.string().optional(),
+  tokensLimit: import_zod52.z.coerce.number().min(1).max(50).default(10),
+  instanceTracking: import_zod52.z.preprocess((val) => {
     if (val === "true")
       return true;
     if (val === "false")
       return false;
     return val;
-  }, import_zod51.z.boolean().optional())
+  }, import_zod52.z.boolean().optional())
 }).refine((data) => data.id !== undefined || data.address !== undefined && data.blockchain !== undefined, {
   message: "Either id OR (address AND blockchain) must be provided"
 });
-var AssetDetailsResponseSchema = import_zod51.z.object({
+var AssetDetailsResponseSchema = import_zod52.z.object({
   data: AssetDetailsDataOutput,
-  hostname: import_zod51.z.string().optional()
+  hostname: import_zod52.z.string().optional()
 });
-var AssetDetailsItemSchema = import_zod51.z.object({
-  id: import_zod51.z.coerce.number().optional(),
-  address: import_zod51.z.string().optional(),
-  blockchain: import_zod51.z.string().optional(),
-  tokensLimit: import_zod51.z.coerce.number().min(1).max(50).default(10)
+var AssetDetailsItemSchema = import_zod52.z.object({
+  id: import_zod52.z.coerce.number().optional(),
+  address: import_zod52.z.string().optional(),
+  blockchain: import_zod52.z.string().optional(),
+  tokensLimit: import_zod52.z.coerce.number().min(1).max(50).default(10)
 });
-var AssetDetailsBatchParamsSchema = import_zod51.z.array(AssetDetailsItemSchema).min(1, "At least one asset is required").max(10, "Maximum 10 assets per request");
-var AssetDetailsBatchResponseSchema = import_zod51.z.object({
-  payload: import_zod51.z.array(AssetDetailsDataOutput.or(import_zod51.z.object({ error: import_zod51.z.string().optional() })).nullable()),
-  hostname: import_zod51.z.string().optional()
+var AssetDetailsBatchParamsSchema = import_zod52.z.array(AssetDetailsItemSchema).min(1, "At least one asset is required").max(10, "Maximum 10 assets per request");
+var AssetDetailsBatchResponseSchema = import_zod52.z.object({
+  payload: import_zod52.z.array(AssetDetailsDataOutput.or(import_zod52.z.object({ error: import_zod52.z.string().optional() })).nullable()),
+  hostname: import_zod52.z.string().optional()
 });
 // src/v2/asset/AssetPriceHistorySchema.ts
-var import_zod52 = require("zod");
-var AssetPriceHistoryItemSchema = import_zod52.z.object({
-  address: import_zod52.z.string().optional(),
-  chainId: import_zod52.z.string().optional(),
-  id: import_zod52.z.coerce.number().optional(),
-  period: import_zod52.z.string().optional().transform((val) => {
+var import_zod53 = require("zod");
+var AssetPriceHistoryItemSchema = import_zod53.z.object({
+  address: import_zod53.z.string().optional(),
+  chainId: import_zod53.z.string().optional(),
+  id: import_zod53.z.coerce.number().optional(),
+  period: import_zod53.z.string().optional().transform((val) => {
     if (val) {
       return normalizePeriod(val);
     }
     return;
   }),
-  from: import_zod52.z.coerce.number().default(0),
-  to: import_zod52.z.coerce.number().default(Date.now)
+  from: import_zod53.z.coerce.number().default(0),
+  to: import_zod53.z.coerce.number().default(Date.now)
 });
 var AssetPriceHistoryParamsSchema = AssetPriceHistoryItemSchema.refine((data) => {
   return data.id !== undefined || data.address !== undefined;
@@ -4911,7 +5033,7 @@ var AssetPriceHistoryParamsSchema = AssetPriceHistoryItemSchema.refine((data) =>
 }, {
   message: "chainId is required when using address"
 });
-var AssetPriceHistoryArraySchema = import_zod52.z.array(AssetPriceHistoryItemSchema).min(1, "At least one asset is required").max(10, "Maximum 10 assets per request").refine((assets) => {
+var AssetPriceHistoryArraySchema = import_zod53.z.array(AssetPriceHistoryItemSchema).min(1, "At least one asset is required").max(10, "Maximum 10 assets per request").refine((assets) => {
   return assets.every((asset) => asset.id !== undefined || asset.address !== undefined);
 }, {
   message: "Each asset must have either id or address"
@@ -4925,312 +5047,312 @@ var AssetPriceHistoryArraySchema = import_zod52.z.array(AssetPriceHistoryItemSch
 }, {
   message: "chainId is required when using address"
 });
-var AssetPriceHistoryBatchParamsSchema = import_zod52.z.union([
+var AssetPriceHistoryBatchParamsSchema = import_zod53.z.union([
   AssetPriceHistoryArraySchema,
-  import_zod52.z.object({ assets: AssetPriceHistoryArraySchema })
+  import_zod53.z.object({ assets: AssetPriceHistoryArraySchema })
 ]);
-var AssetPriceHistoryDataSchema = import_zod52.z.object({
-  priceHistory: import_zod52.z.array(import_zod52.z.array(import_zod52.z.number().nullable())),
-  id: import_zod52.z.number().optional(),
-  name: import_zod52.z.string().optional(),
-  symbol: import_zod52.z.string().optional(),
-  chainId: import_zod52.z.string().optional(),
-  address: import_zod52.z.string().optional(),
-  error: import_zod52.z.string().optional()
-});
-var AssetPriceHistoryResponseSchema = import_zod52.z.object({
+var AssetPriceHistoryDataSchema = import_zod53.z.object({
+  priceHistory: import_zod53.z.array(import_zod53.z.array(import_zod53.z.number().nullable())),
+  id: import_zod53.z.number().optional(),
+  name: import_zod53.z.string().optional(),
+  symbol: import_zod53.z.string().optional(),
+  chainId: import_zod53.z.string().optional(),
+  address: import_zod53.z.string().optional(),
+  error: import_zod53.z.string().optional()
+});
+var AssetPriceHistoryResponseSchema = import_zod53.z.object({
   data: AssetPriceHistoryDataSchema
 });
-var AssetPriceHistoryBatchResponseSchema = import_zod52.z.object({
-  data: import_zod52.z.array(AssetPriceHistoryDataSchema)
+var AssetPriceHistoryBatchResponseSchema = import_zod53.z.object({
+  data: import_zod53.z.array(AssetPriceHistoryDataSchema)
 });
 // src/v2/explorer/BlockQuerySchema.ts
-var import_zod53 = require("zod");
-var BlockQueryParams = import_zod53.z.object({
-  address: import_zod53.z.string(),
-  blockchain: import_zod53.z.string()
+var import_zod54 = require("zod");
+var BlockQueryParams = import_zod54.z.object({
+  address: import_zod54.z.string(),
+  blockchain: import_zod54.z.string()
 });
 var BlockQueryParamsSchema = BlockQueryParams;
 // src/v2/market/MarketDetailsSchema.ts
-var import_zod56 = require("zod");
+var import_zod57 = require("zod");
 
 // src/utils/schemas/MarketDetailsOutput.ts
-var import_zod55 = require("zod");
+var import_zod56 = require("zod");
 
 // src/v2/perp/PerpModels.ts
-var import_zod54 = require("zod");
-var PerpDataRedisSchemaBase = import_zod54.z.object({
-  markPriceUSD: import_zod54.z.coerce.number().default(0),
-  markPriceQuote: import_zod54.z.coerce.number().default(0),
-  oraclePriceUSD: import_zod54.z.coerce.number().default(0),
-  isDisabled: import_zod54.z.coerce.boolean(),
-  isOpen: import_zod54.z.coerce.boolean(),
-  assetClass: import_zod54.z.string().transform((value) => !value ? "crypto" : value),
-  spreadPercentage: import_zod54.z.coerce.number().default(0),
-  fundingFeeShort1hPercentage: import_zod54.z.coerce.number().default(0),
-  totalFeeShort1hPercentage: import_zod54.z.coerce.number().default(0),
-  fundingFeeLong1hPercentage: import_zod54.z.coerce.number().default(0),
-  totalFeeLong1hPercentage: import_zod54.z.coerce.number().default(0),
-  fundingFeeShort8hPercentage: import_zod54.z.coerce.number().default(0),
-  totalFeeShort8hPercentage: import_zod54.z.coerce.number().default(0),
-  fundingFeeLong8hPercentage: import_zod54.z.coerce.number().default(0),
-  totalFeeLong8hPercentage: import_zod54.z.coerce.number().default(0),
-  fundingFeeShort24hPercentage: import_zod54.z.coerce.number().default(0),
-  totalFeeShort24hPercentage: import_zod54.z.coerce.number().default(0),
-  fundingFeeLong24hPercentage: import_zod54.z.coerce.number().default(0),
-  totalFeeLong24hPercentage: import_zod54.z.coerce.number().default(0),
-  fundingFeeShort1yPercentage: import_zod54.z.coerce.number().default(0),
-  totalFeeShort1yPercentage: import_zod54.z.coerce.number().default(0),
-  fundingFeeLong1yPercentage: import_zod54.z.coerce.number().default(0),
-  totalFeeLong1yPercentage: import_zod54.z.coerce.number().default(0),
-  collateral: import_zod54.z.string().optional(),
-  marketId: import_zod54.z.string()
+var import_zod55 = require("zod");
+var PerpDataRedisSchemaBase = import_zod55.z.object({
+  markPriceUSD: import_zod55.z.coerce.number().default(0),
+  markPriceQuote: import_zod55.z.coerce.number().default(0),
+  oraclePriceUSD: import_zod55.z.coerce.number().default(0),
+  isDisabled: import_zod55.z.coerce.boolean(),
+  isOpen: import_zod55.z.coerce.boolean(),
+  assetClass: import_zod55.z.string().transform((value) => !value ? "crypto" : value),
+  spreadPercentage: import_zod55.z.coerce.number().default(0),
+  fundingFeeShort1hPercentage: import_zod55.z.coerce.number().default(0),
+  totalFeeShort1hPercentage: import_zod55.z.coerce.number().default(0),
+  fundingFeeLong1hPercentage: import_zod55.z.coerce.number().default(0),
+  totalFeeLong1hPercentage: import_zod55.z.coerce.number().default(0),
+  fundingFeeShort8hPercentage: import_zod55.z.coerce.number().default(0),
+  totalFeeShort8hPercentage: import_zod55.z.coerce.number().default(0),
+  fundingFeeLong8hPercentage: import_zod55.z.coerce.number().default(0),
+  totalFeeLong8hPercentage: import_zod55.z.coerce.number().default(0),
+  fundingFeeShort24hPercentage: import_zod55.z.coerce.number().default(0),
+  totalFeeShort24hPercentage: import_zod55.z.coerce.number().default(0),
+  fundingFeeLong24hPercentage: import_zod55.z.coerce.number().default(0),
+  totalFeeLong24hPercentage: import_zod55.z.coerce.number().default(0),
+  fundingFeeShort1yPercentage: import_zod55.z.coerce.number().default(0),
+  totalFeeShort1yPercentage: import_zod55.z.coerce.number().default(0),
+  fundingFeeLong1yPercentage: import_zod55.z.coerce.number().default(0),
+  totalFeeLong1yPercentage: import_zod55.z.coerce.number().default(0),
+  collateral: import_zod55.z.string().optional(),
+  marketId: import_zod55.z.string()
 });
 var PerpDataRedisSchemaFlatten = PerpDataRedisSchemaBase.extend({
-  oiCollateral_oiLong: import_zod54.z.coerce.number().default(0),
-  oiCollateral_oiShort: import_zod54.z.coerce.number().default(0),
-  oiCollateral_max: import_zod54.z.coerce.number().optional(),
-  leverage_min: import_zod54.z.coerce.number().default(0),
-  leverage_max: import_zod54.z.coerce.number().default(0),
-  defaultTradingFees_makerFeeBps: import_zod54.z.coerce.number().default(0),
-  defaultTradingFees_takerFeeBps: import_zod54.z.coerce.number().default(0),
-  liquidationParams_maxLiqSpreadPercentage: import_zod54.z.coerce.number().default(0),
-  liquidationParams_startLiqThresholdPercentage: import_zod54.z.coerce.number().default(0),
-  liquidationParams_endLiqThresholdPercentage: import_zod54.z.coerce.number().default(0),
-  liquidationParams_startLeverage: import_zod54.z.coerce.number().default(0),
-  liquidationParams_endLeverage: import_zod54.z.coerce.number().default(0)
+  oiCollateral_oiLong: import_zod55.z.coerce.number().default(0),
+  oiCollateral_oiShort: import_zod55.z.coerce.number().default(0),
+  oiCollateral_max: import_zod55.z.coerce.number().optional(),
+  leverage_min: import_zod55.z.coerce.number().default(0),
+  leverage_max: import_zod55.z.coerce.number().default(0),
+  defaultTradingFees_makerFeeBps: import_zod55.z.coerce.number().default(0),
+  defaultTradingFees_takerFeeBps: import_zod55.z.coerce.number().default(0),
+  liquidationParams_maxLiqSpreadPercentage: import_zod55.z.coerce.number().default(0),
+  liquidationParams_startLiqThresholdPercentage: import_zod55.z.coerce.number().default(0),
+  liquidationParams_endLiqThresholdPercentage: import_zod55.z.coerce.number().default(0),
+  liquidationParams_startLeverage: import_zod55.z.coerce.number().default(0),
+  liquidationParams_endLeverage: import_zod55.z.coerce.number().default(0)
 });
 var PerpDataRedisSchemaNested = PerpDataRedisSchemaBase.extend({
-  defaultTradingFees: import_zod54.z.object({
-    makerFeeBps: import_zod54.z.number().default(0),
-    takerFeeBps: import_zod54.z.number().default(0)
+  defaultTradingFees: import_zod55.z.object({
+    makerFeeBps: import_zod55.z.number().default(0),
+    takerFeeBps: import_zod55.z.number().default(0)
   }),
-  oiCollateral: import_zod54.z.object({
-    oiLong: import_zod54.z.number().default(0),
-    oiShort: import_zod54.z.number().default(0),
-    max: import_zod54.z.number().optional()
+  oiCollateral: import_zod55.z.object({
+    oiLong: import_zod55.z.number().default(0),
+    oiShort: import_zod55.z.number().default(0),
+    max: import_zod55.z.number().optional()
   }),
-  leverage: import_zod54.z.object({
-    min: import_zod54.z.number().default(0),
-    max: import_zod54.z.number().default(0)
+  leverage: import_zod55.z.object({
+    min: import_zod55.z.number().default(0),
+    max: import_zod55.z.number().default(0)
   }),
-  liquidationParams: import_zod54.z.object({
-    maxLiqSpreadPercentage: import_zod54.z.number().default(0),
-    startLiqThresholdPercentage: import_zod54.z.number().default(0),
-    endLiqThresholdPercentage: import_zod54.z.number().default(0),
-    startLeverage: import_zod54.z.number().default(0),
-    endLeverage: import_zod54.z.number().default(0)
+  liquidationParams: import_zod55.z.object({
+    maxLiqSpreadPercentage: import_zod55.z.number().default(0),
+    startLiqThresholdPercentage: import_zod55.z.number().default(0),
+    endLiqThresholdPercentage: import_zod55.z.number().default(0),
+    startLeverage: import_zod55.z.number().default(0),
+    endLeverage: import_zod55.z.number().default(0)
   })
 });
 var PerpDataMarketDetailsOutputSchema = PerpDataRedisSchemaNested.omit({ oiCollateral: true }).extend({
-  openInterest: import_zod54.z.object({
-    longUSD: import_zod54.z.number().default(0),
-    longQuoteToken: import_zod54.z.number().default(0),
-    shortUSD: import_zod54.z.number().default(0),
-    shortQuoteToken: import_zod54.z.number().default(0),
-    maxUSD: import_zod54.z.number().optional(),
-    maxQuoteToken: import_zod54.z.number().optional()
+  openInterest: import_zod55.z.object({
+    longUSD: import_zod55.z.number().default(0),
+    longQuoteToken: import_zod55.z.number().default(0),
+    shortUSD: import_zod55.z.number().default(0),
+    shortQuoteToken: import_zod55.z.number().default(0),
+    maxUSD: import_zod55.z.number().optional(),
+    maxQuoteToken: import_zod55.z.number().optional()
   })
 });
 
 // src/utils/schemas/MarketDetailsOutput.ts
-var TokenDetailsSchema = import_zod55.z.object({
-  address: import_zod55.z.string(),
-  chainId: import_zod55.z.string(),
-  symbol: import_zod55.z.string().nullable(),
-  name: import_zod55.z.string().nullable(),
-  decimals: import_zod55.z.coerce.number().default(0),
-  id: import_zod55.z.number().nullable().optional().default(null),
-  priceUSD: import_zod55.z.coerce.number().default(0),
-  priceToken: import_zod55.z.coerce.number().default(0),
-  priceTokenString: import_zod55.z.string(),
-  approximateReserveUSD: import_zod55.z.coerce.number().default(0),
-  approximateReserveTokenRaw: import_zod55.z.string(),
-  approximateReserveToken: import_zod55.z.coerce.number().default(0),
-  totalSupply: import_zod55.z.coerce.number().default(0),
-  circulatingSupply: import_zod55.z.coerce.number().default(0),
-  marketCapUSD: import_zod55.z.coerce.number().optional().default(0),
-  marketCapDilutedUSD: import_zod55.z.coerce.number().optional().default(0),
-  logo: import_zod55.z.string().nullable(),
-  exchange: import_zod55.z.object({
-    name: import_zod55.z.string(),
-    logo: import_zod55.z.string()
+var TokenDetailsSchema = import_zod56.z.object({
+  address: import_zod56.z.string(),
+  chainId: import_zod56.z.string(),
+  symbol: import_zod56.z.string().nullable(),
+  name: import_zod56.z.string().nullable(),
+  decimals: import_zod56.z.coerce.number().default(0),
+  id: import_zod56.z.number().nullable().optional().default(null),
+  priceUSD: import_zod56.z.coerce.number().default(0),
+  priceToken: import_zod56.z.coerce.number().default(0),
+  priceTokenString: import_zod56.z.string(),
+  approximateReserveUSD: import_zod56.z.coerce.number().default(0),
+  approximateReserveTokenRaw: import_zod56.z.string(),
+  approximateReserveToken: import_zod56.z.coerce.number().default(0),
+  totalSupply: import_zod56.z.coerce.number().default(0),
+  circulatingSupply: import_zod56.z.coerce.number().default(0),
+  marketCapUSD: import_zod56.z.coerce.number().optional().default(0),
+  marketCapDilutedUSD: import_zod56.z.coerce.number().optional().default(0),
+  logo: import_zod56.z.string().nullable(),
+  exchange: import_zod56.z.object({
+    name: import_zod56.z.string(),
+    logo: import_zod56.z.string()
   }).optional(),
-  factory: import_zod55.z.string().nullable().optional(),
-  source: import_zod55.z.string().nullable().optional(),
-  sourceFactory: import_zod55.z.string().nullable().optional(),
-  liquidityUSD: import_zod55.z.coerce.number().optional(),
-  liquidityMaxUSD: import_zod55.z.coerce.number().optional(),
-  bonded: import_zod55.z.boolean().optional(),
-  bondingPercentage: import_zod55.z.coerce.number().optional(),
-  bondingCurveAddress: import_zod55.z.string().nullable().optional(),
-  preBondingFactory: import_zod55.z.string().optional(),
-  poolAddress: import_zod55.z.string().optional(),
-  blockchain: import_zod55.z.string().optional(),
-  type: import_zod55.z.string().optional(),
-  deployer: import_zod55.z.string().nullable().optional(),
-  createdAt: import_zod55.z.coerce.string().optional(),
-  bondedAt: import_zod55.z.coerce.date().nullable(),
-  athUSD: import_zod55.z.coerce.number().optional(),
-  atlUSD: import_zod55.z.coerce.number().optional(),
-  athDate: import_zod55.z.coerce.date().optional(),
-  atlDate: import_zod55.z.coerce.date().optional()
+  factory: import_zod56.z.string().nullable().optional(),
+  source: import_zod56.z.string().nullable().optional(),
+  sourceFactory: import_zod56.z.string().nullable().optional(),
+  liquidityUSD: import_zod56.z.coerce.number().optional(),
+  liquidityMaxUSD: import_zod56.z.coerce.number().optional(),
+  bonded: import_zod56.z.boolean().optional(),
+  bondingPercentage: import_zod56.z.coerce.number().optional(),
+  bondingCurveAddress: import_zod56.z.string().nullable().optional(),
+  preBondingFactory: import_zod56.z.string().optional(),
+  poolAddress: import_zod56.z.string().optional(),
+  blockchain: import_zod56.z.string().optional(),
+  type: import_zod56.z.string().optional(),
+  deployer: import_zod56.z.string().nullable().optional(),
+  createdAt: import_zod56.z.coerce.string().optional(),
+  bondedAt: import_zod56.z.coerce.date().nullable(),
+  athUSD: import_zod56.z.coerce.number().optional(),
+  atlUSD: import_zod56.z.coerce.number().optional(),
+  athDate: import_zod56.z.coerce.date().optional(),
+  atlDate: import_zod56.z.coerce.date().optional()
 }).merge(HoldersStatsSchema);
-var MarketDetailsOutput = import_zod55.z.object({
+var MarketDetailsOutput = import_zod56.z.object({
   token0: TokenDetailsSchema.optional(),
   token1: TokenDetailsSchema.optional(),
   base: TokenDetailsSchema,
   quote: TokenDetailsSchema,
-  liquidityUSD: import_zod55.z.coerce.number().default(0),
-  latestTradeDate: import_zod55.z.coerce.date().nullable(),
-  blockchain: import_zod55.z.string(),
-  address: import_zod55.z.string(),
-  createdAt: import_zod55.z.coerce.date().nullable(),
-  type: import_zod55.z.string(),
-  exchange: import_zod55.z.object({
-    name: import_zod55.z.string(),
-    logo: import_zod55.z.string()
+  liquidityUSD: import_zod56.z.coerce.number().default(0),
+  latestTradeDate: import_zod56.z.coerce.date().nullable(),
+  blockchain: import_zod56.z.string(),
+  address: import_zod56.z.string(),
+  createdAt: import_zod56.z.coerce.date().nullable(),
+  type: import_zod56.z.string(),
+  exchange: import_zod56.z.object({
+    name: import_zod56.z.string(),
+    logo: import_zod56.z.string()
   }),
-  factory: import_zod55.z.string().nullable(),
-  priceUSD: import_zod55.z.coerce.number().optional(),
-  priceToken: import_zod55.z.coerce.number().optional(),
-  priceTokenString: import_zod55.z.string().optional(),
-  baseToken: import_zod55.z.string(),
-  quoteToken: import_zod55.z.string(),
-  bonded: import_zod55.z.coerce.boolean(),
-  bondingPercentage: import_zod55.z.coerce.number().nullable(),
-  preBondingPoolAddress: import_zod55.z.string().nullable(),
-  sourceFactory: import_zod55.z.string().nullable().optional(),
-  totalFeesPaidUSD: import_zod55.z.coerce.number().nullable(),
-  totalFeesPaidNativeRaw: import_zod55.z.coerce.string().default("0"),
-  priceChange1minPercentage: import_zod55.z.coerce.number().default(0),
-  priceChange5minPercentage: import_zod55.z.coerce.number().default(0),
-  priceChange1hPercentage: import_zod55.z.coerce.number().default(0),
-  priceChange4hPercentage: import_zod55.z.coerce.number().default(0),
-  priceChange6hPercentage: import_zod55.z.coerce.number().default(0),
-  priceChange12hPercentage: import_zod55.z.coerce.number().default(0),
-  priceChange24hPercentage: import_zod55.z.coerce.number().default(0),
-  volume1minUSD: import_zod55.z.coerce.number().default(0),
-  volume5minUSD: import_zod55.z.coerce.number().default(0),
-  volume15minUSD: import_zod55.z.coerce.number().default(0),
-  volume1hUSD: import_zod55.z.coerce.number().default(0),
-  volume4hUSD: import_zod55.z.coerce.number().default(0),
-  volume6hUSD: import_zod55.z.coerce.number().default(0),
-  volume12hUSD: import_zod55.z.coerce.number().default(0),
-  volume24hUSD: import_zod55.z.coerce.number().default(0),
-  volumeBuy1minUSD: import_zod55.z.coerce.number().default(0),
-  volumeBuy5minUSD: import_zod55.z.coerce.number().default(0),
-  volumeBuy15minUSD: import_zod55.z.coerce.number().default(0),
-  volumeBuy1hUSD: import_zod55.z.coerce.number().default(0),
-  volumeBuy4hUSD: import_zod55.z.coerce.number().default(0),
-  volumeBuy6hUSD: import_zod55.z.coerce.number().default(0),
-  volumeBuy12hUSD: import_zod55.z.coerce.number().default(0),
-  volumeBuy24hUSD: import_zod55.z.coerce.number().default(0),
-  volumeSell1minUSD: import_zod55.z.coerce.number().default(0),
-  volumeSell5minUSD: import_zod55.z.coerce.number().default(0),
-  volumeSell15minUSD: import_zod55.z.coerce.number().default(0),
-  volumeSell1hUSD: import_zod55.z.coerce.number().default(0),
-  volumeSell4hUSD: import_zod55.z.coerce.number().default(0),
-  volumeSell6hUSD: import_zod55.z.coerce.number().default(0),
-  volumeSell12hUSD: import_zod55.z.coerce.number().default(0),
-  volumeSell24hUSD: import_zod55.z.coerce.number().default(0),
-  trades1min: import_zod55.z.coerce.number().default(0),
-  trades5min: import_zod55.z.coerce.number().default(0),
-  trades15min: import_zod55.z.coerce.number().default(0),
-  trades1h: import_zod55.z.coerce.number().default(0),
-  trades4h: import_zod55.z.coerce.number().default(0),
-  trades6h: import_zod55.z.coerce.number().default(0),
-  trades12h: import_zod55.z.coerce.number().default(0),
-  trades24h: import_zod55.z.coerce.number().default(0),
-  buys1min: import_zod55.z.coerce.number().default(0),
-  buys5min: import_zod55.z.coerce.number().default(0),
-  buys15min: import_zod55.z.coerce.number().default(0),
-  buys1h: import_zod55.z.coerce.number().default(0),
-  buys4h: import_zod55.z.coerce.number().default(0),
-  buys6h: import_zod55.z.coerce.number().default(0),
-  buys12h: import_zod55.z.coerce.number().default(0),
-  buys24h: import_zod55.z.coerce.number().default(0),
-  sells1min: import_zod55.z.coerce.number().default(0),
-  sells5min: import_zod55.z.coerce.number().default(0),
-  sells15min: import_zod55.z.coerce.number().default(0),
-  sells1h: import_zod55.z.coerce.number().default(0),
-  sells4h: import_zod55.z.coerce.number().default(0),
-  sells6h: import_zod55.z.coerce.number().default(0),
-  sells12h: import_zod55.z.coerce.number().default(0),
-  sells24h: import_zod55.z.coerce.number().default(0),
-  buyers1min: import_zod55.z.coerce.number().default(0),
-  buyers5min: import_zod55.z.coerce.number().default(0),
-  buyers15min: import_zod55.z.coerce.number().default(0),
-  buyers1h: import_zod55.z.coerce.number().default(0),
-  buyers4h: import_zod55.z.coerce.number().default(0),
-  buyers6h: import_zod55.z.coerce.number().default(0),
-  buyers12h: import_zod55.z.coerce.number().default(0),
-  buyers24h: import_zod55.z.coerce.number().default(0),
-  sellers1min: import_zod55.z.coerce.number().default(0),
-  sellers5min: import_zod55.z.coerce.number().default(0),
-  sellers15min: import_zod55.z.coerce.number().default(0),
-  sellers1h: import_zod55.z.coerce.number().default(0),
-  sellers4h: import_zod55.z.coerce.number().default(0),
-  sellers6h: import_zod55.z.coerce.number().default(0),
-  sellers12h: import_zod55.z.coerce.number().default(0),
-  sellers24h: import_zod55.z.coerce.number().default(0),
-  traders1min: import_zod55.z.coerce.number().default(0),
-  traders5min: import_zod55.z.coerce.number().default(0),
-  traders15min: import_zod55.z.coerce.number().default(0),
-  traders1h: import_zod55.z.coerce.number().default(0),
-  traders4h: import_zod55.z.coerce.number().default(0),
-  traders6h: import_zod55.z.coerce.number().default(0),
-  traders12h: import_zod55.z.coerce.number().default(0),
-  traders24h: import_zod55.z.coerce.number().default(0),
-  feesPaid1minUSD: import_zod55.z.coerce.number().default(0),
-  feesPaid5minUSD: import_zod55.z.coerce.number().default(0),
-  feesPaid15minUSD: import_zod55.z.coerce.number().default(0),
-  feesPaid1hUSD: import_zod55.z.coerce.number().default(0),
-  feesPaid4hUSD: import_zod55.z.coerce.number().default(0),
-  feesPaid6hUSD: import_zod55.z.coerce.number().default(0),
-  feesPaid12hUSD: import_zod55.z.coerce.number().default(0),
-  feesPaid24hUSD: import_zod55.z.coerce.number().default(0),
-  holdersCount: import_zod55.z.coerce.number().default(0),
-  source: import_zod55.z.string().nullable(),
-  deployer: import_zod55.z.string().nullable(),
-  tokenSymbol: import_zod55.z.string().nullable(),
-  tokenName: import_zod55.z.string().nullable(),
-  dexscreenerListed: import_zod55.z.coerce.boolean().nullable(),
-  deployerMigrations: import_zod55.z.coerce.number().default(0),
-  socials: import_zod55.z.object({
-    twitter: import_zod55.z.string().nullable(),
-    website: import_zod55.z.string().nullable(),
-    telegram: import_zod55.z.string().nullable(),
-    others: import_zod55.z.record(import_zod55.z.unknown()).nullable(),
-    uri: import_zod55.z.string().optional()
+  factory: import_zod56.z.string().nullable(),
+  priceUSD: import_zod56.z.coerce.number().optional(),
+  priceToken: import_zod56.z.coerce.number().optional(),
+  priceTokenString: import_zod56.z.string().optional(),
+  baseToken: import_zod56.z.string(),
+  quoteToken: import_zod56.z.string(),
+  bonded: import_zod56.z.coerce.boolean(),
+  bondingPercentage: import_zod56.z.coerce.number().nullable(),
+  preBondingPoolAddress: import_zod56.z.string().nullable(),
+  sourceFactory: import_zod56.z.string().nullable().optional(),
+  totalFeesPaidUSD: import_zod56.z.coerce.number().nullable(),
+  totalFeesPaidNativeRaw: import_zod56.z.coerce.string().default("0"),
+  priceChange1minPercentage: import_zod56.z.coerce.number().default(0),
+  priceChange5minPercentage: import_zod56.z.coerce.number().default(0),
+  priceChange1hPercentage: import_zod56.z.coerce.number().default(0),
+  priceChange4hPercentage: import_zod56.z.coerce.number().default(0),
+  priceChange6hPercentage: import_zod56.z.coerce.number().default(0),
+  priceChange12hPercentage: import_zod56.z.coerce.number().default(0),
+  priceChange24hPercentage: import_zod56.z.coerce.number().default(0),
+  volume1minUSD: import_zod56.z.coerce.number().default(0),
+  volume5minUSD: import_zod56.z.coerce.number().default(0),
+  volume15minUSD: import_zod56.z.coerce.number().default(0),
+  volume1hUSD: import_zod56.z.coerce.number().default(0),
+  volume4hUSD: import_zod56.z.coerce.number().default(0),
+  volume6hUSD: import_zod56.z.coerce.number().default(0),
+  volume12hUSD: import_zod56.z.coerce.number().default(0),
+  volume24hUSD: import_zod56.z.coerce.number().default(0),
+  volumeBuy1minUSD: import_zod56.z.coerce.number().default(0),
+  volumeBuy5minUSD: import_zod56.z.coerce.number().default(0),
+  volumeBuy15minUSD: import_zod56.z.coerce.number().default(0),
+  volumeBuy1hUSD: import_zod56.z.coerce.number().default(0),
+  volumeBuy4hUSD: import_zod56.z.coerce.number().default(0),
+  volumeBuy6hUSD: import_zod56.z.coerce.number().default(0),
+  volumeBuy12hUSD: import_zod56.z.coerce.number().default(0),
+  volumeBuy24hUSD: import_zod56.z.coerce.number().default(0),
+  volumeSell1minUSD: import_zod56.z.coerce.number().default(0),
+  volumeSell5minUSD: import_zod56.z.coerce.number().default(0),
+  volumeSell15minUSD: import_zod56.z.coerce.number().default(0),
+  volumeSell1hUSD: import_zod56.z.coerce.number().default(0),
+  volumeSell4hUSD: import_zod56.z.coerce.number().default(0),
+  volumeSell6hUSD: import_zod56.z.coerce.number().default(0),
+  volumeSell12hUSD: import_zod56.z.coerce.number().default(0),
+  volumeSell24hUSD: import_zod56.z.coerce.number().default(0),
+  trades1min: import_zod56.z.coerce.number().default(0),
+  trades5min: import_zod56.z.coerce.number().default(0),
+  trades15min: import_zod56.z.coerce.number().default(0),
+  trades1h: import_zod56.z.coerce.number().default(0),
+  trades4h: import_zod56.z.coerce.number().default(0),
+  trades6h: import_zod56.z.coerce.number().default(0),
+  trades12h: import_zod56.z.coerce.number().default(0),
+  trades24h: import_zod56.z.coerce.number().default(0),
+  buys1min: import_zod56.z.coerce.number().default(0),
+  buys5min: import_zod56.z.coerce.number().default(0),
+  buys15min: import_zod56.z.coerce.number().default(0),
+  buys1h: import_zod56.z.coerce.number().default(0),
+  buys4h: import_zod56.z.coerce.number().default(0),
+  buys6h: import_zod56.z.coerce.number().default(0),
+  buys12h: import_zod56.z.coerce.number().default(0),
+  buys24h: import_zod56.z.coerce.number().default(0),
+  sells1min: import_zod56.z.coerce.number().default(0),
+  sells5min: import_zod56.z.coerce.number().default(0),
+  sells15min: import_zod56.z.coerce.number().default(0),
+  sells1h: import_zod56.z.coerce.number().default(0),
+  sells4h: import_zod56.z.coerce.number().default(0),
+  sells6h: import_zod56.z.coerce.number().default(0),
+  sells12h: import_zod56.z.coerce.number().default(0),
+  sells24h: import_zod56.z.coerce.number().default(0),
+  buyers1min: import_zod56.z.coerce.number().default(0),
+  buyers5min: import_zod56.z.coerce.number().default(0),
+  buyers15min: import_zod56.z.coerce.number().default(0),
+  buyers1h: import_zod56.z.coerce.number().default(0),
+  buyers4h: import_zod56.z.coerce.number().default(0),
+  buyers6h: import_zod56.z.coerce.number().default(0),
+  buyers12h: import_zod56.z.coerce.number().default(0),
+  buyers24h: import_zod56.z.coerce.number().default(0),
+  sellers1min: import_zod56.z.coerce.number().default(0),
+  sellers5min: import_zod56.z.coerce.number().default(0),
+  sellers15min: import_zod56.z.coerce.number().default(0),
+  sellers1h: import_zod56.z.coerce.number().default(0),
+  sellers4h: import_zod56.z.coerce.number().default(0),
+  sellers6h: import_zod56.z.coerce.number().default(0),
+  sellers12h: import_zod56.z.coerce.number().default(0),
+  sellers24h: import_zod56.z.coerce.number().default(0),
+  traders1min: import_zod56.z.coerce.number().default(0),
+  traders5min: import_zod56.z.coerce.number().default(0),
+  traders15min: import_zod56.z.coerce.number().default(0),
+  traders1h: import_zod56.z.coerce.number().default(0),
+  traders4h: import_zod56.z.coerce.number().default(0),
+  traders6h: import_zod56.z.coerce.number().default(0),
+  traders12h: import_zod56.z.coerce.number().default(0),
+  traders24h: import_zod56.z.coerce.number().default(0),
+  feesPaid1minUSD: import_zod56.z.coerce.number().default(0),
+  feesPaid5minUSD: import_zod56.z.coerce.number().default(0),
+  feesPaid15minUSD: import_zod56.z.coerce.number().default(0),
+  feesPaid1hUSD: import_zod56.z.coerce.number().default(0),
+  feesPaid4hUSD: import_zod56.z.coerce.number().default(0),
+  feesPaid6hUSD: import_zod56.z.coerce.number().default(0),
+  feesPaid12hUSD: import_zod56.z.coerce.number().default(0),
+  feesPaid24hUSD: import_zod56.z.coerce.number().default(0),
+  holdersCount: import_zod56.z.coerce.number().default(0),
+  source: import_zod56.z.string().nullable(),
+  deployer: import_zod56.z.string().nullable(),
+  tokenSymbol: import_zod56.z.string().nullable(),
+  tokenName: import_zod56.z.string().nullable(),
+  dexscreenerListed: import_zod56.z.coerce.boolean().nullable(),
+  deployerMigrations: import_zod56.z.coerce.number().default(0),
+  socials: import_zod56.z.object({
+    twitter: import_zod56.z.string().nullable(),
+    website: import_zod56.z.string().nullable(),
+    telegram: import_zod56.z.string().nullable(),
+    others: import_zod56.z.record(import_zod56.z.unknown()).nullable(),
+    uri: import_zod56.z.string().optional()
   }),
-  description: import_zod55.z.string().nullable(),
+  description: import_zod56.z.string().nullable(),
   security: SecurityFlagsSchema.nullable(),
-  twitterReusesCount: import_zod55.z.coerce.number().default(0),
-  twitterRenameCount: import_zod55.z.coerce.number().default(0),
-  twitterRenameHistory: import_zod55.z.array(import_zod55.z.object({
-    username: import_zod55.z.string(),
-    lastChecked: import_zod55.z.string()
+  twitterReusesCount: import_zod56.z.coerce.number().default(0),
+  twitterRenameCount: import_zod56.z.coerce.number().default(0),
+  twitterRenameHistory: import_zod56.z.array(import_zod56.z.object({
+    username: import_zod56.z.string(),
+    lastChecked: import_zod56.z.string()
   })).default([]),
   perpetuals: PerpDataMarketDetailsOutputSchema.optional(),
-  extraData: import_zod55.z.record(import_zod55.z.unknown()).optional()
+  extraData: import_zod56.z.record(import_zod56.z.unknown()).optional()
 }).merge(HoldersStatsSchema);
 
 // src/v2/market/MarketDetailsSchema.ts
-var MarketDetailsItemParams = import_zod56.z.object({
-  blockchain: import_zod56.z.string().optional(),
-  address: import_zod56.z.string().optional(),
-  baseToken: import_zod56.z.string().optional(),
+var MarketDetailsItemParams = import_zod57.z.object({
+  blockchain: import_zod57.z.string().optional(),
+  address: import_zod57.z.string().optional(),
+  baseToken: import_zod57.z.string().optional(),
   currencies: CurrenciesParamSchema,
-  stats: import_zod56.z.union([import_zod56.z.boolean(), import_zod56.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
-  force: import_zod56.z.coerce.boolean().optional().default(false),
-  instanceTracking: import_zod56.z.preprocess((val) => {
+  stats: import_zod57.z.union([import_zod57.z.boolean(), import_zod57.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  force: import_zod57.z.coerce.boolean().optional().default(false),
+  instanceTracking: import_zod57.z.preprocess((val) => {
     if (val === "true")
       return true;
     if (val === "false")
       return false;
     return val;
-  }, import_zod56.z.boolean().optional())
+  }, import_zod57.z.boolean().optional())
 }).transform(({ blockchain, address, baseToken, currencies, stats, force, instanceTracking }) => ({
   blockchain,
   address,
@@ -5242,330 +5364,346 @@ var MarketDetailsItemParams = import_zod56.z.object({
   asset: address ? address : undefined
 }));
 var MarketDetailsParamsSchema = MarketDetailsItemParams;
-var MarketDetailsBatchParamsSchema = import_zod56.z.union([
-  import_zod56.z.array(MarketDetailsItemParams),
-  import_zod56.z.object({
-    items: import_zod56.z.array(MarketDetailsItemParams),
-    instanceTracking: import_zod56.z.preprocess((val) => {
+var MarketDetailsBatchParamsSchema = import_zod57.z.union([
+  import_zod57.z.array(MarketDetailsItemParams),
+  import_zod57.z.object({
+    items: import_zod57.z.array(MarketDetailsItemParams),
+    instanceTracking: import_zod57.z.preprocess((val) => {
       if (val === "true")
         return true;
       if (val === "false")
         return false;
       return val;
-    }, import_zod56.z.boolean().optional())
+    }, import_zod57.z.boolean().optional())
   })
 ]);
-var MarketDetailsResponseSchema = import_zod56.z.object({
+var MarketDetailsResponseSchema = import_zod57.z.object({
   data: MarketDetailsOutput,
-  hostname: import_zod56.z.string().optional()
+  hostname: import_zod57.z.string().optional()
 });
-var MarketDetailsBatchResponseSchema = import_zod56.z.object({
-  payload: import_zod56.z.array(MarketDetailsOutput.or(import_zod56.z.object({ error: import_zod56.z.string().optional() })).nullable()),
-  hostname: import_zod56.z.string().optional()
+var MarketDetailsBatchResponseSchema = import_zod57.z.object({
+  payload: import_zod57.z.array(MarketDetailsOutput.or(import_zod57.z.object({ error: import_zod57.z.string().optional() })).nullable()),
+  hostname: import_zod57.z.string().optional()
 });
 // src/v2/market/MarketOHLCVHistorySchema.ts
-var import_zod57 = require("zod");
-var booleanFromString = import_zod57.z.union([import_zod57.z.boolean(), import_zod57.z.string()]).optional().default(true).transform((val) => {
+var import_zod58 = require("zod");
+var booleanFromString = import_zod58.z.union([import_zod58.z.boolean(), import_zod58.z.string()]).optional().default(true).transform((val) => {
   if (typeof val === "boolean")
     return val;
   if (val === "false" || val === "0")
     return false;
   return true;
 });
-var MarketOHLCVHistoryItemSchema = import_zod57.z.object({
-  address: import_zod57.z.string(),
-  chainId: import_zod57.z.string(),
+var MarketOHLCVHistoryItemSchema = import_zod58.z.object({
+  address: import_zod58.z.string(),
+  chainId: import_zod58.z.string(),
   from: DateQuery_default.transform((val) => val ?? 0),
   to: DateQuery_default.transform((val) => val ?? new Date),
-  period: import_zod57.z.string().optional().transform((val) => val ? normalizePeriod(val) : "5m"),
-  amount: import_zod57.z.coerce.number().optional(),
+  period: import_zod58.z.string().optional().transform((val) => val ? normalizePeriod(val) : "5m"),
+  amount: import_zod58.z.coerce.number().optional(),
   usd: booleanFromString
 });
 var MarketOHLCVHistoryParamsSchema = MarketOHLCVHistoryItemSchema.refine((data) => data.address && data.chainId, { message: "address and chainId are required" });
-var MarketOHLCVHistoryArraySchema = import_zod57.z.array(MarketOHLCVHistoryItemSchema).min(1, "At least one market is required").max(10, "Maximum 10 markets per request");
-var MarketOHLCVHistoryBatchParamsSchema = import_zod57.z.union([
+var MarketOHLCVHistoryArraySchema = import_zod58.z.array(MarketOHLCVHistoryItemSchema).min(1, "At least one market is required").max(10, "Maximum 10 markets per request");
+var MarketOHLCVHistoryBatchParamsSchema = import_zod58.z.union([
   MarketOHLCVHistoryArraySchema,
-  import_zod57.z.object({ markets: MarketOHLCVHistoryArraySchema })
+  import_zod58.z.object({ markets: MarketOHLCVHistoryArraySchema })
 ]);
-var OHLCVCandleSchema = import_zod57.z.object({
-  v: import_zod57.z.number(),
-  o: import_zod57.z.number(),
-  h: import_zod57.z.number(),
-  l: import_zod57.z.number(),
-  c: import_zod57.z.number(),
-  t: import_zod57.z.number()
-});
-var MarketOHLCVHistoryResponseSchema = import_zod57.z.object({
-  data: import_zod57.z.array(OHLCVCandleSchema)
-});
-var MarketOHLCVHistoryDataSchema = import_zod57.z.object({
-  ohlcv: import_zod57.z.array(OHLCVCandleSchema),
-  address: import_zod57.z.string(),
-  chainId: import_zod57.z.string(),
-  error: import_zod57.z.string().optional()
-});
-var MarketOHLCVHistoryBatchResponseSchema = import_zod57.z.object({
-  data: import_zod57.z.array(MarketOHLCVHistoryDataSchema)
+var OHLCVCandleSchema = import_zod58.z.object({
+  v: import_zod58.z.number(),
+  o: import_zod58.z.number(),
+  h: import_zod58.z.number(),
+  l: import_zod58.z.number(),
+  c: import_zod58.z.number(),
+  t: import_zod58.z.number()
+});
+var MarketOHLCVHistoryResponseSchema = import_zod58.z.object({
+  data: import_zod58.z.array(OHLCVCandleSchema)
+});
+var MarketOHLCVHistoryDataSchema = import_zod58.z.object({
+  ohlcv: import_zod58.z.array(OHLCVCandleSchema),
+  address: import_zod58.z.string(),
+  chainId: import_zod58.z.string(),
+  error: import_zod58.z.string().optional()
+});
+var MarketOHLCVHistoryBatchResponseSchema = import_zod58.z.object({
+  data: import_zod58.z.array(MarketOHLCVHistoryDataSchema)
 });
 // src/v2/perp/PerpBlocksSchema.ts
-var import_zod58 = require("zod");
-var PerpBlocksQueryParamsSchema = import_zod58.z.object({
-  exchange: import_zod58.z.string().optional(),
-  chain_id: import_zod58.z.string().optional(),
-  block_number: import_zod58.z.coerce.number().optional(),
-  batch_number: import_zod58.z.coerce.number().optional(),
-  block_status: import_zod58.z.string().optional(),
-  from_block_time: import_zod58.z.string().optional(),
-  to_block_time: import_zod58.z.string().optional(),
-  page: import_zod58.z.coerce.number().min(1).default(1),
-  limit: import_zod58.z.coerce.number().min(1).max(100).default(25)
-});
-var PerpBlockSchema = import_zod58.z.object({
-  exchange: import_zod58.z.string().nullable(),
-  chain_id: import_zod58.z.string().nullable(),
-  block_number: import_zod58.z.number(),
-  batch_number: import_zod58.z.number(),
-  block_status: import_zod58.z.string().nullable(),
-  block_time: import_zod58.z.string(),
-  total_transactions: import_zod58.z.number(),
-  logs_count: import_zod58.z.number(),
-  trades_count: import_zod58.z.number(),
-  commit_tx_hash: import_zod58.z.string().nullable(),
-  verify_tx_hash: import_zod58.z.string().nullable(),
-  execute_tx_hash: import_zod58.z.string().nullable(),
-  scraped_at: import_zod58.z.string()
-});
-var PerpBlocksResponseSchema = import_zod58.z.object({
-  data: import_zod58.z.array(PerpBlockSchema),
-  pagination: import_zod58.z.object({
-    page: import_zod58.z.number(),
-    totalPages: import_zod58.z.number(),
-    totalItems: import_zod58.z.number(),
-    limit: import_zod58.z.number()
+var import_zod59 = require("zod");
+var PerpBlocksQueryParamsSchema = import_zod59.z.object({
+  exchange: import_zod59.z.string().optional(),
+  chain_id: import_zod59.z.string().optional(),
+  block_number: import_zod59.z.coerce.number().optional(),
+  batch_number: import_zod59.z.coerce.number().optional(),
+  block_status: import_zod59.z.string().optional(),
+  from_block_time: import_zod59.z.string().optional(),
+  to_block_time: import_zod59.z.string().optional(),
+  page: import_zod59.z.coerce.number().min(1).default(1),
+  limit: import_zod59.z.coerce.number().min(1).max(100).default(25)
+});
+var PerpBlockSchema = import_zod59.z.object({
+  exchange: import_zod59.z.string().nullable(),
+  chain_id: import_zod59.z.string().nullable(),
+  block_number: import_zod59.z.number(),
+  batch_number: import_zod59.z.number(),
+  block_status: import_zod59.z.string().nullable(),
+  block_time: import_zod59.z.string(),
+  total_transactions: import_zod59.z.number(),
+  logs_count: import_zod59.z.number(),
+  trades_count: import_zod59.z.number(),
+  commit_tx_hash: import_zod59.z.string().nullable(),
+  verify_tx_hash: import_zod59.z.string().nullable(),
+  execute_tx_hash: import_zod59.z.string().nullable(),
+  scraped_at: import_zod59.z.string()
+});
+var PerpBlocksResponseSchema = import_zod59.z.object({
+  data: import_zod59.z.array(PerpBlockSchema),
+  pagination: import_zod59.z.object({
+    page: import_zod59.z.number(),
+    totalPages: import_zod59.z.number(),
+    totalItems: import_zod59.z.number(),
+    limit: import_zod59.z.number()
   })
 });
 // src/v2/perp/PerpOrderQuotingSchema.ts
-var import_zod59 = require("zod");
-var SupportedDexSchema = import_zod59.z.enum(["gains"]);
-var TradeTypeSchema = import_zod59.z.enum(["market", "limit", "stop_limit"]);
-var PerpOrderQuotingParamsSchema = import_zod59.z.object({
-  user: import_zod59.z.string(),
-  baseToken: import_zod59.z.string(),
-  quote: import_zod59.z.string(),
-  leverage: import_zod59.z.coerce.number(),
-  long: import_zod59.z.union([import_zod59.z.boolean(), import_zod59.z.string()]).transform((val) => typeof val === "string" ? val === "true" : val),
-  collateralAmount: import_zod59.z.coerce.number(),
-  openPrice: import_zod59.z.coerce.number().optional(),
-  tp: import_zod59.z.coerce.number().optional(),
-  sl: import_zod59.z.coerce.number().optional(),
+var import_zod60 = require("zod");
+var SupportedDexSchema = import_zod60.z.enum(["gains"]);
+var TradeTypeSchema = import_zod60.z.enum(["market", "limit", "stop_limit"]);
+var PerpOrderQuotingParamsSchema = import_zod60.z.object({
+  user: import_zod60.z.string(),
+  baseToken: import_zod60.z.string(),
+  quote: import_zod60.z.string(),
+  leverage: import_zod60.z.coerce.number(),
+  long: import_zod60.z.union([import_zod60.z.boolean(), import_zod60.z.string()]).transform((val) => typeof val === "string" ? val === "true" : val),
+  collateralAmount: import_zod60.z.coerce.number(),
+  openPrice: import_zod60.z.coerce.number().optional(),
+  tp: import_zod60.z.coerce.number().optional(),
+  sl: import_zod60.z.coerce.number().optional(),
   tradeType: TradeTypeSchema.optional().default("market"),
-  amountRaw: import_zod59.z.coerce.number().optional(),
-  maxSlippageP: import_zod59.z.coerce.number().optional(),
-  chainId: import_zod59.z.string().optional(),
+  amountRaw: import_zod60.z.coerce.number().optional(),
+  maxSlippageP: import_zod60.z.coerce.number().optional(),
+  chainId: import_zod60.z.string().optional(),
   dex: SupportedDexSchema.optional(),
-  referrer: import_zod59.z.string().optional()
+  referrer: import_zod60.z.string().optional()
 });
 // src/v2/swap/SwapQuotingBatchOutput.ts
-var import_zod61 = require("zod");
+var import_zod62 = require("zod");
 
 // src/v2/swap/SwapQuotingOutput.ts
-var import_zod60 = require("zod");
-var SolanaTransactionSchema = import_zod60.z.object({
-  serialized: import_zod60.z.string(),
-  variant: import_zod60.z.enum(["legacy", "versioned"])
-});
-var EVMTransactionSchema = import_zod60.z.object({
-  to: import_zod60.z.string(),
-  from: import_zod60.z.string(),
-  data: import_zod60.z.string(),
-  value: import_zod60.z.string(),
-  gasLimit: import_zod60.z.string().optional(),
-  gasPrice: import_zod60.z.string().optional(),
-  maxFeePerGas: import_zod60.z.string().optional(),
-  maxPriorityFeePerGas: import_zod60.z.string().optional(),
-  nonce: import_zod60.z.number().optional(),
-  chainId: import_zod60.z.number()
-});
-var TokenInfoSchema = import_zod60.z.object({
-  address: import_zod60.z.string(),
-  name: import_zod60.z.string().optional(),
-  symbol: import_zod60.z.string().optional(),
-  decimals: import_zod60.z.number(),
-  logo: import_zod60.z.string().nullable().optional()
-});
-var RouteHopSchema = import_zod60.z.object({
-  poolAddress: import_zod60.z.string(),
+var import_zod_to_openapi2 = __toESM(require_dist(), 1);
+var import_zod61 = require("zod");
+import_zod_to_openapi2.extendZodWithOpenApi(import_zod61.z);
+var SolanaTransactionSchema = import_zod61.z.object({
+  serialized: import_zod61.z.string(),
+  variant: import_zod61.z.enum(["legacy", "versioned"])
+});
+var EVMTransactionSchema = import_zod61.z.object({
+  to: import_zod61.z.string(),
+  from: import_zod61.z.string(),
+  data: import_zod61.z.string(),
+  value: import_zod61.z.string(),
+  gasLimit: import_zod61.z.string().optional(),
+  gasPrice: import_zod61.z.string().optional(),
+  maxFeePerGas: import_zod61.z.string().optional(),
+  maxPriorityFeePerGas: import_zod61.z.string().optional(),
+  nonce: import_zod61.z.number().optional(),
+  chainId: import_zod61.z.number()
+});
+var TokenInfoSchema = import_zod61.z.object({
+  address: import_zod61.z.string(),
+  name: import_zod61.z.string().optional(),
+  symbol: import_zod61.z.string().optional(),
+  decimals: import_zod61.z.number(),
+  logo: import_zod61.z.string().nullable().optional()
+});
+var RouteHopSchema = import_zod61.z.object({
+  poolAddress: import_zod61.z.string(),
   tokenIn: TokenInfoSchema,
   tokenOut: TokenInfoSchema,
-  amountInTokens: import_zod60.z.string(),
-  amountOutTokens: import_zod60.z.string(),
-  exchange: import_zod60.z.string().optional(),
-  poolType: import_zod60.z.string().optional(),
-  feePercentage: import_zod60.z.number().optional(),
-  feeBps: import_zod60.z.number().optional()
-});
-var RouteDetailsSchema = import_zod60.z.object({
-  hops: import_zod60.z.array(RouteHopSchema),
-  totalFeePercentage: import_zod60.z.number().optional(),
-  aggregator: import_zod60.z.string().optional()
-});
-var BaseDataSchema = import_zod60.z.object({
-  amountOutTokens: import_zod60.z.string().optional(),
-  slippagePercentage: import_zod60.z.number().optional(),
-  amountInUSD: import_zod60.z.number().optional(),
-  amountOutUSD: import_zod60.z.number().optional(),
-  marketImpactPercentage: import_zod60.z.number().optional(),
-  poolFeesPercentage: import_zod60.z.number().optional(),
+  amountInTokens: import_zod61.z.string(),
+  amountOutTokens: import_zod61.z.string(),
+  exchange: import_zod61.z.string().optional(),
+  poolType: import_zod61.z.string().optional(),
+  feePercentage: import_zod61.z.number().optional(),
+  feeBps: import_zod61.z.number().optional()
+});
+var RouteDetailsSchema = import_zod61.z.object({
+  hops: import_zod61.z.array(RouteHopSchema),
+  totalFeePercentage: import_zod61.z.number().optional(),
+  aggregator: import_zod61.z.string().optional()
+});
+var IntegrationFeeSchema = import_zod61.z.object({
+  amount: import_zod61.z.string(),
+  percentage: import_zod61.z.number(),
+  wallet: import_zod61.z.string(),
+  deductedFrom: import_zod61.z.enum(["input", "output"])
+});
+var BaseDataSchema = import_zod61.z.object({
+  amountOutTokens: import_zod61.z.string().optional(),
+  slippagePercentage: import_zod61.z.number().optional(),
+  amountInUSD: import_zod61.z.number().optional(),
+  amountOutUSD: import_zod61.z.number().optional(),
+  marketImpactPercentage: import_zod61.z.number().optional(),
+  poolFeesPercentage: import_zod61.z.number().optional(),
   tokenIn: TokenInfoSchema.optional(),
   tokenOut: TokenInfoSchema.optional(),
-  requestId: import_zod60.z.string(),
-  details: import_zod60.z.object({
+  requestId: import_zod61.z.string(),
+  details: import_zod61.z.object({
     route: RouteDetailsSchema.optional(),
-    aggregator: import_zod60.z.string().optional(),
-    raw: import_zod60.z.record(import_zod60.z.unknown()).optional()
-  }).optional()
+    aggregator: import_zod61.z.string().optional(),
+    raw: import_zod61.z.record(import_zod61.z.unknown()).optional()
+  }).optional(),
+  fee: IntegrationFeeSchema.optional()
 });
 var DataWithSolanaSchema = BaseDataSchema.extend({
-  solana: import_zod60.z.object({
+  solana: import_zod61.z.object({
     transaction: SolanaTransactionSchema,
-    lastValidBlockHeight: import_zod60.z.number()
+    lastValidBlockHeight: import_zod61.z.number()
   }),
-  evm: import_zod60.z.never().optional()
+  evm: import_zod61.z.never().optional().openapi({ type: "null" })
 });
 var DataWithEVMSchema = BaseDataSchema.extend({
-  evm: import_zod60.z.object({
+  evm: import_zod61.z.object({
     transaction: EVMTransactionSchema
   }),
-  solana: import_zod60.z.never().optional()
+  solana: import_zod61.z.never().optional().openapi({ type: "null" })
 });
 var DataWithErrorSchema = BaseDataSchema.extend({
-  solana: import_zod60.z.never().optional(),
-  evm: import_zod60.z.never().optional()
+  solana: import_zod61.z.never().optional().openapi({ type: "null" }),
+  evm: import_zod61.z.never().optional().openapi({ type: "null" })
 });
-var SwapQuotingDataSchema = import_zod60.z.union([DataWithSolanaSchema, DataWithEVMSchema, DataWithErrorSchema]);
-var SwapQuotingOutputSchema = import_zod60.z.object({
+var SwapQuotingDataSchema = import_zod61.z.union([DataWithSolanaSchema, DataWithEVMSchema, DataWithErrorSchema]);
+var SwapQuotingOutputSchema = import_zod61.z.object({
   data: SwapQuotingDataSchema,
-  error: import_zod60.z.string().optional()
+  error: import_zod61.z.string().optional()
 });
 
 // src/v2/swap/SwapQuotingBatchOutput.ts
-var SwapQuotingBatchResultSchema = import_zod61.z.object({
+var SwapQuotingBatchResultSchema = import_zod62.z.object({
   data: SwapQuotingDataSchema,
-  error: import_zod61.z.string().optional(),
-  index: import_zod61.z.number()
+  error: import_zod62.z.string().optional(),
+  index: import_zod62.z.number()
 });
-var SwapQuotingBatchOutputSchema = import_zod61.z.object({
-  results: import_zod61.z.array(SwapQuotingBatchResultSchema),
-  totalRequests: import_zod61.z.number(),
-  successCount: import_zod61.z.number(),
-  errorCount: import_zod61.z.number()
+var SwapQuotingBatchOutputSchema = import_zod62.z.object({
+  results: import_zod62.z.array(SwapQuotingBatchResultSchema),
+  totalRequests: import_zod62.z.number(),
+  successCount: import_zod62.z.number(),
+  errorCount: import_zod62.z.number()
 });
 // src/v2/swap/SwapQuotingBatchSchema.ts
-var import_zod62 = require("zod");
-var SwapQuotingBatchItemSchema = import_zod62.z.object({
-  chainId: import_zod62.z.string(),
-  tokenIn: import_zod62.z.string().min(1, "tokenIn is required"),
-  tokenOut: import_zod62.z.string().min(1, "tokenOut is required"),
-  amount: import_zod62.z.number().positive("Amount must be a positive number").optional(),
-  amountRaw: import_zod62.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_zod62.z.number().min(0).max(100, "Slippage must be between 0 and 100").default(1),
-  walletAddress: import_zod62.z.string().min(1, "walletAddress is required"),
-  excludedProtocols: import_zod62.z.array(import_zod62.z.string()).optional(),
-  onlyProtocols: import_zod62.z.array(import_zod62.z.string()).optional(),
-  poolAddress: import_zod62.z.string().optional(),
-  onlyRouters: import_zod62.z.array(import_zod62.z.enum(["jupiter", "kyberswap", "lifi"])).optional().transform((val) => val?.length ? val : undefined),
-  priorityFee: import_zod62.z.union([
-    import_zod62.z.literal("auto"),
-    import_zod62.z.number().positive(),
-    import_zod62.z.object({
-      preset: import_zod62.z.enum(["low", "medium", "high", "veryHigh"])
+var import_zod63 = require("zod");
+var SwapQuotingBatchItemSchema = import_zod63.z.object({
+  chainId: import_zod63.z.string(),
+  tokenIn: import_zod63.z.string().min(1, "tokenIn is required"),
+  tokenOut: import_zod63.z.string().min(1, "tokenOut is required"),
+  amount: import_zod63.z.number().positive("Amount must be a positive number").optional(),
+  amountRaw: import_zod63.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_zod63.z.number().min(0).max(100, "Slippage must be between 0 and 100").default(1),
+  walletAddress: import_zod63.z.string().min(1, "walletAddress is required"),
+  excludedProtocols: import_zod63.z.array(import_zod63.z.string()).optional(),
+  onlyProtocols: import_zod63.z.array(import_zod63.z.string()).optional(),
+  poolAddress: import_zod63.z.string().optional(),
+  onlyRouters: import_zod63.z.array(import_zod63.z.enum(["jupiter", "kyberswap", "lifi"])).optional().transform((val) => val?.length ? val : undefined),
+  priorityFee: import_zod63.z.union([
+    import_zod63.z.literal("auto"),
+    import_zod63.z.number().positive(),
+    import_zod63.z.object({
+      preset: import_zod63.z.enum(["low", "medium", "high", "veryHigh"])
     })
   ]).optional(),
-  computeUnitLimit: import_zod62.z.union([import_zod62.z.literal(true), import_zod62.z.number().positive()]).optional(),
-  jitoTipLamports: import_zod62.z.number().positive().optional(),
-  feePercentage: import_zod62.z.number().min(0.01).max(99).optional(),
-  feeWallet: import_zod62.z.string().optional(),
-  payerAddress: import_zod62.z.string().optional()
+  computeUnitLimit: import_zod63.z.union([import_zod63.z.literal(true), import_zod63.z.number().positive()]).optional(),
+  jitoTipLamports: import_zod63.z.number().positive().optional(),
+  feePercentage: import_zod63.z.number().min(0.01).max(99).optional(),
+  feeWallet: import_zod63.z.string().optional(),
+  payerAddress: import_zod63.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_zod62.z.object({
-  requests: import_zod62.z.array(SwapQuotingBatchItemSchema).min(1, "At least one request is required").max(30, "Maximum 30 requests allowed per batch")
+var SwapQuotingBatchBodySchema = import_zod63.z.object({
+  requests: import_zod63.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_zod63 = require("zod");
-var SolanaInstructionSchema = import_zod63.z.object({
-  programId: import_zod63.z.string(),
-  accounts: import_zod63.z.array(import_zod63.z.object({
-    pubkey: import_zod63.z.string(),
-    isSigner: import_zod63.z.boolean(),
-    isWritable: import_zod63.z.boolean()
+var import_zod64 = require("zod");
+var SolanaInstructionSchema = import_zod64.z.object({
+  programId: import_zod64.z.string(),
+  accounts: import_zod64.z.array(import_zod64.z.object({
+    pubkey: import_zod64.z.string(),
+    isSigner: import_zod64.z.boolean(),
+    isWritable: import_zod64.z.boolean()
   })),
-  data: import_zod63.z.string()
-});
-var SolanaInstructionsSchema = import_zod63.z.object({
-  computeBudgetInstructions: import_zod63.z.array(SolanaInstructionSchema).optional(),
-  setupInstructions: import_zod63.z.array(SolanaInstructionSchema).optional(),
-  swapInstructions: import_zod63.z.array(SolanaInstructionSchema),
-  cleanupInstructions: import_zod63.z.array(SolanaInstructionSchema).optional(),
-  addressLookupTableAddresses: import_zod63.z.array(import_zod63.z.string()).optional()
-});
-var TokenInfoSchema2 = import_zod63.z.object({
-  address: import_zod63.z.string(),
-  name: import_zod63.z.string().optional(),
-  symbol: import_zod63.z.string().optional(),
-  decimals: import_zod63.z.number(),
-  logo: import_zod63.z.string().nullable().optional()
-});
-var RouteHopSchema2 = import_zod63.z.object({
-  poolAddress: import_zod63.z.string(),
+  data: import_zod64.z.string()
+});
+var SolanaInstructionsSchema = import_zod64.z.object({
+  computeBudgetInstructions: import_zod64.z.array(SolanaInstructionSchema).optional(),
+  setupInstructions: import_zod64.z.array(SolanaInstructionSchema).optional(),
+  swapInstructions: import_zod64.z.array(SolanaInstructionSchema),
+  cleanupInstructions: import_zod64.z.array(SolanaInstructionSchema).optional(),
+  addressLookupTableAddresses: import_zod64.z.array(import_zod64.z.string()).optional()
+});
+var TokenInfoSchema2 = 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 RouteHopSchema2 = import_zod64.z.object({
+  poolAddress: import_zod64.z.string(),
   tokenIn: TokenInfoSchema2,
   tokenOut: TokenInfoSchema2,
-  amountInTokens: import_zod63.z.string(),
-  amountOutTokens: import_zod63.z.string(),
-  exchange: import_zod63.z.string().optional(),
-  poolType: import_zod63.z.string().optional(),
-  feePercentage: import_zod63.z.number().optional(),
-  feeBps: import_zod63.z.number().optional()
-});
-var RouteDetailsSchema2 = import_zod63.z.object({
-  hops: import_zod63.z.array(RouteHopSchema2),
-  totalFeePercentage: import_zod63.z.number().optional(),
-  aggregator: import_zod63.z.string().optional()
-});
-var SwapQuotingInstructionsDataSchema = import_zod63.z.object({
-  amountOutTokens: import_zod63.z.string().optional(),
-  slippagePercentage: import_zod63.z.number().optional(),
-  amountInUSD: import_zod63.z.number().optional(),
-  amountOutUSD: import_zod63.z.number().optional(),
-  marketImpactPercentage: import_zod63.z.number().optional(),
-  poolFeesPercentage: import_zod63.z.number().optional(),
+  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 RouteDetailsSchema2 = import_zod64.z.object({
+  hops: import_zod64.z.array(RouteHopSchema2),
+  totalFeePercentage: import_zod64.z.number().optional(),
+  aggregator: import_zod64.z.string().optional()
+});
+var IntegrationFeeSchema2 = 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 SwapQuotingInstructionsDataSchema = 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(),
   tokenIn: TokenInfoSchema2.optional(),
   tokenOut: TokenInfoSchema2.optional(),
-  requestId: import_zod63.z.string(),
-  details: import_zod63.z.object({
+  requestId: import_zod64.z.string(),
+  details: import_zod64.z.object({
     route: RouteDetailsSchema2.optional(),
-    aggregator: import_zod63.z.string().optional(),
-    raw: import_zod63.z.record(import_zod63.z.unknown()).optional()
+    aggregator: import_zod64.z.string().optional(),
+    raw: import_zod64.z.record(import_zod64.z.unknown()).optional()
   }).optional(),
-  solana: import_zod63.z.object({
+  solana: import_zod64.z.object({
     instructions: SolanaInstructionsSchema,
-    lastValidBlockHeight: import_zod63.z.number(),
-    recentBlockhash: import_zod63.z.string()
-  })
+    lastValidBlockHeight: import_zod64.z.number(),
+    recentBlockhash: import_zod64.z.string()
+  }),
+  fee: IntegrationFeeSchema2.optional()
 });
-var SwapQuotingInstructionsOutputSchema = import_zod63.z.object({
+var SwapQuotingInstructionsOutputSchema = import_zod64.z.object({
   data: SwapQuotingInstructionsDataSchema,
-  error: import_zod63.z.string().optional()
+  error: import_zod64.z.string().optional()
 });
 // src/v2/swap/SwapQuotingSchema.ts
-var import_zod64 = require("zod");
-var SwapQuotingQuerySchema = import_zod64.z.object({
-  chainId: import_zod64.z.string(),
-  tokenIn: import_zod64.z.string().min(1, "tokenIn is required"),
-  tokenOut: import_zod64.z.string().min(1, "tokenOut is required"),
-  amount: import_zod64.z.string().optional().transform((val) => {
+var import_zod65 = require("zod");
+var SwapQuotingQuerySchema = import_zod65.z.object({
+  chainId: import_zod65.z.string(),
+  tokenIn: import_zod65.z.string().min(1, "tokenIn is required"),
+  tokenOut: import_zod65.z.string().min(1, "tokenOut is required"),
+  amount: import_zod65.z.string().optional().transform((val) => {
     if (!val)
       return;
     const parsed = Number.parseFloat(val);
@@ -5574,7 +5712,7 @@ var SwapQuotingQuerySchema = import_zod64.z.object({
     }
     return parsed;
   }),
-  amountRaw: import_zod64.z.string().optional().transform((val) => {
+  amountRaw: import_zod65.z.string().optional().transform((val) => {
     if (!val)
       return;
     if (!/^\d+$/.test(val)) {
@@ -5586,26 +5724,26 @@ var SwapQuotingQuerySchema = import_zod64.z.object({
     }
     return parsed;
   }),
-  slippage: import_zod64.z.string().optional().default("1").transform((val) => {
+  slippage: import_zod65.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_zod64.z.string().min(1, "walletAddress is required"),
-  excludedProtocols: import_zod64.z.string().optional().transform((val) => {
+  walletAddress: import_zod65.z.string().min(1, "walletAddress is required"),
+  excludedProtocols: import_zod65.z.string().optional().transform((val) => {
     if (!val)
       return;
     return val.split(",").map((f) => f.trim()).filter((f) => f.length > 0);
   }),
-  onlyProtocols: import_zod64.z.string().optional().transform((val) => {
+  onlyProtocols: import_zod65.z.string().optional().transform((val) => {
     if (!val)
       return;
     return val.split(",").map((t) => t.trim()).filter((t) => t.length > 0);
   }),
-  poolAddress: import_zod64.z.string().optional(),
-  onlyRouters: import_zod64.z.string().optional().transform((val) => {
+  poolAddress: import_zod65.z.string().optional(),
+  onlyRouters: import_zod65.z.string().optional().transform((val) => {
     if (!val)
       return;
     const supportedRouters = ["jupiter", "kyberswap", "lifi"];
@@ -5619,7 +5757,7 @@ var SwapQuotingQuerySchema = import_zod64.z.object({
       return;
     return routers;
   }),
-  priorityFee: import_zod64.z.string().optional().transform((val) => {
+  priorityFee: import_zod65.z.string().optional().transform((val) => {
     if (!val)
       return;
     if (val === "auto")
@@ -5634,7 +5772,7 @@ var SwapQuotingQuerySchema = import_zod64.z.object({
     }
     throw new Error(`Invalid priorityFee "${val}". Must be 'auto', a preset (low, medium, high, veryHigh), or a positive number`);
   }),
-  computeUnitLimit: import_zod64.z.string().optional().transform((val) => {
+  computeUnitLimit: import_zod65.z.string().optional().transform((val) => {
     if (!val)
       return;
     if (val === "true")
@@ -5645,7 +5783,7 @@ var SwapQuotingQuerySchema = import_zod64.z.object({
     }
     throw new Error(`Invalid computeUnitLimit "${val}". Must be 'true' or a positive number`);
   }),
-  jitoTipLamports: import_zod64.z.string().optional().transform((val) => {
+  jitoTipLamports: import_zod65.z.string().optional().transform((val) => {
     if (!val)
       return;
     const numValue = Number.parseInt(val, 10);
@@ -5654,7 +5792,7 @@ var SwapQuotingQuerySchema = import_zod64.z.object({
     }
     throw new Error(`Invalid jitoTipLamports "${val}". Must be a positive number`);
   }),
-  feePercentage: import_zod64.z.string().optional().transform((val) => {
+  feePercentage: import_zod65.z.string().optional().transform((val) => {
     if (!val)
       return;
     const numValue = Number.parseFloat(val);
@@ -5663,8 +5801,8 @@ var SwapQuotingQuerySchema = import_zod64.z.object({
     }
     return numValue;
   }),
-  feeWallet: import_zod64.z.string().optional(),
-  payerAddress: import_zod64.z.string().optional()
+  feeWallet: import_zod65.z.string().optional(),
+  payerAddress: import_zod65.z.string().optional()
 }).refine((data) => {
   const hasAmount = data.amount !== undefined;
   const hasAmountRaw = data.amountRaw !== undefined;
@@ -5674,20 +5812,20 @@ var SwapQuotingQuerySchema = import_zod64.z.object({
   path: ["amount"]
 });
 // src/v2/swap/SwapSendOutput.ts
-var import_zod65 = require("zod");
-var SwapSendResponseSchema = import_zod65.z.object({
-  data: import_zod65.z.object({
-    success: import_zod65.z.boolean(),
-    transactionHash: import_zod65.z.string().optional(),
-    requestId: import_zod65.z.string()
+var import_zod66 = require("zod");
+var SwapSendResponseSchema = import_zod66.z.object({
+  data: import_zod66.z.object({
+    success: import_zod66.z.boolean(),
+    transactionHash: import_zod66.z.string().optional(),
+    requestId: import_zod66.z.string()
   }),
-  error: import_zod65.z.string().optional()
+  error: import_zod66.z.string().optional()
 });
 // src/v2/swap/SwapSendSchema.ts
-var import_zod66 = require("zod");
-var SwapSendSchema = import_zod66.z.object({
-  chainId: import_zod66.z.string(),
-  signedTransaction: import_zod66.z.string().min(1, "signedTransaction is required").transform((val) => {
+var import_zod67 = require("zod");
+var SwapSendSchema = import_zod67.z.object({
+  chainId: import_zod67.z.string(),
+  signedTransaction: import_zod67.z.string().min(1, "signedTransaction is required").transform((val) => {
     try {
       return Buffer.from(val, "base64");
     } catch {
@@ -5696,249 +5834,283 @@ var SwapSendSchema = import_zod66.z.object({
   })
 });
 // src/v2/token/TokenDetailsSchema.ts
-var import_zod67 = require("zod");
-var TokenDetailsItemParams = import_zod67.z.object({
-  blockchain: import_zod67.z.string().optional(),
-  address: import_zod67.z.string().optional(),
+var import_zod68 = require("zod");
+var TokenDetailsItemParams = import_zod68.z.object({
+  blockchain: import_zod68.z.string().optional(),
+  address: import_zod68.z.string().optional(),
   currencies: CurrenciesParamSchema,
-  instanceTracking: import_zod67.z.preprocess((val) => {
+  instanceTracking: import_zod68.z.preprocess((val) => {
     if (val === "true")
       return true;
     if (val === "false")
       return false;
     return val;
-  }, import_zod67.z.boolean().optional())
+  }, import_zod68.z.boolean().optional())
 });
 var TokenDetailsParamsSchema = TokenDetailsItemParams;
-var TokenDetailsBatchParamsSchema = import_zod67.z.union([
-  import_zod67.z.array(TokenDetailsItemParams),
-  import_zod67.z.object({
-    items: import_zod67.z.array(TokenDetailsItemParams),
-    instanceTracking: import_zod67.z.preprocess((val) => {
+var TokenDetailsBatchParamsSchema = import_zod68.z.union([
+  import_zod68.z.array(TokenDetailsItemParams),
+  import_zod68.z.object({
+    items: import_zod68.z.array(TokenDetailsItemParams),
+    instanceTracking: import_zod68.z.preprocess((val) => {
       if (val === "true")
         return true;
       if (val === "false")
         return false;
       return val;
-    }, import_zod67.z.boolean().optional())
+    }, import_zod68.z.boolean().optional())
   })
 ]);
-var TokenDetailsResponseSchema = import_zod67.z.object({
+var TokenDetailsResponseSchema = import_zod68.z.object({
   data: TokenDetailsOutput,
-  hostname: import_zod67.z.string().optional()
+  hostname: import_zod68.z.string().optional()
 });
-var TokenDetailsBatchResponseSchema = import_zod67.z.object({
-  payload: import_zod67.z.array(TokenDetailsOutput.or(import_zod67.z.object({ error: import_zod67.z.string().optional() })).nullable()),
-  hostname: import_zod67.z.string().optional()
+var TokenDetailsBatchResponseSchema = import_zod68.z.object({
+  payload: import_zod68.z.array(TokenDetailsOutput.or(import_zod68.z.object({ error: import_zod68.z.string().optional() })).nullable()),
+  hostname: import_zod68.z.string().optional()
 });
 // src/v2/token/TokenKlineBsPointSchema.ts
-var import_zod68 = require("zod");
-var TokenKlineBsPointParamsSchema = import_zod68.z.object({
-  blockchain: import_zod68.z.string(),
-  address: import_zod68.z.string(),
-  bar: import_zod68.z.string().transform((val) => normalizePeriod(val ?? "5m", "5m")),
+var import_zod69 = require("zod");
+var TokenKlineBsPointParamsSchema = import_zod69.z.object({
+  blockchain: import_zod69.z.string(),
+  address: import_zod69.z.string(),
+  bar: import_zod69.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_zod68.z.object({
-  volumeBuyToken: import_zod68.z.string(),
-  buys: import_zod68.z.string(),
-  avgBuyPriceUSD: import_zod68.z.string(),
-  volumeBuy: import_zod68.z.string(),
-  volumeSellToken: import_zod68.z.string(),
-  sells: import_zod68.z.string(),
-  avgSellPriceUSD: import_zod68.z.string(),
-  volumeSell: import_zod68.z.string(),
-  fromAddress: import_zod68.z.string(),
-  fromAddressTag: import_zod68.z.string(),
-  time: import_zod68.z.string()
-});
-var TokenKlineBsPointResponseSchema = import_zod68.z.object({
-  data: import_zod68.z.array(TokenKlineBsBubblePoint)
+var TokenKlineBsBubblePoint = import_zod69.z.object({
+  volumeBuyToken: import_zod69.z.string(),
+  buys: import_zod69.z.string(),
+  avgBuyPriceUSD: import_zod69.z.string(),
+  volumeBuy: import_zod69.z.string(),
+  volumeSellToken: import_zod69.z.string(),
+  sells: import_zod69.z.string(),
+  avgSellPriceUSD: import_zod69.z.string(),
+  volumeSell: import_zod69.z.string(),
+  fromAddress: import_zod69.z.string(),
+  fromAddressTag: import_zod69.z.string(),
+  time: import_zod69.z.string()
+});
+var TokenKlineBsPointResponseSchema = import_zod69.z.object({
+  data: import_zod69.z.array(TokenKlineBsBubblePoint)
 });
 // src/v2/token/TokenMarketsSchema.ts
-var import_zod69 = require("zod");
+var import_zod70 = require("zod");
 var DEFAULT_MARKETS_RES_LIMIT = 10;
 var MARKETS_MAX__RES_LIMIT = 25;
-var TokenMarketsParamsSchema = import_zod69.z.object({
-  blockchain: import_zod69.z.string().optional(),
-  address: import_zod69.z.string(),
-  limit: import_zod69.z.coerce.number().min(1).max(MARKETS_MAX__RES_LIMIT).default(DEFAULT_MARKETS_RES_LIMIT)
+var TokenMarketsParamsSchema = import_zod70.z.object({
+  blockchain: import_zod70.z.string().optional(),
+  address: import_zod70.z.string(),
+  limit: import_zod70.z.coerce.number().min(1).max(MARKETS_MAX__RES_LIMIT).default(DEFAULT_MARKETS_RES_LIMIT)
 });
-var TokenMarketsOutput = import_zod69.z.array(MarketDetailsOutput);
-var TokenMarketsResponseSchema = import_zod69.z.object({
+var TokenMarketsOutput = import_zod70.z.array(MarketDetailsOutput);
+var TokenMarketsResponseSchema = import_zod70.z.object({
   data: TokenMarketsOutput,
-  totalCount: import_zod69.z.number()
+  totalCount: import_zod70.z.number()
 });
 // src/v2/token/TokenOHLCVHistorySchema.ts
-var import_zod70 = require("zod");
-var booleanFromString2 = import_zod70.z.union([import_zod70.z.boolean(), import_zod70.z.string()]).optional().default(true).transform((val) => {
+var import_zod71 = require("zod");
+var booleanFromString2 = import_zod71.z.union([import_zod71.z.boolean(), import_zod71.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_zod70.z.object({
-  address: import_zod70.z.string(),
-  chainId: import_zod70.z.string(),
+var TokenOHLCVHistoryItemSchema = import_zod71.z.object({
+  address: import_zod71.z.string(),
+  chainId: import_zod71.z.string(),
   from: DateQuery_default.transform((val) => val ?? 0),
   to: DateQuery_default.transform((val) => val ?? new Date),
-  period: import_zod70.z.string().optional().transform((val) => val ? normalizePeriod(val) : "5m"),
-  amount: import_zod70.z.coerce.number().optional(),
+  period: import_zod71.z.string().optional().transform((val) => val ? normalizePeriod(val) : "5m"),
+  amount: import_zod71.z.coerce.number().optional(),
   usd: booleanFromString2
 });
 var TokenOHLCVHistoryParamsSchema = TokenOHLCVHistoryItemSchema.refine((data) => data.address && data.chainId, { message: "address and chainId are required" });
-var TokenOHLCVHistoryArraySchema = import_zod70.z.array(TokenOHLCVHistoryItemSchema).min(1, "At least one token is required").max(10, "Maximum 10 tokens per request");
-var TokenOHLCVHistoryBatchParamsSchema = import_zod70.z.union([
+var TokenOHLCVHistoryArraySchema = import_zod71.z.array(TokenOHLCVHistoryItemSchema).min(1, "At least one token is required").max(10, "Maximum 10 tokens per request");
+var TokenOHLCVHistoryBatchParamsSchema = import_zod71.z.union([
   TokenOHLCVHistoryArraySchema,
-  import_zod70.z.object({ tokens: TokenOHLCVHistoryArraySchema })
+  import_zod71.z.object({ tokens: TokenOHLCVHistoryArraySchema })
 ]);
-var OHLCVCandleSchema2 = import_zod70.z.object({
-  v: import_zod70.z.number(),
-  o: import_zod70.z.number(),
-  h: import_zod70.z.number(),
-  l: import_zod70.z.number(),
-  c: import_zod70.z.number(),
-  t: import_zod70.z.number()
-});
-var TokenOHLCVHistoryResponseSchema = import_zod70.z.object({
-  data: import_zod70.z.array(OHLCVCandleSchema2)
-});
-var TokenOHLCVHistoryDataSchema = import_zod70.z.object({
-  ohlcv: import_zod70.z.array(OHLCVCandleSchema2),
-  address: import_zod70.z.string(),
-  chainId: import_zod70.z.string(),
-  error: import_zod70.z.string().optional()
+var OHLCVCandleSchema2 = import_zod71.z.object({
+  v: import_zod71.z.number(),
+  o: import_zod71.z.number(),
+  h: import_zod71.z.number(),
+  l: import_zod71.z.number(),
+  c: import_zod71.z.number(),
+  t: import_zod71.z.number()
+});
+var TokenOHLCVHistoryResponseSchema = import_zod71.z.object({
+  data: import_zod71.z.array(OHLCVCandleSchema2)
+});
+var TokenOHLCVHistoryDataSchema = import_zod71.z.object({
+  ohlcv: import_zod71.z.array(OHLCVCandleSchema2),
+  address: import_zod71.z.string(),
+  chainId: import_zod71.z.string(),
+  error: import_zod71.z.string().optional()
 });
-var TokenOHLCVHistoryBatchResponseSchema = import_zod70.z.object({
-  data: import_zod70.z.array(TokenOHLCVHistoryDataSchema)
+var TokenOHLCVHistoryBatchResponseSchema = import_zod71.z.object({
+  data: import_zod71.z.array(TokenOHLCVHistoryDataSchema)
 });
 // src/v2/token/TokenPositionsSchema.ts
-var import_zod71 = require("zod");
-var TokenPositionsParamsSchema = import_zod71.z.object({
-  blockchain: import_zod71.z.string().optional(),
-  address: import_zod71.z.string().optional(),
-  force: import_zod71.z.coerce.boolean().optional().default(false),
-  label: import_zod71.z.nativeEnum(Tags).optional(),
-  limit: import_zod71.z.coerce.number().optional().default(100),
-  offset: import_zod71.z.coerce.number().optional().default(0),
+var import_zod72 = require("zod");
+var TokenPositionsParamsSchema = import_zod72.z.object({
+  blockchain: import_zod72.z.string().optional(),
+  address: import_zod72.z.string().optional(),
+  force: import_zod72.z.coerce.boolean().optional().default(false),
+  label: import_zod72.z.nativeEnum(Tags).optional(),
+  limit: import_zod72.z.coerce.number().optional().default(100),
+  offset: import_zod72.z.coerce.number().optional().default(0),
   walletAddresses: stringOrArray.optional()
 });
-var TokenPositionOutput = import_zod71.z.object({
-  chainId: import_zod71.z.string(),
-  walletAddress: import_zod71.z.string(),
-  tokenAddress: import_zod71.z.string(),
-  tokenAmount: import_zod71.z.string(),
-  tokenAmountRaw: import_zod71.z.string(),
-  pnlUSD: import_zod71.z.string(),
-  buys: import_zod71.z.number(),
-  sells: import_zod71.z.number(),
-  volumeBuyToken: import_zod71.z.string(),
-  volumeSellToken: import_zod71.z.string(),
-  volumeBuyUSD: import_zod71.z.string(),
-  volumeSellUSD: import_zod71.z.string(),
-  avgBuyPriceUSD: import_zod71.z.string(),
-  avgSellPriceUSD: import_zod71.z.string(),
-  walletFundAt: import_zod71.z.date().nullable(),
-  lastActivityAt: import_zod71.z.date().nullable(),
-  firstTradeAt: import_zod71.z.date().nullable(),
-  lastTradeAt: import_zod71.z.date().nullable(),
-  labels: import_zod71.z.array(import_zod71.z.string()).nullable().optional().default([]),
-  fundingInfo: import_zod71.z.object({
-    from: import_zod71.z.string().nullable(),
-    date: import_zod71.z.date().nullable(),
-    chainId: import_zod71.z.string().nullable(),
-    txHash: import_zod71.z.string().nullable(),
-    amount: import_zod71.z.string().nullable(),
-    fromWalletLogo: import_zod71.z.string().nullable(),
-    fromWalletTag: import_zod71.z.string().nullable()
+var TokenPositionOutput = import_zod72.z.object({
+  chainId: import_zod72.z.string(),
+  walletAddress: import_zod72.z.string(),
+  tokenAddress: import_zod72.z.string(),
+  tokenAmount: import_zod72.z.string(),
+  tokenAmountRaw: import_zod72.z.string(),
+  tokenAmountUSD: import_zod72.z.string(),
+  percentageOfTotalSupply: import_zod72.z.string(),
+  pnlUSD: import_zod72.z.string(),
+  realizedPnlUSD: import_zod72.z.string(),
+  unrealizedPnlUSD: import_zod72.z.string(),
+  totalPnlUSD: import_zod72.z.string(),
+  buys: import_zod72.z.number(),
+  sells: import_zod72.z.number(),
+  volumeBuyToken: import_zod72.z.string(),
+  volumeSellToken: import_zod72.z.string(),
+  volumeBuyUSD: import_zod72.z.string(),
+  volumeSellUSD: import_zod72.z.string(),
+  avgBuyPriceUSD: import_zod72.z.string(),
+  avgSellPriceUSD: import_zod72.z.string(),
+  walletFundAt: import_zod72.z.date().nullable(),
+  lastActivityAt: import_zod72.z.date().nullable(),
+  firstTradeAt: import_zod72.z.date().nullable(),
+  lastTradeAt: import_zod72.z.date().nullable(),
+  labels: import_zod72.z.array(import_zod72.z.string()).nullable().optional().default([]),
+  fundingInfo: import_zod72.z.object({
+    from: import_zod72.z.string().nullable(),
+    date: import_zod72.z.date().nullable(),
+    chainId: import_zod72.z.string().nullable(),
+    txHash: import_zod72.z.string().nullable(),
+    amount: import_zod72.z.string().nullable(),
+    fromWalletLogo: import_zod72.z.string().nullable(),
+    fromWalletTag: import_zod72.z.string().nullable()
   })
 });
-var TokenPositionsResponseSchema = import_zod71.z.object({
-  data: import_zod71.z.array(TokenPositionOutput)
+var TokenPositionsResponseSchema = import_zod72.z.object({
+  data: import_zod72.z.array(TokenPositionOutput)
+});
+// src/v2/token/TokenPriceSchema.ts
+var import_zod73 = require("zod");
+var TokenPriceItemParams = import_zod73.z.object({
+  blockchain: import_zod73.z.string().optional(),
+  address: import_zod73.z.string().optional()
+});
+var TokenPriceParamsSchema = TokenPriceItemParams;
+var TokenPriceBatchParamsSchema = import_zod73.z.union([
+  import_zod73.z.array(TokenPriceItemParams),
+  import_zod73.z.object({
+    items: import_zod73.z.array(TokenPriceItemParams)
+  })
+]);
+var TokenPriceItemResponseSchema = import_zod73.z.object({
+  name: import_zod73.z.string().nullable(),
+  symbol: import_zod73.z.string().nullable(),
+  logo: import_zod73.z.string().nullable(),
+  priceUSD: import_zod73.z.number().nullable(),
+  marketCapUSD: import_zod73.z.number().nullable(),
+  marketCapDilutedUSD: import_zod73.z.number().nullable(),
+  liquidityUSD: import_zod73.z.number().nullable(),
+  liquidityMaxUSD: import_zod73.z.number().nullable()
+});
+var TokenPriceResponseSchema = import_zod73.z.object({
+  data: TokenPriceItemResponseSchema
+});
+var TokenPriceBatchResponseSchema = import_zod73.z.object({
+  payload: import_zod73.z.array(TokenPriceItemResponseSchema.or(import_zod73.z.object({ error: import_zod73.z.string().optional() })).nullable())
 });
 // src/v2/token/TokenSecurityOutput.ts
-var import_zod72 = require("zod");
-var StaticAnalysisStatusEnum = import_zod72.z.enum([
+var import_zod74 = require("zod");
+var StaticAnalysisStatusEnum = import_zod74.z.enum([
   "completed",
   "pending",
   "not_available",
   "insufficient_liquidity",
   "not_evm"
 ]);
-var TokenSecurityOutput = import_zod72.z.object({
-  address: import_zod72.z.string(),
-  chainId: import_zod72.z.string(),
-  contractHoldingsPercentage: import_zod72.z.number().nullable(),
-  contractBalanceRaw: import_zod72.z.string().nullable(),
-  burnedHoldingsPercentage: import_zod72.z.number().nullable(),
-  totalBurnedBalanceRaw: import_zod72.z.string().nullable(),
-  buyFeePercentage: import_zod72.z.number(),
-  sellFeePercentage: import_zod72.z.number(),
-  maxWalletAmountRaw: import_zod72.z.string().nullable(),
-  maxSellAmountRaw: import_zod72.z.string().nullable(),
-  maxBuyAmountRaw: import_zod72.z.string().nullable(),
-  maxTransferAmountRaw: import_zod72.z.string().nullable(),
-  isLaunchpadToken: import_zod72.z.boolean().nullable(),
-  top10HoldingsPercentage: import_zod72.z.number().nullable(),
-  top50HoldingsPercentage: import_zod72.z.number().nullable(),
-  top100HoldingsPercentage: import_zod72.z.number().nullable(),
-  top200HoldingsPercentage: import_zod72.z.number().nullable(),
-  isMintable: import_zod72.z.boolean().nullable(),
-  isFreezable: import_zod72.z.boolean().nullable(),
-  proTraderVolume24hPercentage: import_zod72.z.number().nullable(),
-  transferPausable: import_zod72.z.boolean().nullable(),
-  isBlacklisted: import_zod72.z.boolean().nullable(),
-  isHoneypot: import_zod72.z.boolean().nullable(),
-  isNotOpenSource: import_zod72.z.boolean().nullable(),
-  renounced: import_zod72.z.boolean().nullable(),
-  locked: import_zod72.z.string().nullable(),
-  isWhitelisted: import_zod72.z.boolean().nullable(),
-  balanceMutable: import_zod72.z.boolean().nullable(),
-  lowLiquidity: import_zod72.z.string().nullable(),
-  burnRate: import_zod72.z.string().nullable(),
-  modifyableTax: import_zod72.z.boolean().nullable(),
-  selfDestruct: import_zod72.z.boolean().nullable(),
+var TokenSecurityOutput = import_zod74.z.object({
+  address: import_zod74.z.string(),
+  chainId: import_zod74.z.string(),
+  contractHoldingsPercentage: import_zod74.z.number().nullable(),
+  contractBalanceRaw: import_zod74.z.string().nullable(),
+  burnedHoldingsPercentage: import_zod74.z.number().nullable(),
+  totalBurnedBalanceRaw: import_zod74.z.string().nullable(),
+  buyFeePercentage: import_zod74.z.number(),
+  sellFeePercentage: import_zod74.z.number(),
+  maxWalletAmountRaw: import_zod74.z.string().nullable(),
+  maxSellAmountRaw: import_zod74.z.string().nullable(),
+  maxBuyAmountRaw: import_zod74.z.string().nullable(),
+  maxTransferAmountRaw: import_zod74.z.string().nullable(),
+  isLaunchpadToken: import_zod74.z.boolean().nullable(),
+  top10HoldingsPercentage: import_zod74.z.number().nullable(),
+  top50HoldingsPercentage: import_zod74.z.number().nullable(),
+  top100HoldingsPercentage: import_zod74.z.number().nullable(),
+  top200HoldingsPercentage: import_zod74.z.number().nullable(),
+  isMintable: import_zod74.z.boolean().nullable(),
+  isFreezable: import_zod74.z.boolean().nullable(),
+  proTraderVolume24hPercentage: import_zod74.z.number().nullable(),
+  transferPausable: import_zod74.z.boolean().nullable(),
+  isBlacklisted: import_zod74.z.boolean().nullable(),
+  isHoneypot: import_zod74.z.boolean().nullable(),
+  isNotOpenSource: import_zod74.z.boolean().nullable(),
+  renounced: import_zod74.z.boolean().nullable(),
+  locked: import_zod74.z.string().nullable(),
+  isWhitelisted: import_zod74.z.boolean().nullable(),
+  balanceMutable: import_zod74.z.boolean().nullable(),
+  lowLiquidity: import_zod74.z.string().nullable(),
+  burnRate: import_zod74.z.string().nullable(),
+  modifyableTax: import_zod74.z.boolean().nullable(),
+  selfDestruct: import_zod74.z.boolean().nullable(),
   staticAnalysisStatus: StaticAnalysisStatusEnum.nullable(),
-  staticAnalysisDate: import_zod72.z.string().nullable()
+  staticAnalysisDate: import_zod74.z.string().nullable()
 });
-var TokenSecurityResponseSchema = import_zod72.z.object({
+var TokenSecurityResponseSchema = import_zod74.z.object({
   data: TokenSecurityOutput,
-  hostname: import_zod72.z.string().optional()
+  hostname: import_zod74.z.string().optional()
 });
 // src/v2/token/TokenSecurityQuery.ts
-var import_zod73 = require("zod");
-var TokenSecurityQuery = import_zod73.z.object({
-  blockchain: import_zod73.z.string().optional(),
-  address: import_zod73.z.string(),
-  instanceTracking: import_zod73.z.preprocess((val) => {
+var import_zod75 = require("zod");
+var TokenSecurityQuery = import_zod75.z.object({
+  blockchain: import_zod75.z.string().optional(),
+  address: import_zod75.z.string(),
+  instanceTracking: import_zod75.z.preprocess((val) => {
     if (val === "true")
       return true;
     if (val === "false")
       return false;
     return val;
-  }, import_zod73.z.boolean().optional()),
-  _forceAnalysis: import_zod73.z.preprocess((val) => {
+  }, import_zod75.z.boolean().optional()),
+  _forceAnalysis: import_zod75.z.preprocess((val) => {
     if (val === "true")
       return true;
     if (val === "false")
       return false;
     return val;
-  }, import_zod73.z.boolean().optional())
+  }, import_zod75.z.boolean().optional())
 });
 // src/v2/token/TokenTradesSchema.ts
-var import_zod74 = require("zod");
-var TokenTradesParamsSchema = import_zod74.z.object({
-  blockchain: import_zod74.z.string().optional(),
-  address: import_zod74.z.string().optional(),
-  offset: import_zod74.z.coerce.number().default(0),
-  limit: import_zod74.z.coerce.number().optional().default(10),
-  sortOrder: import_zod74.z.enum(["asc", "desc"]).default("desc"),
-  mode: import_zod74.z.enum(["pair", "asset"]).default("pair"),
-  label: import_zod74.z.nativeEnum(Tags).optional(),
+var import_zod76 = require("zod");
+var TokenTradesParamsSchema = import_zod76.z.object({
+  blockchain: import_zod76.z.string().optional(),
+  address: import_zod76.z.string().optional(),
+  offset: import_zod76.z.coerce.number().default(0),
+  limit: import_zod76.z.coerce.number().optional().default(10),
+  sortOrder: import_zod76.z.enum(["asc", "desc"]).default("desc"),
+  mode: import_zod76.z.enum(["pair", "asset"]).default("pair"),
+  label: import_zod76.z.nativeEnum(Tags).optional(),
   swapTypes: stringOrArray.optional().transform((val) => val?.filter((v) => Object.values(SwapType).includes(v))),
   swapSenderAddresses: stringOrArray.optional().refine((arr) => !arr || arr.length <= 25, {
     message: "Maximum 25 swap sender addresses allowed"
@@ -5946,684 +6118,687 @@ var TokenTradesParamsSchema = import_zod74.z.object({
   transactionSenderAddresses: stringOrArray.optional().refine((arr) => !arr || arr.length <= 25, {
     message: "Maximum 25 transaction sender addresses allowed"
   }),
-  maxAmountUSD: import_zod74.z.coerce.number().optional(),
-  minAmountUSD: import_zod74.z.coerce.number().optional(),
+  maxAmountUSD: import_zod76.z.coerce.number().optional(),
+  minAmountUSD: import_zod76.z.coerce.number().optional(),
   fromDate: DateQuery_default.transform((val) => val ?? undefined),
   toDate: DateQuery_default.transform((val) => val ?? undefined)
 });
-var TokenTradeOutput = import_zod74.z.object({
-  id: import_zod74.z.string(),
-  operation: import_zod74.z.string(),
-  type: import_zod74.z.string(),
-  baseTokenAmount: import_zod74.z.number(),
-  baseTokenAmountRaw: import_zod74.z.string(),
-  baseTokenAmountUSD: import_zod74.z.number(),
-  quoteTokenAmount: import_zod74.z.number(),
-  quoteTokenAmountRaw: import_zod74.z.string(),
-  quoteTokenAmountUSD: import_zod74.z.number(),
-  preBalanceBaseToken: import_zod74.z.string().nullable().optional(),
-  preBalanceQuoteToken: import_zod74.z.string().nullable().optional(),
-  postBalanceBaseToken: import_zod74.z.string().nullable().optional(),
-  postBalanceQuoteToken: import_zod74.z.string().nullable().optional(),
-  date: import_zod74.z.number(),
-  swapSenderAddress: import_zod74.z.string(),
-  transactionSenderAddress: import_zod74.z.string(),
-  blockchain: import_zod74.z.string(),
-  transactionHash: import_zod74.z.string(),
-  marketAddress: import_zod74.z.string(),
-  baseTokenPriceUSD: import_zod74.z.number(),
-  quoteTokenPriceUSD: import_zod74.z.number(),
-  labels: import_zod74.z.array(import_zod74.z.string()).nullable().optional().default([]),
+var TokenTradeOutput = import_zod76.z.object({
+  id: import_zod76.z.string(),
+  operation: import_zod76.z.string(),
+  type: import_zod76.z.string(),
+  baseTokenAmount: import_zod76.z.number(),
+  baseTokenAmountRaw: import_zod76.z.string(),
+  baseTokenAmountUSD: import_zod76.z.number(),
+  quoteTokenAmount: import_zod76.z.number(),
+  quoteTokenAmountRaw: import_zod76.z.string(),
+  quoteTokenAmountUSD: import_zod76.z.number(),
+  preBalanceBaseToken: import_zod76.z.string().nullable().optional(),
+  preBalanceQuoteToken: import_zod76.z.string().nullable().optional(),
+  postBalanceBaseToken: import_zod76.z.string().nullable().optional(),
+  postBalanceQuoteToken: import_zod76.z.string().nullable().optional(),
+  date: import_zod76.z.number(),
+  swapSenderAddress: import_zod76.z.string(),
+  transactionSenderAddress: import_zod76.z.string(),
+  blockchain: import_zod76.z.string(),
+  transactionHash: import_zod76.z.string(),
+  marketAddress: import_zod76.z.string(),
+  marketAddresses: import_zod76.z.array(import_zod76.z.string()).optional(),
+  baseTokenPriceUSD: import_zod76.z.number(),
+  quoteTokenPriceUSD: import_zod76.z.number(),
+  labels: import_zod76.z.array(import_zod76.z.string()).nullable().optional().default([]),
   baseToken: TokenDetailsOutput.optional(),
   quoteToken: TokenDetailsOutput.optional(),
-  totalFeesUSD: import_zod74.z.number().nullable().optional(),
-  gasFeesUSD: import_zod74.z.number().nullable().optional(),
-  platformFeesUSD: import_zod74.z.number().nullable().optional(),
-  mevFeesUSD: import_zod74.z.number().nullable().optional()
+  totalFeesUSD: import_zod76.z.number().nullable().optional(),
+  gasFeesUSD: import_zod76.z.number().nullable().optional(),
+  platformFeesUSD: import_zod76.z.number().nullable().optional(),
+  mevFeesUSD: import_zod76.z.number().nullable().optional()
 });
-var TokenTradeResponseSchema = import_zod74.z.object({
-  data: import_zod74.z.array(TokenTradeOutput)
+var TokenTradeResponseSchema = import_zod76.z.object({
+  data: import_zod76.z.array(TokenTradeOutput)
 });
-var SingleTokenTradeResponseSchema = import_zod74.z.object({
+var SingleTokenTradeResponseSchema = import_zod76.z.object({
   data: TokenTradeOutput
 });
-var FormattedTokenTradeOutput = import_zod74.z.object({
-  labels: import_zod74.z.array(import_zod74.z.string()).nullable().optional().default([]),
-  pair: import_zod74.z.string(),
-  date: import_zod74.z.number(),
-  tokenPrice: import_zod74.z.number(),
-  tokenPriceVs: import_zod74.z.number(),
-  tokenAmount: import_zod74.z.number(),
-  tokenAmountVs: import_zod74.z.number(),
-  tokenAmountUsd: import_zod74.z.number(),
-  tokenAmountVsUsd: import_zod74.z.number(),
-  type: import_zod74.z.string(),
-  operation: import_zod74.z.string(),
-  blockchain: import_zod74.z.string(),
-  hash: import_zod74.z.string(),
-  sender: import_zod74.z.string(),
-  tokenAmountRaw: import_zod74.z.string(),
-  tokenAmountRawVs: import_zod74.z.string(),
-  totalFeesUSD: import_zod74.z.number().nullable().optional(),
-  gasFeesUSD: import_zod74.z.number().nullable().optional(),
-  platformFeesUSD: import_zod74.z.number().nullable().optional(),
-  mevFeesUSD: import_zod74.z.number().nullable().optional()
-});
-var FormattedTokenTradeResponseSchema = import_zod74.z.object({
-  data: import_zod74.z.array(FormattedTokenTradeOutput)
-});
-var TokenTradeParamsSchema = import_zod74.z.object({
-  blockchain: import_zod74.z.string().optional(),
-  transactionHash: import_zod74.z.string().min(1, "Transaction hash is required")
-});
-var TokenTradeParamsSchemaOpenAPI = import_zod74.z.object({
-  blockchain: import_zod74.z.string().describe("Blockchain name or chain ID"),
-  transactionHash: import_zod74.z.string().min(1).describe("Transaction hash")
-});
-var TokenTradeOutputOpenAPI = import_zod74.z.object({
-  id: import_zod74.z.string(),
-  operation: import_zod74.z.string(),
-  type: import_zod74.z.string(),
-  baseTokenAmount: import_zod74.z.number(),
-  baseTokenAmountRaw: import_zod74.z.string(),
-  baseTokenAmountUSD: import_zod74.z.number(),
-  quoteTokenAmount: import_zod74.z.number(),
-  quoteTokenAmountRaw: import_zod74.z.string(),
-  quoteTokenAmountUSD: import_zod74.z.number(),
-  date: import_zod74.z.number(),
-  swapSenderAddress: import_zod74.z.string(),
-  transactionSenderAddress: import_zod74.z.string(),
-  blockchain: import_zod74.z.string(),
-  transactionHash: import_zod74.z.string(),
-  marketAddress: import_zod74.z.string(),
-  baseTokenPriceUSD: import_zod74.z.number(),
-  quoteTokenPriceUSD: import_zod74.z.number(),
-  labels: import_zod74.z.array(import_zod74.z.string()).nullable().optional().default([]),
+var FormattedTokenTradeOutput = import_zod76.z.object({
+  labels: import_zod76.z.array(import_zod76.z.string()).nullable().optional().default([]),
+  pair: import_zod76.z.string(),
+  date: import_zod76.z.number(),
+  tokenPrice: import_zod76.z.number(),
+  tokenPriceVs: import_zod76.z.number(),
+  tokenAmount: import_zod76.z.number(),
+  tokenAmountVs: import_zod76.z.number(),
+  tokenAmountUsd: import_zod76.z.number(),
+  tokenAmountVsUsd: import_zod76.z.number(),
+  type: import_zod76.z.string(),
+  operation: import_zod76.z.string(),
+  blockchain: import_zod76.z.string(),
+  hash: import_zod76.z.string(),
+  sender: import_zod76.z.string(),
+  tokenAmountRaw: import_zod76.z.string(),
+  tokenAmountRawVs: import_zod76.z.string(),
+  totalFeesUSD: import_zod76.z.number().nullable().optional(),
+  gasFeesUSD: import_zod76.z.number().nullable().optional(),
+  platformFeesUSD: import_zod76.z.number().nullable().optional(),
+  mevFeesUSD: import_zod76.z.number().nullable().optional()
+});
+var FormattedTokenTradeResponseSchema = import_zod76.z.object({
+  data: import_zod76.z.array(FormattedTokenTradeOutput)
+});
+var TokenTradeParamsSchema = import_zod76.z.object({
+  blockchain: import_zod76.z.string().optional(),
+  transactionHash: import_zod76.z.string().min(1, "Transaction hash is required")
+});
+var TokenTradeParamsSchemaOpenAPI = import_zod76.z.object({
+  blockchain: import_zod76.z.string().describe("Blockchain name or chain ID"),
+  transactionHash: import_zod76.z.string().min(1).describe("Transaction hash")
+});
+var TokenTradeOutputOpenAPI = import_zod76.z.object({
+  id: import_zod76.z.string(),
+  operation: import_zod76.z.string(),
+  type: import_zod76.z.string(),
+  baseTokenAmount: import_zod76.z.number(),
+  baseTokenAmountRaw: import_zod76.z.string(),
+  baseTokenAmountUSD: import_zod76.z.number(),
+  quoteTokenAmount: import_zod76.z.number(),
+  quoteTokenAmountRaw: import_zod76.z.string(),
+  quoteTokenAmountUSD: import_zod76.z.number(),
+  date: import_zod76.z.number(),
+  swapSenderAddress: import_zod76.z.string(),
+  transactionSenderAddress: import_zod76.z.string(),
+  blockchain: import_zod76.z.string(),
+  transactionHash: import_zod76.z.string(),
+  marketAddress: import_zod76.z.string(),
+  marketAddresses: import_zod76.z.array(import_zod76.z.string()).optional(),
+  baseTokenPriceUSD: import_zod76.z.number(),
+  quoteTokenPriceUSD: import_zod76.z.number(),
+  labels: import_zod76.z.array(import_zod76.z.string()).nullable().optional().default([]),
   baseToken: TokenDetailsOutput.optional(),
   quoteToken: TokenDetailsOutput.optional(),
-  totalFeesUSD: import_zod74.z.number().nullable().optional(),
-  gasFeesUSD: import_zod74.z.number().nullable().optional(),
-  platformFeesUSD: import_zod74.z.number().nullable().optional(),
-  mevFeesUSD: import_zod74.z.number().nullable().optional()
+  totalFeesUSD: import_zod76.z.number().nullable().optional(),
+  gasFeesUSD: import_zod76.z.number().nullable().optional(),
+  platformFeesUSD: import_zod76.z.number().nullable().optional(),
+  mevFeesUSD: import_zod76.z.number().nullable().optional()
 });
-var SingleTokenTradeResponseSchemaOpenAPI = import_zod74.z.object({
+var SingleTokenTradeResponseSchemaOpenAPI = import_zod76.z.object({
   data: TokenTradeOutputOpenAPI
 });
 // src/v2/wallet/WalleAnalysisQuerySchema.ts
-var import_zod75 = require("zod");
-var WalletAnalysisParamsSchema = import_zod75.z.object({
-  wallet: import_zod75.z.string().min(1, "Wallet address is required"),
-  blockchain: import_zod75.z.string().optional(),
-  period: import_zod75.z.string().optional().default("7d").transform((val) => val?.toLowerCase()).refine((val) => ["1d", "7d", "30d", "90d"].includes(val), {
+var import_zod77 = require("zod");
+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().default("7d").transform((val) => val?.toLowerCase()).refine((val) => ["1d", "7d", "30d", "90d"].includes(val), {
     message: "Period must be one of: 1d, 7d, 30d, 90d"
   })
 });
-var WalletAnalysisParamsSchemaOpenAPI = import_zod75.z.object({
-  wallet: import_zod75.z.string().min(1).describe("Wallet address to analyze"),
-  blockchain: import_zod75.z.string().optional().describe("Blockchain ID (e.g., ethereum, base, solana:solana)"),
-  period: import_zod75.z.string().optional().default("7d").describe("Analysis period: 1d, 7d, 30d, or 90d")
-});
-var WalletAnalysisResponseSchema = import_zod75.z.object({
-  data: import_zod75.z.object({
-    winRateDistribution: import_zod75.z.object({
-      ">500%": import_zod75.z.number(),
-      "200%-500%": import_zod75.z.number(),
-      "50%-200%": import_zod75.z.number(),
-      "0%-50%": import_zod75.z.number(),
-      "-50%-0%": import_zod75.z.number(),
-      "<-50%": import_zod75.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().default("7d").describe("Analysis period: 1d, 7d, 30d, or 90d")
+});
+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_zod75.z.object({
-      ">1000M": import_zod75.z.number(),
-      ">100M": import_zod75.z.number(),
-      "10M-100M": import_zod75.z.number(),
-      "1M-10M": import_zod75.z.number(),
-      "100k-1M": import_zod75.z.number(),
-      "<100k": import_zod75.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_zod75.z.array(import_zod75.z.object({
-      date: import_zod75.z.date(),
-      realized: import_zod75.z.number()
+    periodTimeframes: import_zod77.z.array(import_zod77.z.object({
+      date: import_zod77.z.date(),
+      realized: import_zod77.z.number()
     })),
-    stat: import_zod75.z.object({
-      totalValue: import_zod75.z.number(),
-      periodTotalPnlUSD: import_zod75.z.number(),
-      periodRealizedPnlUSD: import_zod75.z.number(),
-      periodRealizedRate: import_zod75.z.number(),
-      periodActiveTokensCount: import_zod75.z.number(),
-      periodWinCount: import_zod75.z.number(),
-      fundingInfo: import_zod75.z.object({
-        from: import_zod75.z.string().nullable(),
-        date: import_zod75.z.date().nullable(),
-        chainId: import_zod75.z.string().nullable(),
-        txHash: import_zod75.z.string().nullable(),
-        amount: import_zod75.z.string().nullable(),
-        fromWalletLogo: import_zod75.z.string().nullable(),
-        fromWalletTag: import_zod75.z.string().nullable()
+    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.date().nullable(),
+        chainId: import_zod77.z.string().nullable(),
+        txHash: import_zod77.z.string().nullable(),
+        amount: import_zod77.z.string().nullable(),
+        fromWalletLogo: import_zod77.z.string().nullable(),
+        fromWalletTag: import_zod77.z.string().nullable()
       }),
-      periodVolumeBuy: import_zod75.z.number(),
-      periodVolumeSell: import_zod75.z.number(),
-      periodBuys: import_zod75.z.number(),
-      periodSells: import_zod75.z.number(),
-      nativeBalance: import_zod75.z.object({
-        rawBalance: import_zod75.z.string(),
-        formattedBalance: import_zod75.z.number(),
-        assetId: import_zod75.z.number().nullable(),
-        chainId: import_zod75.z.string(),
-        address: import_zod75.z.string(),
-        decimals: import_zod75.z.number(),
-        name: import_zod75.z.string(),
-        symbol: import_zod75.z.string(),
-        logo: import_zod75.z.string().nullable(),
-        price: import_zod75.z.number(),
-        balanceUSD: import_zod75.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_zod75.z.number(),
-      periodSellTokens: import_zod75.z.number(),
-      periodTradingTokens: import_zod75.z.number(),
-      holdingTokensCount: import_zod75.z.number(),
-      holdingDuration: import_zod75.z.number(),
-      tradingTimeFrames: import_zod75.z.number(),
-      winRealizedPnl: import_zod75.z.number(),
-      winRealizedPnlRate: import_zod75.z.number(),
-      winToken: import_zod75.z.object({
-        address: import_zod75.z.string(),
-        chainId: import_zod75.z.string(),
-        name: import_zod75.z.string(),
-        symbol: import_zod75.z.string(),
-        logo: import_zod75.z.string().nullable(),
-        decimals: import_zod75.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_zod75.z.array(import_zod75.z.string())
+    labels: import_zod77.z.array(import_zod77.z.string())
   })
 });
-var WalletAnalysisResponseSchemaOpenAPI = import_zod75.z.object({
-  data: import_zod75.z.object({
-    winRateDistribution: import_zod75.z.object({
-      ">500%": import_zod75.z.number(),
-      "200%-500%": import_zod75.z.number(),
-      "50%-200%": import_zod75.z.number(),
-      "0%-50%": import_zod75.z.number(),
-      "-50%-0%": import_zod75.z.number(),
-      "<-50%": import_zod75.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_zod75.z.object({
-      ">1000M": import_zod75.z.number(),
-      ">100M": import_zod75.z.number(),
-      "10M-100M": import_zod75.z.number(),
-      "1M-10M": import_zod75.z.number(),
-      "100k-1M": import_zod75.z.number(),
-      "<100k": import_zod75.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_zod75.z.array(import_zod75.z.object({
-      date: import_zod75.z.string(),
-      realized: import_zod75.z.number()
+    periodTimeframes: import_zod77.z.array(import_zod77.z.object({
+      date: import_zod77.z.string(),
+      realized: import_zod77.z.number()
     })),
-    stat: import_zod75.z.object({
-      totalValue: import_zod75.z.number(),
-      periodTotalPnlUSD: import_zod75.z.number(),
-      periodRealizedPnlUSD: import_zod75.z.number(),
-      periodRealizedRate: import_zod75.z.number(),
-      periodActiveTokensCount: import_zod75.z.number(),
-      periodWinCount: import_zod75.z.number(),
-      fundingInfo: import_zod75.z.object({
-        from: import_zod75.z.string().nullable(),
-        date: import_zod75.z.string().nullable(),
-        chainId: import_zod75.z.string().nullable(),
-        txHash: import_zod75.z.string().nullable(),
-        amount: import_zod75.z.string().nullable(),
-        fromWalletLogo: import_zod75.z.string().nullable(),
-        fromWalletTag: import_zod75.z.string().nullable()
+    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(),
+        fromWalletLogo: import_zod77.z.string().nullable(),
+        fromWalletTag: import_zod77.z.string().nullable()
       }),
-      periodVolumeBuy: import_zod75.z.number(),
-      periodVolumeSell: import_zod75.z.number(),
-      periodBuys: import_zod75.z.number(),
-      periodSells: import_zod75.z.number(),
-      nativeBalance: import_zod75.z.object({
-        rawBalance: import_zod75.z.string(),
-        formattedBalance: import_zod75.z.number(),
-        assetId: import_zod75.z.number().nullable(),
-        chainId: import_zod75.z.string(),
-        address: import_zod75.z.string(),
-        decimals: import_zod75.z.number(),
-        name: import_zod75.z.string(),
-        symbol: import_zod75.z.string(),
-        logo: import_zod75.z.string().nullable(),
-        price: import_zod75.z.number(),
-        balanceUSD: import_zod75.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_zod75.z.number(),
-      periodSellTokens: import_zod75.z.number(),
-      periodTradingTokens: import_zod75.z.number(),
-      holdingTokensCount: import_zod75.z.number(),
-      holdingDuration: import_zod75.z.number(),
-      tradingTimeFrames: import_zod75.z.number(),
-      winRealizedPnl: import_zod75.z.number(),
-      winRealizedPnlRate: import_zod75.z.number(),
-      winToken: import_zod75.z.object({
-        address: import_zod75.z.string(),
-        chainId: import_zod75.z.string(),
-        name: import_zod75.z.string(),
-        symbol: import_zod75.z.string(),
-        logo: import_zod75.z.string().nullable(),
-        decimals: import_zod75.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_zod75.z.array(import_zod75.z.string())
+    labels: import_zod77.z.array(import_zod77.z.string())
   })
 });
 // src/v2/wallet/WalleFundingQuerySchema.ts
-var import_zod76 = require("zod");
-var WalletFundingParamsSchema = import_zod76.z.object({
-  wallet: import_zod76.z.string().min(1, "Wallet address is required")
-});
-var WalletFundingResponseSchema = import_zod76.z.object({
-  data: import_zod76.z.object({
-    from: import_zod76.z.string().nullable(),
-    chainId: import_zod76.z.string().nullable(),
-    date: import_zod76.z.date().nullable(),
-    txHash: import_zod76.z.string().nullable(),
-    amount: import_zod76.z.string().nullable(),
-    fromWalletLogo: import_zod76.z.string().nullable(),
-    fromWalletTag: import_zod76.z.string().nullable()
+var import_zod78 = require("zod");
+var WalletFundingParamsSchema = import_zod78.z.object({
+  wallet: import_zod78.z.string().min(1, "Wallet address is required")
+});
+var WalletFundingResponseSchema = import_zod78.z.object({
+  data: import_zod78.z.object({
+    from: import_zod78.z.string().nullable(),
+    chainId: import_zod78.z.string().nullable(),
+    date: import_zod78.z.date().nullable(),
+    txHash: import_zod78.z.string().nullable(),
+    amount: import_zod78.z.string().nullable(),
+    fromWalletLogo: import_zod78.z.string().nullable(),
+    fromWalletTag: import_zod78.z.string().nullable()
   })
 });
 // src/v2/wallet/WalletActivityV2Schema.ts
-var import_zod77 = require("zod");
-var WalletActivityV2ParamsSchema = import_zod77.z.object({
-  wallet: import_zod77.z.string(),
-  blockchains: import_zod77.z.string().optional().transform((val) => {
+var import_zod79 = require("zod");
+var WalletActivityV2ParamsSchema = import_zod79.z.object({
+  wallet: import_zod79.z.string(),
+  blockchains: import_zod79.z.string().optional().transform((val) => {
     if (val) {
       return val.split(",").map((b) => b.trim()).filter((b) => b.length > 0);
     }
     return [];
   }),
-  blacklist: import_zod77.z.string().optional().transform((val) => val ? val.split(",").map((addr) => addr.trim().toLowerCase()) : []),
-  offset: import_zod77.z.coerce.number().optional().default(0),
-  limit: import_zod77.z.coerce.number().optional().default(100),
-  order: import_zod77.z.enum(["asc", "desc"]).optional().default("desc"),
-  pagination: import_zod77.z.union([import_zod77.z.boolean(), import_zod77.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
-  unlistedAssets: import_zod77.z.union([import_zod77.z.boolean(), import_zod77.z.string()]).optional().transform((val) => val === true || val === "true").default(true),
-  filterSpam: import_zod77.z.union([import_zod77.z.boolean(), import_zod77.z.string()]).optional().transform((val) => val === true || val === "true").default(true),
-  backfillTransfers: import_zod77.z.union([import_zod77.z.boolean(), import_zod77.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
-  backfillBalances: import_zod77.z.union([import_zod77.z.boolean(), import_zod77.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
-  cursor_hash: import_zod77.z.string().optional(),
-  cursor_direction: import_zod77.z.enum(["before", "after"]).optional().default("before"),
-  withTokens: import_zod77.z.union([import_zod77.z.boolean(), import_zod77.z.string()]).optional().transform((val) => val === true || val === "true").default(false)
-});
-var ActivityAssetSchema = import_zod77.z.object({
-  id: import_zod77.z.number().nullable(),
-  name: import_zod77.z.string(),
-  symbol: import_zod77.z.string(),
-  decimals: import_zod77.z.number(),
-  totalSupply: import_zod77.z.number(),
-  circulatingSupply: import_zod77.z.number(),
-  price: import_zod77.z.number(),
-  liquidity: import_zod77.z.number(),
-  priceChange24hPercent: import_zod77.z.number(),
-  marketCapUsd: import_zod77.z.number(),
-  logo: import_zod77.z.string().nullable(),
-  contract: import_zod77.z.string()
-});
-var WalletActivityV2TransactionActivitySchema = import_zod77.z.object({
-  model: import_zod77.z.enum(["swap", "transfer"]),
-  swapType: import_zod77.z.enum(["REGULAR", "MEV", "SANDWICHED_MEV", "DEPOSIT", "WITHDRAW"]).optional(),
-  swapRawAmountOut: import_zod77.z.number().optional(),
-  swapRawAmountIn: import_zod77.z.number().optional(),
-  swapAmountOut: import_zod77.z.number().optional(),
-  swapAmountIn: import_zod77.z.number().optional(),
-  swapPriceUsdTokenOut: import_zod77.z.number().optional(),
-  swapPriceUsdTokenIn: import_zod77.z.number().optional(),
-  swapAmountUsd: import_zod77.z.number().optional(),
-  swapTransactionSenderAddress: import_zod77.z.string().optional(),
-  swapBaseAddress: import_zod77.z.string().optional(),
-  swapQuoteAddress: import_zod77.z.string().optional(),
-  swapAmountQuote: import_zod77.z.number().optional(),
-  swapAmountBase: import_zod77.z.number().optional(),
+  blacklist: import_zod79.z.string().optional().transform((val) => val ? val.split(",").map((addr) => addr.trim().toLowerCase()) : []),
+  offset: import_zod79.z.coerce.number().optional().default(0),
+  limit: import_zod79.z.coerce.number().optional().default(100),
+  order: import_zod79.z.enum(["asc", "desc"]).optional().default("desc"),
+  pagination: import_zod79.z.union([import_zod79.z.boolean(), import_zod79.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
+  unlistedAssets: import_zod79.z.union([import_zod79.z.boolean(), import_zod79.z.string()]).optional().transform((val) => val === true || val === "true").default(true),
+  filterSpam: import_zod79.z.union([import_zod79.z.boolean(), import_zod79.z.string()]).optional().transform((val) => val === true || val === "true").default(true),
+  backfillTransfers: import_zod79.z.union([import_zod79.z.boolean(), import_zod79.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
+  backfillBalances: import_zod79.z.union([import_zod79.z.boolean(), import_zod79.z.string()]).optional().transform((val) => val === true || val === "true").default(false),
+  cursor_hash: import_zod79.z.string().optional(),
+  cursor_direction: import_zod79.z.enum(["before", "after"]).optional().default("before"),
+  withTokens: import_zod79.z.union([import_zod79.z.boolean(), import_zod79.z.string()]).optional().transform((val) => val === true || val === "true").default(false)
+});
+var ActivityAssetSchema = import_zod79.z.object({
+  id: import_zod79.z.number().nullable(),
+  name: import_zod79.z.string(),
+  symbol: import_zod79.z.string(),
+  decimals: import_zod79.z.number(),
+  totalSupply: import_zod79.z.number(),
+  circulatingSupply: import_zod79.z.number(),
+  price: import_zod79.z.number(),
+  liquidity: import_zod79.z.number(),
+  priceChange24hPercent: import_zod79.z.number(),
+  marketCapUsd: import_zod79.z.number(),
+  logo: import_zod79.z.string().nullable(),
+  contract: import_zod79.z.string()
+});
+var WalletActivityV2TransactionActivitySchema = import_zod79.z.object({
+  model: import_zod79.z.enum(["swap", "transfer"]),
+  swapType: import_zod79.z.enum(["REGULAR", "MEV", "SANDWICHED_MEV", "DEPOSIT", "WITHDRAW"]).optional(),
+  swapRawAmountOut: import_zod79.z.number().optional(),
+  swapRawAmountIn: import_zod79.z.number().optional(),
+  swapAmountOut: import_zod79.z.number().optional(),
+  swapAmountIn: import_zod79.z.number().optional(),
+  swapPriceUsdTokenOut: import_zod79.z.number().optional(),
+  swapPriceUsdTokenIn: import_zod79.z.number().optional(),
+  swapAmountUsd: import_zod79.z.number().optional(),
+  swapTransactionSenderAddress: import_zod79.z.string().optional(),
+  swapBaseAddress: import_zod79.z.string().optional(),
+  swapQuoteAddress: import_zod79.z.string().optional(),
+  swapAmountQuote: import_zod79.z.number().optional(),
+  swapAmountBase: import_zod79.z.number().optional(),
   swapAssetIn: ActivityAssetSchema.optional(),
   swapAssetOut: ActivityAssetSchema.optional(),
-  transferRawAmount: import_zod77.z.string().optional(),
-  transferAmount: import_zod77.z.number().optional(),
-  transferAmountUsd: import_zod77.z.number().optional(),
-  transferType: import_zod77.z.enum(["VAULT_DEPOSIT", "VAULT_WITHDRAW", "VAULT_UNSTAKE", "TOKEN_IN", "TOKEN_OUT", "NATIVE_IN", "NATIVE_OUT"]).optional(),
-  transferFromAddress: import_zod77.z.string().optional().nullable(),
-  transferToAddress: import_zod77.z.string().optional().nullable(),
+  transferRawAmount: import_zod79.z.string().optional(),
+  transferAmount: import_zod79.z.number().optional(),
+  transferAmountUsd: import_zod79.z.number().optional(),
+  transferType: import_zod79.z.enum(["VAULT_DEPOSIT", "VAULT_WITHDRAW", "VAULT_UNSTAKE", "TOKEN_IN", "TOKEN_OUT", "NATIVE_IN", "NATIVE_OUT"]).optional(),
+  transferFromAddress: import_zod79.z.string().optional().nullable(),
+  transferToAddress: import_zod79.z.string().optional().nullable(),
   transferAsset: ActivityAssetSchema.optional()
 });
-var WalletActivityV2TransactionSchema = import_zod77.z.object({
-  chainId: import_zod77.z.string(),
-  txDateMs: import_zod77.z.number(),
-  txDateIso: import_zod77.z.string(),
-  txHash: import_zod77.z.string(),
-  txRawFeesNative: import_zod77.z.string(),
-  txFeesNativeUsd: import_zod77.z.number(),
-  txBlockNumber: import_zod77.z.number(),
-  txIndex: import_zod77.z.number(),
-  txAction: import_zod77.z.string().optional().nullable(),
-  actions: import_zod77.z.array(WalletActivityV2TransactionActivitySchema)
-});
-var WalletActivityV2OutputDataSchema = import_zod77.z.array(WalletActivityV2TransactionSchema);
-var WalletActivityV2OutputPaginationSchema = import_zod77.z.object({
-  page: import_zod77.z.number(),
-  offset: import_zod77.z.number(),
-  limit: import_zod77.z.number(),
-  pageEntries: import_zod77.z.number()
-});
-var WalletActivityV2ResponseSchema = import_zod77.z.object({
+var WalletActivityV2TransactionSchema = import_zod79.z.object({
+  chainId: import_zod79.z.string(),
+  txDateMs: import_zod79.z.number(),
+  txDateIso: import_zod79.z.string(),
+  txHash: import_zod79.z.string(),
+  txRawFeesNative: import_zod79.z.string(),
+  txFeesNativeUsd: import_zod79.z.number(),
+  txBlockNumber: import_zod79.z.number(),
+  txIndex: import_zod79.z.number(),
+  txAction: import_zod79.z.string().optional().nullable(),
+  actions: import_zod79.z.array(WalletActivityV2TransactionActivitySchema)
+});
+var WalletActivityV2OutputDataSchema = import_zod79.z.array(WalletActivityV2TransactionSchema);
+var WalletActivityV2OutputPaginationSchema = import_zod79.z.object({
+  page: import_zod79.z.number(),
+  offset: import_zod79.z.number(),
+  limit: import_zod79.z.number(),
+  pageEntries: import_zod79.z.number()
+});
+var WalletActivityV2ResponseSchema = import_zod79.z.object({
   data: WalletActivityV2OutputDataSchema,
   pagination: WalletActivityV2OutputPaginationSchema,
-  backfillStatus: import_zod77.z.enum(["processed", "processing", "pending"]).optional(),
-  tokens: import_zod77.z.array(TokenDetailsOutput).optional()
+  backfillStatus: import_zod79.z.enum(["processed", "processing", "pending"]).optional(),
+  tokens: import_zod79.z.array(TokenDetailsOutput).optional()
 });
 // src/v2/wallet/WalletDefiPositionsSchema.ts
-var import_zod78 = require("zod");
-var walletAddressSchema = import_zod78.z.string().min(32, "Invalid wallet address").max(44, "Invalid wallet address").or(import_zod78.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid EVM wallet address"));
-var WalletDefiPositionsParamsSchema = import_zod78.z.object({
+var import_zod80 = require("zod");
+var walletAddressSchema = import_zod80.z.string().min(32, "Invalid wallet address").max(44, "Invalid wallet address").or(import_zod80.z.string().regex(/^0x[a-fA-F0-9]{40}$/, "Invalid EVM wallet address"));
+var WalletDefiPositionsParamsSchema = import_zod80.z.object({
   wallet: walletAddressSchema.describe("Wallet address (EVM or Solana)"),
-  blockchains: import_zod78.z.string().describe('Blockchain to fetch positions from (e.g., "solana", "ethereum")')
+  blockchains: import_zod80.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/WalletPerpsPositionsSchema.ts
-var import_zod79 = require("zod");
-var ExchangesIds = import_zod79.z.enum(["gains", "hyperliquid", "gte", "lighter"]);
-var tpSlSchema = import_zod79.z.object({ size: import_zod79.z.bigint(), price: import_zod79.z.number(), id: import_zod79.z.number() });
-var PerpsPositionSchema = import_zod79.z.object({
-  id: import_zod79.z.string(),
-  entryPriceQuote: import_zod79.z.number(),
-  currentLeverage: import_zod79.z.number(),
-  amountUSD: import_zod79.z.number(),
-  amountRaw: import_zod79.z.bigint(),
-  side: import_zod79.z.enum(["BUY", "SELL"]),
-  liquidationPriceQuote: import_zod79.z.number(),
-  currentPriceQuote: import_zod79.z.number(),
-  realizedPnlUSD: import_zod79.z.number(),
-  unrealizedPnlUSD: import_zod79.z.number(),
-  realizedPnlPercent: import_zod79.z.number(),
-  unrealizedPnlPercent: import_zod79.z.number(),
-  tp: import_zod79.z.array(tpSlSchema),
-  sl: import_zod79.z.array(tpSlSchema),
-  marketId: import_zod79.z.string(),
+var import_zod81 = require("zod");
+var ExchangesIds = import_zod81.z.enum(["gains", "hyperliquid", "gte", "lighter", "drift"]);
+var tpSlSchema = import_zod81.z.object({ size: import_zod81.z.bigint(), price: import_zod81.z.number(), id: import_zod81.z.number() });
+var PerpsPositionSchema = import_zod81.z.object({
+  id: import_zod81.z.string(),
+  entryPriceQuote: import_zod81.z.number(),
+  currentLeverage: import_zod81.z.number(),
+  amountUSD: import_zod81.z.number(),
+  amountRaw: import_zod81.z.bigint(),
+  side: import_zod81.z.enum(["BUY", "SELL"]),
+  liquidationPriceQuote: import_zod81.z.number(),
+  currentPriceQuote: import_zod81.z.number(),
+  realizedPnlUSD: import_zod81.z.number(),
+  unrealizedPnlUSD: import_zod81.z.number(),
+  realizedPnlPercent: import_zod81.z.number(),
+  unrealizedPnlPercent: import_zod81.z.number(),
+  tp: import_zod81.z.array(tpSlSchema),
+  sl: import_zod81.z.array(tpSlSchema),
+  marketId: import_zod81.z.string(),
   exchange: ExchangesIds,
-  feesOpeningUSD: import_zod79.z.number(),
-  feesClosingUSD: import_zod79.z.number(),
-  feesFundingUSD: import_zod79.z.number(),
-  openDate: import_zod79.z.date(),
-  lastUpdate: import_zod79.z.date(),
-  address: import_zod79.z.string(),
-  chainId: import_zod79.z.string(),
-  collateralAsset: import_zod79.z.string()
+  feesOpeningUSD: import_zod81.z.number(),
+  feesClosingUSD: import_zod81.z.number(),
+  feesFundingUSD: import_zod81.z.number(),
+  openDate: import_zod81.z.date(),
+  lastUpdate: import_zod81.z.date(),
+  address: import_zod81.z.string(),
+  chainId: import_zod81.z.string(),
+  collateralAsset: import_zod81.z.string()
 });
 var PerpsPositionNonExecutedSchema = PerpsPositionSchema.extend({
-  type: import_zod79.z.enum(["STOP", "LIMIT"])
+  type: import_zod81.z.enum(["STOP", "LIMIT"])
 });
-var WalletPerpsPositionsResponseSchema = import_zod79.z.object({
-  data: import_zod79.z.array(PerpsPositionSchema)
+var WalletPerpsPositionsResponseSchema = import_zod81.z.object({
+  data: import_zod81.z.array(PerpsPositionSchema)
 });
-var WalletPerpsPositionsNonExecutedResponseSchema = import_zod79.z.object({
-  data: import_zod79.z.array(PerpsPositionNonExecutedSchema)
+var WalletPerpsPositionsNonExecutedResponseSchema = import_zod81.z.object({
+  data: import_zod81.z.array(PerpsPositionNonExecutedSchema)
 });
 // src/v2/wallet/WalletPositionsSchema.ts
-var import_zod80 = require("zod");
-var WalletPositionsParamsSchema = import_zod80.z.object({
-  wallet: import_zod80.z.string(),
-  blockchain: import_zod80.z.string().optional(),
-  backfillPositions: import_zod80.z.union([import_zod80.z.boolean(), import_zod80.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
-  backfillSwapsAndPositions: import_zod80.z.union([import_zod80.z.boolean(), import_zod80.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
-});
-var SinglePositionQuery = import_zod80.z.object({
-  wallet: import_zod80.z.string(),
-  asset: import_zod80.z.string(),
-  blockchain: import_zod80.z.string()
-});
-var SinglePositionItemSchema = import_zod80.z.object({
-  wallet: import_zod80.z.string(),
-  asset: import_zod80.z.string(),
-  blockchain: import_zod80.z.string()
-});
-var SinglePositionBatchParamsSchema = import_zod80.z.union([
-  import_zod80.z.array(SinglePositionItemSchema),
-  import_zod80.z.object({
-    items: import_zod80.z.array(SinglePositionItemSchema),
-    instanceTracking: import_zod80.z.preprocess((val) => {
+var import_zod82 = require("zod");
+var WalletPositionsParamsSchema = import_zod82.z.object({
+  wallet: import_zod82.z.string(),
+  blockchain: import_zod82.z.string().optional(),
+  backfillPositions: import_zod82.z.union([import_zod82.z.boolean(), import_zod82.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val),
+  backfillSwapsAndPositions: import_zod82.z.union([import_zod82.z.boolean(), import_zod82.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+});
+var SinglePositionQuery = import_zod82.z.object({
+  wallet: import_zod82.z.string(),
+  asset: import_zod82.z.string(),
+  blockchain: import_zod82.z.string()
+});
+var SinglePositionItemSchema = import_zod82.z.object({
+  wallet: import_zod82.z.string(),
+  asset: import_zod82.z.string(),
+  blockchain: import_zod82.z.string()
+});
+var SinglePositionBatchParamsSchema = import_zod82.z.union([
+  import_zod82.z.array(SinglePositionItemSchema),
+  import_zod82.z.object({
+    items: import_zod82.z.array(SinglePositionItemSchema),
+    instanceTracking: 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())
   })
 ]);
-var WalletPositionsResponseSchema = import_zod80.z.object({
-  data: import_zod80.z.array(tokenPositionSchema)
+var WalletPositionsResponseSchema = import_zod82.z.object({
+  data: import_zod82.z.array(tokenPositionSchema)
 });
-var singlePositionOutputSchema = import_zod80.z.object({
+var singlePositionOutputSchema = import_zod82.z.object({
   data: tokenPositionSchema
 });
 var batchPositionItemSchema = tokenPositionSchema.extend({
-  wallet: import_zod80.z.string()
+  wallet: import_zod82.z.string()
 });
-var SinglePositionBatchResponseSchema = import_zod80.z.object({
-  payload: import_zod80.z.array(batchPositionItemSchema.or(import_zod80.z.object({ error: import_zod80.z.string().optional(), wallet: import_zod80.z.string().optional() })).nullable()),
-  hostname: import_zod80.z.string().optional()
+var SinglePositionBatchResponseSchema = import_zod82.z.object({
+  payload: import_zod82.z.array(batchPositionItemSchema.or(import_zod82.z.object({ error: import_zod82.z.string().optional(), wallet: import_zod82.z.string().optional() })).nullable()),
+  hostname: import_zod82.z.string().optional()
 });
 // src/v2/wallet/WalletTokenBalancesSchema.ts
-var import_zod81 = require("zod");
-var tokenHoldingSchema = import_zod81.z.object({
-  token: import_zod81.z.object({
-    address: import_zod81.z.string(),
-    chainId: import_zod81.z.string(),
-    name: import_zod81.z.string().nullable(),
-    symbol: import_zod81.z.string().nullable(),
-    logo: import_zod81.z.string().nullable(),
-    decimals: import_zod81.z.coerce.number().default(0),
-    holdersCount: import_zod81.z.coerce.number().default(0),
-    deployer: import_zod81.z.string().nullable(),
-    website: import_zod81.z.string().nullable(),
-    x: import_zod81.z.string().nullable(),
-    telegram: import_zod81.z.string().nullable(),
-    description: import_zod81.z.string().nullable(),
+var import_zod83 = require("zod");
+var tokenHoldingSchema = import_zod83.z.object({
+  token: import_zod83.z.object({
+    address: import_zod83.z.string(),
+    chainId: import_zod83.z.string(),
+    name: import_zod83.z.string().nullable(),
+    symbol: import_zod83.z.string().nullable(),
+    logo: import_zod83.z.string().nullable(),
+    decimals: import_zod83.z.coerce.number().default(0),
+    holdersCount: import_zod83.z.coerce.number().default(0),
+    deployer: import_zod83.z.string().nullable(),
+    website: import_zod83.z.string().nullable(),
+    x: import_zod83.z.string().nullable(),
+    telegram: import_zod83.z.string().nullable(),
+    description: import_zod83.z.string().nullable(),
     security: SecurityFlagsSchema.nullable()
   }),
-  balance: import_zod81.z.number(),
-  rawBalance: import_zod81.z.string()
+  balance: import_zod83.z.number(),
+  rawBalance: import_zod83.z.string(),
+  lamports: import_zod83.z.string().nullable().optional()
 });
-var WalletHoldingsResponseSchema = import_zod81.z.object({
-  data: import_zod81.z.array(tokenHoldingSchema)
+var WalletHoldingsResponseSchema = import_zod83.z.object({
+  data: import_zod83.z.array(tokenHoldingSchema)
 });
 // src/wss/aggregated-feed/FeedSchema.ts
-var import_zod82 = require("zod");
-var FeedPayloadSchema = import_zod82.z.discriminatedUnion("kind", [
-  import_zod82.z.object({
-    kind: import_zod82.z.literal("asset_ids"),
-    asset_ids: import_zod82.z.array(import_zod82.z.number()).optional(),
-    quote_id: import_zod82.z.number().optional().nullable()
+var import_zod84 = require("zod");
+var FeedPayloadSchema = import_zod84.z.discriminatedUnion("kind", [
+  import_zod84.z.object({
+    kind: import_zod84.z.literal("asset_ids"),
+    asset_ids: import_zod84.z.array(import_zod84.z.number()).optional(),
+    quote_id: import_zod84.z.number().optional().nullable()
   }),
-  import_zod82.z.object({
-    kind: import_zod82.z.literal("address"),
-    tokens: import_zod82.z.array(import_zod82.z.object({
-      blockchain: import_zod82.z.string(),
-      address: import_zod82.z.string()
+  import_zod84.z.object({
+    kind: import_zod84.z.literal("address"),
+    tokens: import_zod84.z.array(import_zod84.z.object({
+      blockchain: import_zod84.z.string(),
+      address: import_zod84.z.string()
     })),
-    quote: import_zod82.z.object({
-      address: import_zod82.z.string(),
-      blockchain: import_zod82.z.string()
+    quote: import_zod84.z.object({
+      address: import_zod84.z.string(),
+      blockchain: import_zod84.z.string()
     }).optional()
   }),
-  import_zod82.z.object({
-    kind: import_zod82.z.literal("all")
+  import_zod84.z.object({
+    kind: import_zod84.z.literal("all")
   })
 ]);
-var FeedAssetIdSchema = import_zod82.z.object({
-  asset_ids: import_zod82.z.array(import_zod82.z.number()).optional(),
-  quote_id: import_zod82.z.number().optional().nullable()
-});
-var FeedTokenSchema = import_zod82.z.object({
-  tokens: import_zod82.z.array(import_zod82.z.object({
-    blockchain: import_zod82.z.string(),
-    address: import_zod82.z.string()
+var FeedAssetIdSchema = import_zod84.z.object({
+  asset_ids: import_zod84.z.array(import_zod84.z.number()).optional(),
+  quote_id: import_zod84.z.number().optional().nullable()
+});
+var FeedTokenSchema = import_zod84.z.object({
+  tokens: import_zod84.z.array(import_zod84.z.object({
+    blockchain: import_zod84.z.string(),
+    address: import_zod84.z.string()
   })),
-  quote: import_zod82.z.object({
-    address: import_zod82.z.string(),
-    blockchain: import_zod82.z.string()
+  quote: import_zod84.z.object({
+    address: import_zod84.z.string(),
+    blockchain: import_zod84.z.string()
   }).optional()
 });
 // src/wss/BalancePayloadSchema.ts
-var import_zod83 = require("zod");
-var BalanceItemSchema = import_zod83.z.object({
-  wallet: import_zod83.z.string(),
-  token: import_zod83.z.string(),
-  blockchain: import_zod83.z.string()
+var import_zod85 = require("zod");
+var BalanceItemSchema = import_zod85.z.object({
+  wallet: import_zod85.z.string(),
+  token: import_zod85.z.string(),
+  blockchain: import_zod85.z.string()
 });
-var BalancePayloadSchema = import_zod83.z.object({
-  items: import_zod83.z.array(BalanceItemSchema),
-  subscriptionId: import_zod83.z.string().optional(),
-  subscriptionTracking: import_zod83.z.union([import_zod83.z.boolean(), import_zod83.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+var BalancePayloadSchema = import_zod85.z.object({
+  items: import_zod85.z.array(BalanceItemSchema),
+  subscriptionId: import_zod85.z.string().optional(),
+  subscriptionTracking: import_zod85.z.union([import_zod85.z.boolean(), import_zod85.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 // src/wss/FastTradePayloadSchema.ts
-var import_zod84 = require("zod");
-var FastTradesPayloadSchema = import_zod84.z.object({
-  assetMode: import_zod84.z.coerce.boolean().default(false),
-  items: import_zod84.z.array(import_zod84.z.object({
-    address: import_zod84.z.string(),
-    blockchain: import_zod84.z.string()
+var import_zod86 = require("zod");
+var FastTradesPayloadSchema = import_zod86.z.object({
+  assetMode: import_zod86.z.coerce.boolean().default(false),
+  items: import_zod86.z.array(import_zod86.z.object({
+    address: import_zod86.z.string(),
+    blockchain: import_zod86.z.string()
   })),
-  subscriptionId: import_zod84.z.string().optional(),
-  subscriptionTracking: import_zod84.z.union([import_zod84.z.boolean(), import_zod84.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+  subscriptionId: import_zod86.z.string().optional(),
+  subscriptionTracking: import_zod86.z.union([import_zod86.z.boolean(), import_zod86.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 // src/wss/FundingPayloadSchema.ts
-var import_zod85 = require("zod");
-var FundingPayloadSchema = import_zod85.z.object({
-  symbol: import_zod85.z.string(),
-  quote: import_zod85.z.string().optional(),
-  exchange: import_zod85.z.string().optional().transform((val) => {
-    const validExchanges = ["binance", "bybit", "hyperliquid", "deribit", "okx"];
+var import_zod87 = require("zod");
+var FundingPayloadSchema = import_zod87.z.object({
+  symbol: import_zod87.z.string(),
+  quote: import_zod87.z.string().optional(),
+  exchange: import_zod87.z.string().optional().transform((val) => {
+    const validExchanges = ["binance", "bybit", "hyperliquid", "deribit", "okx", "gate"];
     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_zod85.z.number().optional().default(5),
-  subscriptionId: import_zod85.z.string().optional(),
-  subscriptionTracking: import_zod85.z.string().optional()
+  interval: import_zod87.z.number().optional().default(5),
+  subscriptionId: import_zod87.z.string().optional(),
+  subscriptionTracking: import_zod87.z.string().optional()
 });
 // src/wss/HoldersPayloadSchema.ts
-var import_zod86 = require("zod");
-var HoldersPayloadSchema = import_zod86.z.object({
-  tokens: import_zod86.z.array(import_zod86.z.object({
-    address: import_zod86.z.string(),
-    blockchain: import_zod86.z.string()
+var import_zod88 = require("zod");
+var HoldersPayloadSchema = import_zod88.z.object({
+  tokens: import_zod88.z.array(import_zod88.z.object({
+    address: import_zod88.z.string(),
+    blockchain: import_zod88.z.string()
   })),
-  subscriptionId: import_zod86.z.string().optional(),
-  subscriptionTracking: import_zod86.z.union([import_zod86.z.boolean(), import_zod86.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+  subscriptionId: import_zod88.z.string().optional(),
+  subscriptionTracking: import_zod88.z.union([import_zod88.z.boolean(), import_zod88.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 // src/wss/MarketDetailsPayloadSchema.ts
-var import_zod87 = require("zod");
-var MarketDetailsPayloadSchema = import_zod87.z.object({
-  pools: import_zod87.z.array(import_zod87.z.object({
-    address: import_zod87.z.string(),
-    blockchain: import_zod87.z.string()
+var import_zod89 = require("zod");
+var MarketDetailsPayloadSchema = import_zod89.z.object({
+  pools: import_zod89.z.array(import_zod89.z.object({
+    address: import_zod89.z.string(),
+    blockchain: import_zod89.z.string()
   })),
-  subscriptionId: import_zod87.z.string().optional(),
-  subscriptionTracking: import_zod87.z.union([import_zod87.z.boolean(), import_zod87.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+  subscriptionId: import_zod89.z.string().optional(),
+  subscriptionTracking: import_zod89.z.union([import_zod89.z.boolean(), import_zod89.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 // src/wss/MarketPayloadSchema.ts
-var import_zod88 = require("zod");
-var MarketPayloadSchema = import_zod88.z.object({
-  interval: import_zod88.z.number().default(30),
-  subscriptionId: import_zod88.z.string().optional(),
-  assets: import_zod88.z.array(import_zod88.z.union([
-    import_zod88.z.object({ name: import_zod88.z.string() }),
-    import_zod88.z.object({ symbol: import_zod88.z.string() }),
-    import_zod88.z.object({
-      address: import_zod88.z.string(),
-      blockchain: import_zod88.z.string()
+var import_zod90 = require("zod");
+var MarketPayloadSchema = import_zod90.z.object({
+  interval: import_zod90.z.number().default(30),
+  subscriptionId: import_zod90.z.string().optional(),
+  assets: import_zod90.z.array(import_zod90.z.union([
+    import_zod90.z.object({ name: import_zod90.z.string() }),
+    import_zod90.z.object({ symbol: import_zod90.z.string() }),
+    import_zod90.z.object({
+      address: import_zod90.z.string(),
+      blockchain: import_zod90.z.string()
     })
   ])).max(100),
-  subscriptionTracking: import_zod88.z.union([import_zod88.z.boolean(), import_zod88.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+  subscriptionTracking: import_zod90.z.union([import_zod90.z.boolean(), import_zod90.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 // src/wss/OhlcvPayloadSchema.ts
-var import_zod89 = require("zod");
-var OhlcvPayloadSchema = import_zod89.z.object({
-  address: import_zod89.z.string().optional(),
-  subscriptionId: import_zod89.z.string().optional(),
-  blockchain: import_zod89.z.string().optional(),
-  chainId: import_zod89.z.string().optional(),
-  period: import_zod89.z.string().optional().transform((val) => {
+var import_zod91 = require("zod");
+var OhlcvPayloadSchema = import_zod91.z.object({
+  address: import_zod91.z.string().optional(),
+  subscriptionId: import_zod91.z.string().optional(),
+  blockchain: import_zod91.z.string().optional(),
+  chainId: import_zod91.z.string().optional(),
+  period: import_zod91.z.string().optional().transform((val) => {
     if (val) {
       return normalizePeriod(val);
     }
     return "5m";
   }),
-  asset: import_zod89.z.string().optional(),
-  currentPrice: import_zod89.z.string().optional(),
-  mode: import_zod89.z.enum(["asset", "pair"]).optional(),
-  subscriptionTracking: import_zod89.z.union([import_zod89.z.boolean(), import_zod89.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+  asset: import_zod91.z.string().optional(),
+  currentPrice: import_zod91.z.string().optional(),
+  mode: import_zod91.z.enum(["asset", "pair"]).optional(),
+  subscriptionTracking: import_zod91.z.union([import_zod91.z.boolean(), import_zod91.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 // src/wss/PairsPayloadSchema.ts
-var import_zod90 = require("zod");
-var PairsPayloadSchema = import_zod90.z.object({
-  mode: import_zod90.z.enum(["asset", "pair"]).optional().default("pair"),
-  subscriptionId: import_zod90.z.string().optional(),
-  blockchain: import_zod90.z.string().optional(),
-  factory: import_zod90.z.string().optional(),
-  interval: import_zod90.z.number().default(30),
-  address: import_zod90.z.string().optional(),
-  asset: 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 import_zod92 = require("zod");
+var PairsPayloadSchema = import_zod92.z.object({
+  mode: import_zod92.z.enum(["asset", "pair"]).optional().default("pair"),
+  subscriptionId: import_zod92.z.string().optional(),
+  blockchain: import_zod92.z.string().optional(),
+  factory: import_zod92.z.string().optional(),
+  interval: import_zod92.z.number().default(30),
+  address: import_zod92.z.string().optional(),
+  asset: 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/PositionPayloadSchema.ts
-var import_zod91 = require("zod");
-var PositionPayloadSchema = import_zod91.z.object({
-  wallet: import_zod91.z.string(),
-  token: import_zod91.z.string(),
-  blockchain: import_zod91.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)
-});
-var PositionsPayloadSchema = import_zod91.z.object({
-  wallet: import_zod91.z.string(),
-  blockchain: import_zod91.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)
+var import_zod93 = require("zod");
+var PositionPayloadSchema = import_zod93.z.object({
+  wallet: import_zod93.z.string(),
+  token: import_zod93.z.string(),
+  blockchain: import_zod93.z.string(),
+  subscriptionId: import_zod93.z.string().optional(),
+  subscriptionTracking: import_zod93.z.union([import_zod93.z.boolean(), import_zod93.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
+});
+var PositionsPayloadSchema = import_zod93.z.object({
+  wallet: import_zod93.z.string(),
+  blockchain: import_zod93.z.string(),
+  subscriptionId: import_zod93.z.string().optional(),
+  subscriptionTracking: import_zod93.z.union([import_zod93.z.boolean(), import_zod93.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 // src/wss/pulse/PausePulsePayloadSchema.ts
-var import_zod92 = require("zod");
-var PausePulsePayloadSchema = import_zod92.z.object({
-  action: import_zod92.z.enum(["pause", "unpause"]),
-  views: import_zod92.z.array(import_zod92.z.string()).min(1)
+var import_zod94 = require("zod");
+var PausePulsePayloadSchema = import_zod94.z.object({
+  action: import_zod94.z.enum(["pause", "unpause"]),
+  views: import_zod94.z.array(import_zod94.z.string()).min(1)
 });
 // src/wss/stream/StreamPayloadSchema.ts
-var import_zod94 = require("zod");
+var import_zod96 = require("zod");
 
 // src/utils/schemas/Filter.ts
-var import_zod93 = require("zod");
-var BaseFilter = import_zod93.z.object({
-  eq: import_zod93.z.tuple([import_zod93.z.string(), import_zod93.z.union([import_zod93.z.string(), import_zod93.z.number(), import_zod93.z.boolean(), import_zod93.z.null()])]).optional(),
-  neq: import_zod93.z.tuple([import_zod93.z.string(), import_zod93.z.union([import_zod93.z.string(), import_zod93.z.number(), import_zod93.z.boolean(), import_zod93.z.null()])]).optional(),
-  lt: import_zod93.z.tuple([import_zod93.z.string(), import_zod93.z.coerce.number()]).optional(),
-  lte: import_zod93.z.tuple([import_zod93.z.string(), import_zod93.z.coerce.number()]).optional(),
-  gt: import_zod93.z.tuple([import_zod93.z.string(), import_zod93.z.coerce.number()]).optional(),
-  gte: import_zod93.z.tuple([import_zod93.z.string(), import_zod93.z.coerce.number()]).optional(),
-  in: import_zod93.z.tuple([
-    import_zod93.z.string(),
-    import_zod93.z.union([
-      import_zod93.z.string(),
-      import_zod93.z.number(),
-      import_zod93.z.boolean(),
-      import_zod93.z.null(),
-      import_zod93.z.array(import_zod93.z.union([import_zod93.z.string(), import_zod93.z.number(), import_zod93.z.boolean(), import_zod93.z.null()]))
+var import_zod95 = require("zod");
+var BaseFilter2 = import_zod95.z.object({
+  eq: import_zod95.z.tuple([import_zod95.z.string(), import_zod95.z.union([import_zod95.z.string(), import_zod95.z.number(), import_zod95.z.boolean(), import_zod95.z.null()])]).optional(),
+  neq: import_zod95.z.tuple([import_zod95.z.string(), import_zod95.z.union([import_zod95.z.string(), import_zod95.z.number(), import_zod95.z.boolean(), import_zod95.z.null()])]).optional(),
+  lt: import_zod95.z.tuple([import_zod95.z.string(), import_zod95.z.coerce.number()]).optional(),
+  lte: import_zod95.z.tuple([import_zod95.z.string(), import_zod95.z.coerce.number()]).optional(),
+  gt: import_zod95.z.tuple([import_zod95.z.string(), import_zod95.z.coerce.number()]).optional(),
+  gte: import_zod95.z.tuple([import_zod95.z.string(), import_zod95.z.coerce.number()]).optional(),
+  in: import_zod95.z.tuple([
+    import_zod95.z.string(),
+    import_zod95.z.union([
+      import_zod95.z.string(),
+      import_zod95.z.number(),
+      import_zod95.z.boolean(),
+      import_zod95.z.null(),
+      import_zod95.z.array(import_zod95.z.union([import_zod95.z.string(), import_zod95.z.number(), import_zod95.z.boolean(), import_zod95.z.null()]))
     ])
   ]).optional()
 });
-var Filter = BaseFilter.and(import_zod93.z.union([
-  BaseFilter.extend({ and: import_zod93.z.undefined(), or: import_zod93.z.undefined() }),
-  BaseFilter.extend({ and: import_zod93.z.array(import_zod93.z.lazy(() => Filter)), or: import_zod93.z.undefined() }),
-  BaseFilter.extend({ and: import_zod93.z.undefined(), or: import_zod93.z.array(import_zod93.z.lazy(() => Filter)) })
+var Filter2 = BaseFilter2.and(import_zod95.z.union([
+  BaseFilter2.extend({ and: import_zod95.z.undefined(), or: import_zod95.z.undefined() }),
+  BaseFilter2.extend({ and: import_zod95.z.array(import_zod95.z.lazy(() => Filter2)), or: import_zod95.z.undefined() }),
+  BaseFilter2.extend({ and: import_zod95.z.undefined(), or: import_zod95.z.array(import_zod95.z.lazy(() => Filter2)) })
 ]));
-function countOperations(filter) {
+function countOperations2(filter) {
   if (!filter)
     return 0;
   let count = 0;
@@ -6633,44 +6808,44 @@ function countOperations(filter) {
   }
   if ("and" in filter && Array.isArray(filter.and)) {
     for (const child of filter.and) {
-      count += countOperations(child);
+      count += countOperations2(child);
     }
   }
   if ("or" in filter && Array.isArray(filter.or)) {
     for (const child of filter.or) {
-      count += countOperations(child);
+      count += countOperations2(child);
     }
   }
   return count;
 }
-var FilterWithLimit = Filter.superRefine((val, ctx) => {
-  const total = countOperations(val);
+var FilterWithLimit2 = Filter2.superRefine((val, ctx) => {
+  const total = countOperations2(val);
   const max = 1000;
   if (total > max) {
     ctx.addIssue({
-      code: import_zod93.z.ZodIssueCode.custom,
+      code: import_zod95.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.`
     });
   }
 });
-var Filter_default = FilterWithLimit;
+var Filter_default = FilterWithLimit2;
 
 // src/wss/stream/StreamPayloadSchema.ts
-var StreamPayloadSchema = import_zod94.z.object({
+var StreamPayloadSchema = import_zod96.z.object({
   filters: Filter_default.optional(),
-  chainIds: import_zod94.z.array(import_zod94.z.string()).nonempty(),
-  name: import_zod94.z.string().optional(),
-  events: import_zod94.z.array(import_zod94.z.enum(["swap", "transfer", "swap-enriched", "block", "order"])).nonempty(),
-  authorization: import_zod94.z.string(),
-  subscriptionId: import_zod94.z.string().optional(),
-  subscriptionTracking: import_zod94.z.string().optional(),
-  debugSubscriptionId: import_zod94.z.string().optional()
-});
-var UnsubscribeStreamPayloadSchema = import_zod94.z.object({
-  type: import_zod94.z.enum(["stream"]).optional(),
-  subscriptionId: import_zod94.z.string().optional(),
-  personalizedId: import_zod94.z.string().optional(),
-  viewName: import_zod94.z.string().optional()
+  chainIds: import_zod96.z.array(import_zod96.z.string()).nonempty(),
+  name: import_zod96.z.string().optional(),
+  events: import_zod96.z.array(import_zod96.z.enum(["swap", "transfer", "swap-enriched", "block", "order"])).nonempty(),
+  authorization: import_zod96.z.string(),
+  subscriptionId: import_zod96.z.string().optional(),
+  subscriptionTracking: import_zod96.z.string().optional(),
+  debugSubscriptionId: import_zod96.z.string().optional()
+});
+var UnsubscribeStreamPayloadSchema = import_zod96.z.object({
+  type: import_zod96.z.enum(["stream"]).optional(),
+  subscriptionId: import_zod96.z.string().optional(),
+  personalizedId: import_zod96.z.string().optional(),
+  viewName: import_zod96.z.string().optional()
 }).transform((data) => {
   if (data.personalizedId && !data.subscriptionId) {
     return {
@@ -6680,24 +6855,24 @@ var UnsubscribeStreamPayloadSchema = import_zod94.z.object({
   }
   return data;
 }).optional();
-var UpdateStreamPayloadSchema = import_zod94.z.object({
-  subscriptionId: import_zod94.z.string(),
-  authorization: import_zod94.z.string(),
-  mode: import_zod94.z.enum(["merge", "replace"]).default("replace"),
+var UpdateStreamPayloadSchema = import_zod96.z.object({
+  subscriptionId: import_zod96.z.string(),
+  authorization: import_zod96.z.string(),
+  mode: import_zod96.z.enum(["merge", "replace"]).default("replace"),
   filters: Filter_default.optional(),
-  chainIds: import_zod94.z.array(import_zod94.z.string()).optional(),
-  events: import_zod94.z.array(import_zod94.z.string()).optional(),
-  subscriptionTracking: import_zod94.z.string().optional()
+  chainIds: import_zod96.z.array(import_zod96.z.string()).optional(),
+  events: import_zod96.z.array(import_zod96.z.string()).optional(),
+  subscriptionTracking: import_zod96.z.string().optional()
 });
 // src/wss/TokenDetailsPayloadSchema.ts
-var import_zod95 = require("zod");
-var TokenDetailsPayloadSchema = import_zod95.z.object({
-  tokens: import_zod95.z.array(import_zod95.z.object({
-    address: import_zod95.z.string(),
-    blockchain: import_zod95.z.string()
+var import_zod97 = require("zod");
+var TokenDetailsPayloadSchema = import_zod97.z.object({
+  tokens: import_zod97.z.array(import_zod97.z.object({
+    address: import_zod97.z.string(),
+    blockchain: import_zod97.z.string()
   })),
-  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)
+  subscriptionId: import_zod97.z.string().optional(),
+  subscriptionTracking: import_zod97.z.union([import_zod97.z.boolean(), import_zod97.z.string()]).default(false).transform((val) => typeof val === "string" ? val === "true" : val)
 });
 
-//# debugId=B3990E54D55910FC64756E2164756E21
+//# debugId=441E755874017D8064756E2164756E21