@mobula_labs/types 0.1.2 → 0.1.4

package/dist/esm/index.js

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