@surf-ai/sdk 0.1.0

package/dist/react/index.js

@@ -0,0 +1,980 @@
+// src/react/utils.ts
+import { clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+function cn(...inputs) {
+  return twMerge(clsx(inputs));
+}
+
+// src/react/use-toast.ts
+import * as React from "react";
+var TOAST_LIMIT = 1;
+var TOAST_REMOVE_DELAY = 1e6;
+var count = 0;
+function genId() {
+  return (count = (count + 1) % Number.MAX_SAFE_INTEGER).toString();
+}
+var toastTimeouts = /* @__PURE__ */ new Map();
+var listeners = [];
+var memoryState = { toasts: [] };
+function dispatch(action) {
+  memoryState = reducer(memoryState, action);
+  listeners.forEach((l) => l(memoryState));
+}
+function reducer(state, action) {
+  switch (action.type) {
+    case "ADD_TOAST":
+      return { ...state, toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT) };
+    case "UPDATE_TOAST":
+      return { ...state, toasts: state.toasts.map((t) => t.id === action.toast.id ? { ...t, ...action.toast } : t) };
+    case "DISMISS_TOAST": {
+      const { toastId } = action;
+      if (toastId) {
+        if (!toastTimeouts.has(toastId)) {
+          toastTimeouts.set(toastId, setTimeout(() => {
+            toastTimeouts.delete(toastId);
+            dispatch({ type: "REMOVE_TOAST", toastId });
+          }, TOAST_REMOVE_DELAY));
+        }
+      } else {
+        state.toasts.forEach((t) => dispatch({ type: "DISMISS_TOAST", toastId: t.id }));
+      }
+      return { ...state, toasts: state.toasts.map((t) => t.id === toastId || !toastId ? { ...t } : t) };
+    }
+    case "REMOVE_TOAST":
+      return { ...state, toasts: action.toastId ? state.toasts.filter((t) => t.id !== action.toastId) : [] };
+  }
+}
+function toast(props) {
+  const id = genId();
+  dispatch({ type: "ADD_TOAST", toast: { ...props, id } });
+  return { id, dismiss: () => dispatch({ type: "DISMISS_TOAST", toastId: id }), update: (p) => dispatch({ type: "UPDATE_TOAST", toast: { ...p, id } }) };
+}
+function useToast() {
+  const [state, setState] = React.useState(memoryState);
+  React.useEffect(() => {
+    listeners.push(setState);
+    return () => {
+      const i = listeners.indexOf(setState);
+      if (i > -1) listeners.splice(i, 1);
+    };
+  }, []);
+  return { ...state, toast, dismiss: (toastId) => dispatch({ type: "DISMISS_TOAST", toastId }) };
+}
+
+// src/react/hooks/exchange.ts
+import { useQuery } from "@tanstack/react-query";
+
+// src/react/fetch.ts
+var BASE = typeof window !== "undefined" ? (import.meta.env?.BASE_URL || "/").replace(/\/$/, "") : "";
+function normalizePath(path) {
+  return String(path || "").replace(/^\/+/, "").replace(/^(?:proxy\/)+/, "");
+}
+async function fetchWithRetry(url, init, retries = 1) {
+  for (let attempt = 0; attempt <= retries; attempt++) {
+    const res = await fetch(url, init);
+    if (!res.ok) {
+      const text2 = await res.text();
+      throw new Error(`API error ${res.status}: ${text2.slice(0, 200)}`);
+    }
+    const text = await res.text();
+    if (text) return JSON.parse(text);
+    if (attempt < retries) await new Promise((r) => setTimeout(r, 1e3));
+  }
+  throw new Error(`Empty response from ${url}`);
+}
+async function proxyGet(path, params) {
+  const cleaned = {};
+  if (params) {
+    for (const [k, v] of Object.entries(params)) {
+      if (v != null) cleaned[k] = String(v);
+    }
+  }
+  const qs = Object.keys(cleaned).length ? "?" + new URLSearchParams(cleaned).toString() : "";
+  return fetchWithRetry(`${BASE}/proxy/${normalizePath(path)}${qs}`);
+}
+async function proxyPost(path, body) {
+  return fetchWithRetry(`${BASE}/proxy/${normalizePath(path)}`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: body ? JSON.stringify(body) : void 0
+  });
+}
+
+// src/react/hooks/exchange.ts
+function useExchangeDepth(params) {
+  return useQuery({
+    queryKey: ["exchange-depth", params],
+    queryFn: () => proxyGet("exchange/depth", params)
+  });
+}
+function useExchangeFundingHistory(params) {
+  return useQuery({
+    queryKey: ["exchange-funding-history", params],
+    queryFn: () => proxyGet("exchange/funding-history", params)
+  });
+}
+function useExchangeKlines(params) {
+  return useQuery({
+    queryKey: ["exchange-klines", params],
+    queryFn: () => proxyGet("exchange/klines", params)
+  });
+}
+function useExchangeLongShortRatio(params) {
+  return useQuery({
+    queryKey: ["exchange-long-short-ratio", params],
+    queryFn: () => proxyGet("exchange/long-short-ratio", params)
+  });
+}
+function useExchangeMarkets(params) {
+  return useQuery({
+    queryKey: ["exchange-markets", params],
+    queryFn: () => proxyGet("exchange/markets", params)
+  });
+}
+function useExchangePerp(params) {
+  return useQuery({
+    queryKey: ["exchange-perp", params],
+    queryFn: () => proxyGet("exchange/perp", params)
+  });
+}
+function useExchangePrice(params) {
+  return useQuery({
+    queryKey: ["exchange-price", params],
+    queryFn: () => proxyGet("exchange/price", params)
+  });
+}
+
+// src/react/hooks/fund.ts
+import { useQuery as useQuery2, useInfiniteQuery as useInfiniteQuery2 } from "@tanstack/react-query";
+function useFundDetail(params) {
+  return useQuery2({
+    queryKey: ["fund-detail", params],
+    queryFn: () => proxyGet("fund/detail", params)
+  });
+}
+function useInfiniteFundPortfolio(params) {
+  return useInfiniteQuery2({
+    queryKey: ["fund-portfolio", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("fund/portfolio", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfiniteFundRanking(params) {
+  return useInfiniteQuery2({
+    queryKey: ["fund-ranking", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("fund/ranking", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+
+// src/react/hooks/kalshi.ts
+import { useQuery as useQuery3, useInfiniteQuery as useInfiniteQuery3 } from "@tanstack/react-query";
+function useInfiniteKalshiEvents(params) {
+  return useInfiniteQuery3({
+    queryKey: ["kalshi-events", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("kalshi/events", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfiniteKalshiMarkets(params) {
+  return useInfiniteQuery3({
+    queryKey: ["kalshi-markets", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("kalshi/markets", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useKalshiOpenInterest(params) {
+  return useQuery3({
+    queryKey: ["kalshi-open-interest", params],
+    queryFn: () => proxyGet("kalshi/open-interest", params)
+  });
+}
+function useKalshiPrices(params) {
+  return useQuery3({
+    queryKey: ["kalshi-prices", params],
+    queryFn: () => proxyGet("kalshi/prices", params)
+  });
+}
+function useInfiniteKalshiRanking(params) {
+  return useInfiniteQuery3({
+    queryKey: ["kalshi-ranking", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("kalshi/ranking", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfiniteKalshiTrades(params) {
+  return useInfiniteQuery3({
+    queryKey: ["kalshi-trades", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("kalshi/trades", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useKalshiVolumes(params) {
+  return useQuery3({
+    queryKey: ["kalshi-volumes", params],
+    queryFn: () => proxyGet("kalshi/volumes", params)
+  });
+}
+
+// src/react/hooks/market.ts
+import { useQuery as useQuery4, useInfiniteQuery as useInfiniteQuery4 } from "@tanstack/react-query";
+function useMarketEtf(params) {
+  return useQuery4({
+    queryKey: ["market-etf", params],
+    queryFn: () => proxyGet("market/etf", params)
+  });
+}
+function useMarketFearGreed(params) {
+  return useQuery4({
+    queryKey: ["market-fear-greed", params],
+    queryFn: () => proxyGet("market/fear-greed", params)
+  });
+}
+function useMarketFutures(params) {
+  return useQuery4({
+    queryKey: ["market-futures", params],
+    queryFn: () => proxyGet("market/futures", params)
+  });
+}
+function useMarketLiquidationChart(params) {
+  return useQuery4({
+    queryKey: ["market-liquidation-chart", params],
+    queryFn: () => proxyGet("market/liquidation-chart", params)
+  });
+}
+function useMarketLiquidationExchangeList(params) {
+  return useQuery4({
+    queryKey: ["market-liquidation-exchange-list", params],
+    queryFn: () => proxyGet("market/liquidation-exchange-list", params)
+  });
+}
+function useMarketLiquidationOrder(params) {
+  return useQuery4({
+    queryKey: ["market-liquidation-order", params],
+    queryFn: () => proxyGet("market/liquidation-order", params)
+  });
+}
+function useMarketOnchainIndicator(params) {
+  return useQuery4({
+    queryKey: ["market-onchain-indicator", params],
+    queryFn: () => proxyGet("market/onchain-indicator", params)
+  });
+}
+function useMarketOptions(params) {
+  return useQuery4({
+    queryKey: ["market-options", params],
+    queryFn: () => proxyGet("market/options", params)
+  });
+}
+function useMarketPrice(params) {
+  return useQuery4({
+    queryKey: ["market-price", params],
+    queryFn: () => proxyGet("market/price", params)
+  });
+}
+function useMarketPriceIndicator(params) {
+  return useQuery4({
+    queryKey: ["market-price-indicator", params],
+    queryFn: () => proxyGet("market/price-indicator", params)
+  });
+}
+function useInfiniteMarketRanking(params) {
+  return useInfiniteQuery4({
+    queryKey: ["market-ranking", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("market/ranking", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+
+// src/react/hooks/news.ts
+import { useQuery as useQuery5, useInfiniteQuery as useInfiniteQuery5 } from "@tanstack/react-query";
+function useNewsDetail(params) {
+  return useQuery5({
+    queryKey: ["news-detail", params],
+    queryFn: () => proxyGet("news/detail", params)
+  });
+}
+function useInfiniteNewsFeed(params) {
+  return useInfiniteQuery5({
+    queryKey: ["news-feed", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("news/feed", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+
+// src/react/hooks/onchain.ts
+import { useQuery as useQuery6, useInfiniteQuery as useInfiniteQuery6 } from "@tanstack/react-query";
+function useInfiniteOnchainBridgeRanking(params) {
+  return useInfiniteQuery6({
+    queryKey: ["onchain-bridge-ranking", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("onchain/bridge-ranking", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useOnchainGasPrice(params) {
+  return useQuery6({
+    queryKey: ["onchain-gas-price", params],
+    queryFn: () => proxyGet("onchain/gas-price", params)
+  });
+}
+function useOnchainStructuredQuery(params) {
+  return useQuery6({
+    queryKey: ["onchain-structured-query", params],
+    queryFn: () => proxyPost("onchain/structured-query", params)
+  });
+}
+function useOnchainSchema() {
+  return useQuery6({
+    queryKey: ["onchain-schema"],
+    queryFn: () => proxyGet("onchain/schema")
+  });
+}
+function useOnchainSql(params) {
+  return useQuery6({
+    queryKey: ["onchain-sql", params],
+    queryFn: () => proxyPost("onchain/sql", params)
+  });
+}
+function useOnchainTx(params) {
+  return useQuery6({
+    queryKey: ["onchain-tx", params],
+    queryFn: () => proxyGet("onchain/tx", params)
+  });
+}
+function useInfiniteOnchainYieldRanking(params) {
+  return useInfiniteQuery6({
+    queryKey: ["onchain-yield-ranking", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("onchain/yield-ranking", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+
+// src/react/hooks/polymarket.ts
+import { useQuery as useQuery7, useInfiniteQuery as useInfiniteQuery7 } from "@tanstack/react-query";
+function useInfinitePolymarketActivity(params) {
+  return useInfiniteQuery7({
+    queryKey: ["polymarket-activity", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("polymarket/activity", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfinitePolymarketEvents(params) {
+  return useInfiniteQuery7({
+    queryKey: ["polymarket-events", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("polymarket/events", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfinitePolymarketMarkets(params) {
+  return useInfiniteQuery7({
+    queryKey: ["polymarket-markets", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("polymarket/markets", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function usePolymarketOpenInterest(params) {
+  return useQuery7({
+    queryKey: ["polymarket-open-interest", params],
+    queryFn: () => proxyGet("polymarket/open-interest", params)
+  });
+}
+function useInfinitePolymarketPositions(params) {
+  return useInfiniteQuery7({
+    queryKey: ["polymarket-positions", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("polymarket/positions", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function usePolymarketPrices(params) {
+  return useQuery7({
+    queryKey: ["polymarket-prices", params],
+    queryFn: () => proxyGet("polymarket/prices", params)
+  });
+}
+function useInfinitePolymarketRanking(params) {
+  return useInfiniteQuery7({
+    queryKey: ["polymarket-ranking", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("polymarket/ranking", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfinitePolymarketTrades(params) {
+  return useInfiniteQuery7({
+    queryKey: ["polymarket-trades", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("polymarket/trades", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function usePolymarketVolumes(params) {
+  return useQuery7({
+    queryKey: ["polymarket-volumes", params],
+    queryFn: () => proxyGet("polymarket/volumes", params)
+  });
+}
+
+// src/react/hooks/prediction_market.ts
+import { useInfiniteQuery as useInfiniteQuery8 } from "@tanstack/react-query";
+function useInfinitePredictionMarketCategoryMetrics(params) {
+  return useInfiniteQuery8({
+    queryKey: ["prediction-market-category-metrics", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("prediction-market/category-metrics", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+
+// src/react/hooks/project.ts
+import { useQuery as useQuery9, useInfiniteQuery as useInfiniteQuery9 } from "@tanstack/react-query";
+function useInfiniteProjectDefiMetrics(params) {
+  return useInfiniteQuery9({
+    queryKey: ["project-defi-metrics", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("project/defi-metrics", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfiniteProjectDefiRanking(params) {
+  return useInfiniteQuery9({
+    queryKey: ["project-defi-ranking", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("project/defi-ranking", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useProjectDetail(params) {
+  return useQuery9({
+    queryKey: ["project-detail", params],
+    queryFn: () => proxyGet("project/detail", params)
+  });
+}
+
+// src/react/hooks/search.ts
+import { useQuery as useQuery10, useInfiniteQuery as useInfiniteQuery10 } from "@tanstack/react-query";
+function useInfiniteSearchAirdrop(params) {
+  return useInfiniteQuery10({
+    queryKey: ["search-airdrop", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("search/airdrop", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfiniteSearchEvents(params) {
+  return useInfiniteQuery10({
+    queryKey: ["search-events", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("search/events", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfiniteSearchFund(params) {
+  return useInfiniteQuery10({
+    queryKey: ["search-fund", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("search/fund", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfiniteSearchKalshi(params) {
+  return useInfiniteQuery10({
+    queryKey: ["search-kalshi", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("search/kalshi", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useSearchNews(params) {
+  return useQuery10({
+    queryKey: ["search-news", params],
+    queryFn: () => proxyGet("search/news", params)
+  });
+}
+function useInfiniteSearchPolymarket(params) {
+  return useInfiniteQuery10({
+    queryKey: ["search-polymarket", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("search/polymarket", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfiniteSearchProject(params) {
+  return useInfiniteQuery10({
+    queryKey: ["search-project", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("search/project", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfiniteSearchSocialPeople(params) {
+  return useInfiniteQuery10({
+    queryKey: ["search-social-people", params],
+    queryFn: ({ pageParam }) => proxyGet("search/social-people", { ...params, cursor: pageParam || void 0 }),
+    initialPageParam: "",
+    getNextPageParam: (last) => last?.meta?.has_more ? last.meta.next_cursor : void 0
+  });
+}
+function useInfiniteSearchSocialPosts(params) {
+  return useInfiniteQuery10({
+    queryKey: ["search-social-posts", params],
+    queryFn: ({ pageParam }) => proxyGet("search/social-posts", { ...params, cursor: pageParam || void 0 }),
+    initialPageParam: "",
+    getNextPageParam: (last) => last?.meta?.has_more ? last.meta.next_cursor : void 0
+  });
+}
+function useInfiniteSearchWallet(params) {
+  return useInfiniteQuery10({
+    queryKey: ["search-wallet", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("search/wallet", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfiniteSearchWeb(params) {
+  return useInfiniteQuery10({
+    queryKey: ["search-web", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("search/web", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+
+// src/react/hooks/social.ts
+import { useQuery as useQuery11, useInfiniteQuery as useInfiniteQuery11 } from "@tanstack/react-query";
+function useSocialDetail(params) {
+  return useQuery11({
+    queryKey: ["social-detail", params],
+    queryFn: () => proxyGet("social/detail", params)
+  });
+}
+function useSocialMindshare(params) {
+  return useQuery11({
+    queryKey: ["social-mindshare", params],
+    queryFn: () => proxyGet("social/mindshare", params)
+  });
+}
+function useInfiniteSocialRanking(params) {
+  return useInfiniteQuery11({
+    queryKey: ["social-ranking", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("social/ranking", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useSocialSmartFollowersHistory(params) {
+  return useQuery11({
+    queryKey: ["social-smart-followers-history", params],
+    queryFn: () => proxyGet("social/smart-followers-history", params)
+  });
+}
+function useInfiniteSocialTweetReplies(params) {
+  return useInfiniteQuery11({
+    queryKey: ["social-tweet-replies", params],
+    queryFn: ({ pageParam }) => proxyGet("social/tweet-replies", { ...params, cursor: pageParam || void 0 }),
+    initialPageParam: "",
+    getNextPageParam: (last) => last?.meta?.has_more ? last.meta.next_cursor : void 0
+  });
+}
+function useSocialTweets(params) {
+  return useQuery11({
+    queryKey: ["social-tweets", params],
+    queryFn: () => proxyGet("social/tweets", params)
+  });
+}
+function useSocialUser(params) {
+  return useQuery11({
+    queryKey: ["social-user", params],
+    queryFn: () => proxyGet("social/user", params)
+  });
+}
+function useInfiniteSocialUserFollowers(params) {
+  return useInfiniteQuery11({
+    queryKey: ["social-user-followers", params],
+    queryFn: ({ pageParam }) => proxyGet("social/user-followers", { ...params, cursor: pageParam || void 0 }),
+    initialPageParam: "",
+    getNextPageParam: (last) => last?.meta?.has_more ? last.meta.next_cursor : void 0
+  });
+}
+function useInfiniteSocialUserFollowing(params) {
+  return useInfiniteQuery11({
+    queryKey: ["social-user-following", params],
+    queryFn: ({ pageParam }) => proxyGet("social/user-following", { ...params, cursor: pageParam || void 0 }),
+    initialPageParam: "",
+    getNextPageParam: (last) => last?.meta?.has_more ? last.meta.next_cursor : void 0
+  });
+}
+function useInfiniteSocialUserPosts(params) {
+  return useInfiniteQuery11({
+    queryKey: ["social-user-posts", params],
+    queryFn: ({ pageParam }) => proxyGet("social/user-posts", { ...params, cursor: pageParam || void 0 }),
+    initialPageParam: "",
+    getNextPageParam: (last) => last?.meta?.has_more ? last.meta.next_cursor : void 0
+  });
+}
+function useInfiniteSocialUserReplies(params) {
+  return useInfiniteQuery11({
+    queryKey: ["social-user-replies", params],
+    queryFn: ({ pageParam }) => proxyGet("social/user-replies", { ...params, cursor: pageParam || void 0 }),
+    initialPageParam: "",
+    getNextPageParam: (last) => last?.meta?.has_more ? last.meta.next_cursor : void 0
+  });
+}
+
+// src/react/hooks/token.ts
+import { useQuery as useQuery12, useInfiniteQuery as useInfiniteQuery12 } from "@tanstack/react-query";
+function useInfiniteTokenDexTrades(params) {
+  return useInfiniteQuery12({
+    queryKey: ["token-dex-trades", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("token/dex-trades", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfiniteTokenHolders(params) {
+  return useInfiniteQuery12({
+    queryKey: ["token-holders", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("token/holders", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useTokenTokenomics(params) {
+  return useQuery12({
+    queryKey: ["token-tokenomics", params],
+    queryFn: () => proxyGet("token/tokenomics", params)
+  });
+}
+function useInfiniteTokenTransfers(params) {
+  return useInfiniteQuery12({
+    queryKey: ["token-transfers", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("token/transfers", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+
+// src/react/hooks/wallet.ts
+import { useQuery as useQuery13, useInfiniteQuery as useInfiniteQuery13 } from "@tanstack/react-query";
+function useWalletDetail(params) {
+  return useQuery13({
+    queryKey: ["wallet-detail", params],
+    queryFn: () => proxyGet("wallet/detail", params)
+  });
+}
+function useInfiniteWalletHistory(params) {
+  return useInfiniteQuery13({
+    queryKey: ["wallet-history", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("wallet/history", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useWalletLabelsBatch(params) {
+  return useQuery13({
+    queryKey: ["wallet-labels-batch", params],
+    queryFn: () => proxyGet("wallet/labels-batch", params)
+  });
+}
+function useWalletNetWorth(params) {
+  return useQuery13({
+    queryKey: ["wallet-net-worth", params],
+    queryFn: () => proxyGet("wallet/net-worth", params)
+  });
+}
+function useInfiniteWalletProtocols(params) {
+  return useInfiniteQuery13({
+    queryKey: ["wallet-protocols", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("wallet/protocols", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+function useInfiniteWalletTransfers(params) {
+  return useInfiniteQuery13({
+    queryKey: ["wallet-transfers", params],
+    queryFn: ({ pageParam = 0 }) => proxyGet("wallet/transfers", { ...params, offset: String(pageParam) }),
+    initialPageParam: 0,
+    getNextPageParam: (last) => {
+      const m = last?.meta;
+      if (!m?.total || !m?.limit) return void 0;
+      const next = (m.offset ?? 0) + m.limit;
+      return next < m.total ? next : void 0;
+    }
+  });
+}
+
+// src/react/hooks/web.ts
+import { useQuery as useQuery14 } from "@tanstack/react-query";
+function useWebFetch(params) {
+  return useQuery14({
+    queryKey: ["web-fetch", params],
+    queryFn: () => proxyGet("web/fetch", params)
+  });
+}
+export {
+  cn,
+  toast,
+  useExchangeDepth,
+  useExchangeFundingHistory,
+  useExchangeKlines,
+  useExchangeLongShortRatio,
+  useExchangeMarkets,
+  useExchangePerp,
+  useExchangePrice,
+  useFundDetail,
+  useInfiniteFundPortfolio,
+  useInfiniteFundRanking,
+  useInfiniteKalshiEvents,
+  useInfiniteKalshiMarkets,
+  useInfiniteKalshiRanking,
+  useInfiniteKalshiTrades,
+  useInfiniteMarketRanking,
+  useInfiniteNewsFeed,
+  useInfiniteOnchainBridgeRanking,
+  useInfiniteOnchainYieldRanking,
+  useInfinitePolymarketActivity,
+  useInfinitePolymarketEvents,
+  useInfinitePolymarketMarkets,
+  useInfinitePolymarketPositions,
+  useInfinitePolymarketRanking,
+  useInfinitePolymarketTrades,
+  useInfinitePredictionMarketCategoryMetrics,
+  useInfiniteProjectDefiMetrics,
+  useInfiniteProjectDefiRanking,
+  useInfiniteSearchAirdrop,
+  useInfiniteSearchEvents,
+  useInfiniteSearchFund,
+  useInfiniteSearchKalshi,
+  useInfiniteSearchPolymarket,
+  useInfiniteSearchProject,
+  useInfiniteSearchSocialPeople,
+  useInfiniteSearchSocialPosts,
+  useInfiniteSearchWallet,
+  useInfiniteSearchWeb,
+  useInfiniteSocialRanking,
+  useInfiniteSocialTweetReplies,
+  useInfiniteSocialUserFollowers,
+  useInfiniteSocialUserFollowing,
+  useInfiniteSocialUserPosts,
+  useInfiniteSocialUserReplies,
+  useInfiniteTokenDexTrades,
+  useInfiniteTokenHolders,
+  useInfiniteTokenTransfers,
+  useInfiniteWalletHistory,
+  useInfiniteWalletProtocols,
+  useInfiniteWalletTransfers,
+  useKalshiOpenInterest,
+  useKalshiPrices,
+  useKalshiVolumes,
+  useMarketEtf,
+  useMarketFearGreed,
+  useMarketFutures,
+  useMarketLiquidationChart,
+  useMarketLiquidationExchangeList,
+  useMarketLiquidationOrder,
+  useMarketOnchainIndicator,
+  useMarketOptions,
+  useMarketPrice,
+  useMarketPriceIndicator,
+  useNewsDetail,
+  useOnchainGasPrice,
+  useOnchainSchema,
+  useOnchainSql,
+  useOnchainStructuredQuery,
+  useOnchainTx,
+  usePolymarketOpenInterest,
+  usePolymarketPrices,
+  usePolymarketVolumes,
+  useProjectDetail,
+  useSearchNews,
+  useSocialDetail,
+  useSocialMindshare,
+  useSocialSmartFollowersHistory,
+  useSocialTweets,
+  useSocialUser,
+  useToast,
+  useTokenTokenomics,
+  useWalletDetail,
+  useWalletLabelsBatch,
+  useWalletNetWorth,
+  useWebFetch
+};