@surf-ai/sdk 0.1.0

package/dist/server/index.cjs

@@ -0,0 +1,798 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/data/client.ts
+var client_exports = {};
+__export(client_exports, {
+  get: () => get,
+  post: () => post
+});
+function env(surfName, legacyName) {
+  return process.env[surfName] || process.env[legacyName];
+}
+function resolveConfig() {
+  const proxyBase = env("SURF_SANDBOX_PROXY_BASE", "DATA_PROXY_BASE");
+  if (proxyBase) {
+    return { baseUrl: proxyBase, headers: {} };
+  }
+  const gatewayUrl = env("SURF_DEPLOYED_GATEWAY_URL", "GATEWAY_URL");
+  const appToken = env("SURF_DEPLOYED_APP_TOKEN", "APP_TOKEN");
+  if (gatewayUrl && appToken) {
+    return {
+      baseUrl: `${gatewayUrl.replace(/\/$/, "")}/gateway/v1`,
+      headers: { Authorization: `Bearer ${appToken}` }
+    };
+  }
+  return { baseUrl: DEFAULT_PUBLIC_URL, headers: {} };
+}
+function normalizePath(path2) {
+  return String(path2 || "").replace(/^\/+/, "").replace(/^(?:proxy\/)+/, "");
+}
+async function fetchJson(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 get(path2, params) {
+  const config = resolveConfig();
+  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 fetchJson(`${config.baseUrl}/${normalizePath(path2)}${qs}`, {
+    headers: config.headers
+  });
+}
+async function post(path2, body) {
+  const config = resolveConfig();
+  return fetchJson(`${config.baseUrl}/${normalizePath(path2)}`, {
+    method: "POST",
+    headers: { ...config.headers, "Content-Type": "application/json" },
+    body: body ? JSON.stringify(body) : void 0
+  });
+}
+var DEFAULT_PUBLIC_URL;
+var init_client = __esm({
+  "src/data/client.ts"() {
+    "use strict";
+    DEFAULT_PUBLIC_URL = "https://api.ask.surf/gateway/v1";
+  }
+});
+
+// src/server/index.ts
+var server_exports = {};
+__export(server_exports, {
+  createServer: () => createServer,
+  dataApi: () => dataApi
+});
+module.exports = __toCommonJS(server_exports);
+
+// src/server/runtime.ts
+var import_express = __toESM(require("express"), 1);
+var import_cors = __toESM(require("cors"), 1);
+var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_http_proxy_middleware = require("http-proxy-middleware");
+var import_croner = require("croner");
+function createServer(options = {}) {
+  const port = options.port || parseInt(process.env.PORT || "3001", 10);
+  const routesDir = options.routesDir || import_path.default.join(process.cwd(), "routes");
+  const cronDir = options.cronDir || process.cwd();
+  const enableProxy = options.proxy !== false;
+  const app = (0, import_express.default)();
+  app.use((0, import_cors.default)());
+  if (enableProxy) {
+    setupProxy(app, port);
+  }
+  app.use(import_express.default.json());
+  app.get("/api/health", (_req, res) => {
+    res.json({ status: "ok" });
+  });
+  if (import_fs.default.existsSync(routesDir)) {
+    for (const file of import_fs.default.readdirSync(routesDir)) {
+      if (!file.endsWith(".js") && !file.endsWith(".ts")) continue;
+      const name = file.replace(/\.(js|ts)$/, "");
+      try {
+        const route = require(import_path.default.join(routesDir, file));
+        const handler = route.default || route;
+        if (typeof handler === "function") {
+          app.use(`/api/${name}`, handler);
+          console.log(`Route registered: /api/${name}`);
+        }
+      } catch (err) {
+        console.error(`Failed to load route ${file}: ${err.message}`);
+      }
+    }
+  }
+  const schemaDir = options.routesDir ? import_path.default.join(options.routesDir, "..", "db") : import_path.default.join(process.cwd(), "db");
+  setupSchemaSync(app, schemaDir);
+  setupCron(app, cronDir);
+  return {
+    app,
+    port,
+    async start() {
+      return new Promise((resolve) => {
+        app.listen(port, async () => {
+          console.log(`Backend listening on port ${port}`);
+          await schemaSync.run();
+          schemaSync.watch();
+          resolve();
+        });
+      });
+    }
+  };
+}
+function env2(surfName, legacyName) {
+  return process.env[surfName] || process.env[legacyName];
+}
+function setupProxy(app, port) {
+  const gatewayUrl = env2("SURF_DEPLOYED_GATEWAY_URL", "GATEWAY_URL");
+  const appToken = env2("SURF_DEPLOYED_APP_TOKEN", "APP_TOKEN");
+  const proxyBase = env2("SURF_SANDBOX_PROXY_BASE", "DATA_PROXY_BASE");
+  const isDeployed = Boolean(gatewayUrl && appToken);
+  const bufferResponse = (0, import_http_proxy_middleware.responseInterceptor)(async (buf) => buf);
+  if (isDeployed) {
+    app.use("/proxy", (0, import_http_proxy_middleware.createProxyMiddleware)({
+      target: gatewayUrl,
+      changeOrigin: true,
+      selfHandleResponse: true,
+      pathRewrite: (p) => "/gateway/v1" + p,
+      headers: {
+        Authorization: `Bearer ${appToken}`,
+        "Accept-Encoding": "identity"
+      },
+      on: { proxyRes: bufferResponse }
+    }));
+    const loopback = `http://127.0.0.1:${port}/proxy`;
+    process.env.SURF_SANDBOX_PROXY_BASE = loopback;
+    process.env.DATA_PROXY_BASE = loopback;
+  } else if (proxyBase) {
+    const target = proxyBase.replace(/\/proxy$/, "");
+    app.use((0, import_http_proxy_middleware.createProxyMiddleware)({
+      target,
+      changeOrigin: true,
+      selfHandleResponse: true,
+      pathFilter: "/proxy",
+      on: {
+        proxyReq: (proxyReq, req) => {
+          console.log(`[proxy] >> ${req.method} ${req.originalUrl}`);
+        },
+        proxyRes: (0, import_http_proxy_middleware.responseInterceptor)(async (buf, proxyRes, req) => {
+          const status = proxyRes.statusCode;
+          const tag = status && status >= 400 ? "ERR" : "OK";
+          console.log(`[proxy] << ${status} ${tag} ${req.method} ${req.originalUrl} bytes=${buf.length}`);
+          return buf;
+        }),
+        error: (err, req, res) => {
+          console.error(`[proxy] !! ${req.method} ${req.originalUrl} error: ${err.message}`);
+          if (!res.headersSent) res.status(502).json({ error: err.message });
+        }
+      }
+    }));
+  }
+}
+var schemaSync = { run: async () => {
+}, watch: () => {
+} };
+function setupSchemaSync(app, schemaDir) {
+  let syncing = false;
+  let schemaReady = false;
+  async function doSyncSchema() {
+    if (syncing) return;
+    syncing = true;
+    try {
+      const schemaPath = import_path.default.join(schemaDir, "schema.js");
+      if (!import_fs.default.existsSync(schemaPath)) return;
+      try {
+        delete require.cache[require.resolve(schemaPath)];
+      } catch {
+      }
+      let schema;
+      try {
+        schema = require(schemaPath);
+      } catch (err) {
+        if (err instanceof SyntaxError) {
+          console.log("DB: schema.js has syntax error, waiting for next change...");
+          return;
+        }
+        if (err.message.includes("Cannot find module") || err.message.includes("is not a function")) {
+          return;
+        }
+        throw err;
+      }
+      let getTableConfig;
+      try {
+        getTableConfig = require("drizzle-orm/pg-core").getTableConfig;
+      } catch {
+        return;
+      }
+      const tables = Object.values(schema).filter(
+        (t) => t && typeof t === "object" && /* @__PURE__ */ Symbol.for("drizzle:Name") in t
+      );
+      if (tables.length === 0) return;
+      const { get: dbGet, post: dbPost } = await Promise.resolve().then(() => (init_client(), client_exports));
+      await dbPost("db/provision");
+      const existing = (await dbGet("db/tables")).map((t) => t.name);
+      const missing = tables.filter((t) => !existing.includes(getTableConfig(t).name));
+      if (missing.length > 0) {
+        const { generateDrizzleJson, generateMigration } = require("drizzle-kit/api");
+        const missingSchema = {};
+        for (const t of missing) missingSchema[getTableConfig(t).name] = t;
+        const sqls = await generateMigration(generateDrizzleJson({}), generateDrizzleJson(missingSchema));
+        for (const sql of sqls) {
+          for (let attempt = 0; attempt < 2; attempt++) {
+            try {
+              await dbPost("db/query", { sql, params: [] });
+              console.log(`DB: Executed: ${sql.slice(0, 80)}...`);
+              break;
+            } catch (err) {
+              if (attempt === 0) {
+                console.warn(`DB: Retrying after: ${err.message}`);
+                await new Promise((r) => setTimeout(r, 1500));
+              } else {
+                console.error(`DB: Failed: ${sql.slice(0, 80)}... \u2014 ${err.message}`);
+              }
+            }
+          }
+        }
+      }
+      const existingTables = tables.filter((t) => existing.includes(getTableConfig(t).name));
+      for (const t of existingTables) {
+        const cfg = getTableConfig(t);
+        try {
+          const live = await dbGet("db/table-schema", { table: cfg.name });
+          const liveCols = new Set((live.columns || []).map((c) => c.name));
+          for (const col of cfg.columns) {
+            if (!liveCols.has(col.name)) {
+              const colType = col.getSQLType();
+              const ddl = `ALTER TABLE "${cfg.name}" ADD COLUMN IF NOT EXISTS "${col.name}" ${colType}`;
+              try {
+                await dbPost("db/query", { sql: ddl, params: [] });
+                console.log(`DB: Added column ${col.name} to ${cfg.name}`);
+              } catch (err) {
+                console.warn(`DB: Failed to add column ${col.name} to ${cfg.name}: ${err.message}`);
+              }
+            }
+          }
+        } catch (err) {
+          console.warn(`DB: Column check failed for ${cfg.name}: ${err.message}`);
+        }
+      }
+    } finally {
+      syncing = false;
+    }
+  }
+  async function syncWithRetry(retries = 3, delay = 2e3) {
+    for (let i = 0; i < retries; i++) {
+      try {
+        await doSyncSchema();
+        return;
+      } catch (err) {
+        console.error(`DB schema sync attempt ${i + 1}/${retries} failed: ${err.message}`);
+        if (i < retries - 1) await new Promise((r) => setTimeout(r, delay * (i + 1)));
+      }
+    }
+    console.error("DB schema sync failed after all retries");
+  }
+  app.post("/api/__sync-schema", async (_req, res) => {
+    try {
+      await syncWithRetry(2, 1500);
+      res.json({ ok: true });
+    } catch (err) {
+      res.status(500).json({ ok: false, error: err.message });
+    }
+  });
+  app.use("/api", (req, res, next) => {
+    if (schemaReady || req.path === "/health" || req.path === "/__sync-schema" || req.path.startsWith("/cron")) return next();
+    res.status(503).json({ error: "Database schema initializing..." });
+  });
+  schemaSync.run = async () => {
+    try {
+      await syncWithRetry();
+      schemaReady = true;
+      console.log("Schema sync complete, API ready");
+    } catch {
+      schemaReady = true;
+      console.warn("Schema sync failed, proceeding anyway");
+    }
+  };
+  schemaSync.watch = () => {
+    const schemaPath = import_path.default.join(schemaDir, "schema.js");
+    if (!import_fs.default.existsSync(schemaPath)) return;
+    let debounce = null;
+    import_fs.default.watchFile(schemaPath, { interval: 2e3 }, () => {
+      if (debounce) clearTimeout(debounce);
+      debounce = setTimeout(async () => {
+        console.log("DB: schema.js changed, re-syncing tables...");
+        try {
+          await syncWithRetry(2, 1500);
+          console.log("DB: schema re-sync complete");
+        } catch (err) {
+          console.error(`DB: schema re-sync failed: ${err.message}`);
+        }
+      }, 1e3);
+    });
+  };
+}
+function setupCron(app, cronDir) {
+  const cronJobs = /* @__PURE__ */ new Map();
+  const cronState = /* @__PURE__ */ new Map();
+  let cronTasks = [];
+  function loadCronJobs() {
+    for (const [, job] of cronJobs) {
+      try {
+        job.stop();
+      } catch (_) {
+      }
+    }
+    cronJobs.clear();
+    const cronPath = import_path.default.join(cronDir, "cron.json");
+    if (!import_fs.default.existsSync(cronPath)) return;
+    let tasks;
+    try {
+      tasks = JSON.parse(import_fs.default.readFileSync(cronPath, "utf-8"));
+    } catch (e) {
+      console.error("Failed to parse cron.json:", e.message);
+      return;
+    }
+    if (!Array.isArray(tasks)) {
+      console.error("cron.json must be an array");
+      return;
+    }
+    cronTasks = tasks;
+    for (const task of tasks) {
+      if (!task.enabled) continue;
+      const timeoutMs = (task.timeout || 300) * 1e3;
+      let handlerMod;
+      try {
+        handlerMod = require(import_path.default.join(cronDir, task.handler));
+      } catch (e) {
+        console.error(`Failed to load cron handler ${task.handler}:`, e.message);
+        continue;
+      }
+      if (typeof handlerMod.handler !== "function") {
+        console.error(`Cron handler ${task.handler} has no handler function`);
+        continue;
+      }
+      if (!cronState.has(task.id)) {
+        cronState.set(task.id, { lastRunAt: null, lastStatus: null, lastError: null });
+      }
+      const job = new import_croner.Cron(task.schedule, async () => {
+        const state = cronState.get(task.id);
+        state.lastRunAt = (/* @__PURE__ */ new Date()).toISOString();
+        try {
+          await Promise.race([
+            Promise.resolve(handlerMod.handler()),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("Cron task timed out")), timeoutMs))
+          ]);
+          state.lastStatus = "success";
+          state.lastError = null;
+          console.log(`Cron [${task.id}] ${task.name}: success`);
+        } catch (e) {
+          state.lastStatus = "error";
+          state.lastError = e.message;
+          console.error(`Cron [${task.id}] ${task.name}: ${e.message}`);
+        }
+      });
+      cronJobs.set(task.id, job);
+      console.log(`Cron registered: [${task.id}] ${task.name} (${task.schedule})`);
+    }
+  }
+  const envFn = (s, l) => process.env[s] || process.env[l];
+  app.use("/api/cron", (req, res, next) => {
+    const appToken = envFn("SURF_DEPLOYED_APP_TOKEN", "APP_TOKEN");
+    if (!appToken) return next();
+    const auth = req.headers.authorization;
+    if (!auth || auth !== `Bearer ${appToken}`) {
+      return res.status(401).json({ error: "Unauthorized" });
+    }
+    next();
+  });
+  app.get("/api/cron", (_req, res) => {
+    res.json(cronTasks.map((t) => {
+      const state = cronState.get(t.id) || { lastRunAt: null, lastStatus: null, lastError: null };
+      const job = cronJobs.get(t.id);
+      return {
+        ...t,
+        lastRunAt: state.lastRunAt,
+        lastStatus: state.lastStatus,
+        lastError: state.lastError,
+        nextRun: job ? job.nextRun()?.toISOString() || null : null
+      };
+    }));
+  });
+  app.post("/api/cron", (req, res) => {
+    const { id, name, schedule, handler, enabled = true, timeout = 300 } = req.body || {};
+    if (!id || !name || !schedule || !handler) {
+      return res.status(400).json({ error: "Missing required fields: id, name, schedule, handler" });
+    }
+    try {
+      const testJob = new import_croner.Cron(schedule);
+      const next1 = testJob.nextRun();
+      const next2 = next1 ? testJob.nextRun(next1) : null;
+      testJob.stop();
+      if (next1 && next2 && next2.getTime() - next1.getTime() < 6e4) {
+        return res.status(400).json({ error: "Minimum interval between runs must be at least 1 minute" });
+      }
+    } catch (err) {
+      return res.status(400).json({ error: `Invalid cron expression: ${err.message}` });
+    }
+    const cronPath = import_path.default.join(cronDir, "cron.json");
+    let tasks = [];
+    try {
+      if (import_fs.default.existsSync(cronPath)) tasks = JSON.parse(import_fs.default.readFileSync(cronPath, "utf8"));
+    } catch {
+      tasks = [];
+    }
+    if (tasks.some((t) => t.id === id)) {
+      return res.status(409).json({ error: `Task with id "${id}" already exists` });
+    }
+    const newTask = { id, name, schedule, handler, enabled, timeout };
+    tasks.push(newTask);
+    import_fs.default.writeFileSync(cronPath, JSON.stringify(tasks, null, 2));
+    loadCronJobs();
+    res.status(201).json(newTask);
+  });
+  app.patch("/api/cron/:id", (req, res) => {
+    const cronPath = import_path.default.join(cronDir, "cron.json");
+    let tasks = [];
+    try {
+      if (import_fs.default.existsSync(cronPath)) tasks = JSON.parse(import_fs.default.readFileSync(cronPath, "utf8"));
+    } catch {
+      tasks = [];
+    }
+    const idx = tasks.findIndex((t) => t.id === req.params.id);
+    if (idx === -1) return res.status(404).json({ error: "Task not found" });
+    const updates = req.body || {};
+    if (updates.schedule) {
+      try {
+        const testJob = new import_croner.Cron(updates.schedule);
+        const next1 = testJob.nextRun();
+        const next2 = next1 ? testJob.nextRun(next1) : null;
+        testJob.stop();
+        if (next1 && next2 && next2.getTime() - next1.getTime() < 6e4) {
+          return res.status(400).json({ error: "Minimum interval between runs must be at least 1 minute" });
+        }
+      } catch (err) {
+        return res.status(400).json({ error: `Invalid cron expression: ${err.message}` });
+      }
+    }
+    tasks[idx] = { ...tasks[idx], ...updates, id: req.params.id };
+    import_fs.default.writeFileSync(cronPath, JSON.stringify(tasks, null, 2));
+    loadCronJobs();
+    res.json(tasks[idx]);
+  });
+  app.delete("/api/cron/:id", (req, res) => {
+    const cronPath = import_path.default.join(cronDir, "cron.json");
+    let tasks = [];
+    try {
+      if (import_fs.default.existsSync(cronPath)) tasks = JSON.parse(import_fs.default.readFileSync(cronPath, "utf8"));
+    } catch {
+      tasks = [];
+    }
+    const idx = tasks.findIndex((t) => t.id === req.params.id);
+    if (idx === -1) return res.status(404).json({ error: "Task not found" });
+    tasks.splice(idx, 1);
+    import_fs.default.writeFileSync(cronPath, JSON.stringify(tasks, null, 2));
+    cronState.delete(req.params.id);
+    loadCronJobs();
+    res.json({ ok: true });
+  });
+  app.post("/api/cron/:id/run", async (req, res) => {
+    const job = cronJobs.get(req.params.id);
+    if (!job) return res.status(404).json({ error: "Task not found or not enabled" });
+    try {
+      job.trigger();
+      res.json({ ok: true, message: `Task ${req.params.id} triggered` });
+    } catch (err) {
+      res.status(500).json({ error: err.message });
+    }
+  });
+  loadCronJobs();
+}
+
+// src/data/data-api.ts
+init_client();
+
+// src/data/categories/exchange.ts
+init_client();
+var exchange = {
+  /** Get order book bid/ask levels with computed stats: spread, spread percentage, mid-price, and total bid/ask depth. Use `limit` to control the number of price levels (1–100, default 20). Set `type=swap` to query perpetual contract order books instead of spot. */
+  depth: (params) => get("exchange/depth", params),
+  /** Get historical funding rate records for a perpetual contract. Use `from` to set the start time and `limit` to control result count. For longer history, paginate by using the last returned timestamp as the next `from` value. Note: not all exchanges support historical queries via `from`; some only return recent data regardless. For the latest funding rate snapshot, see `/exchange/perp?fields=funding`. */
+  funding_history: (params) => get("exchange/funding-history", params),
+  /** Get OHLCV candlestick data with period summary stats (high, low, total volume). Supports 15 intervals from `1m` to `1M`. Use `from` to set the start time and `limit` to control how many candles to return. For longer ranges, paginate by using the last returned candle's timestamp as the next `from` value. Exchange-side limits vary (200–1000 per request). Set `type=swap` to query perpetual contract candles instead of spot. */
+  klines: (params) => get("exchange/klines", params),
+  /** Get historical long/short ratio for a perpetual contract — ratio value, long account percentage, and short account percentage. Use `interval` (`1h`, `4h`, `1d`) for granularity, `from` for start time, and `limit` for result count. For longer history, paginate by using the last returned timestamp as the next `from` value. Note: not all exchanges support historical queries via `from`; some only return recent data regardless. Just pass the base pair (e.g. `pair=BTC/USDT`). For aggregated cross-exchange long/short ratio, see `/market/futures`. */
+  long_short_ratio: (params) => get("exchange/long-short-ratio", params),
+  /** List trading pairs available on an exchange. Filter by `type` (`spot`, `swap`, `future`, `option`) or free-text `search`. Returns pair name, base/quote currencies, market type, active status, and default fee rates. Use the returned `pair` values as the `pair` parameter in other exchange endpoints. */
+  markets: (params) => get("exchange/markets", params),
+  /** Get a combined snapshot of perpetual contract data for a pair. Use `fields` to select which sub-resources to fetch: `funding` (current funding rate, next settlement, mark/index price) and/or `oi` (open interest in contracts and USD). Just pass the base pair (e.g. `pair=BTC/USDT`). The `:USDT` swap suffix is added automatically. */
+  perp: (params) => get("exchange/perp", params),
+  /** Get the real-time ticker for a trading pair — last price, bid/ask, 24h high/low, 24h volume, and 24h price change. Set `type=swap` to query perpetual contract prices instead of spot. For historical price trends, use `/market/price`. */
+  price: (params) => get("exchange/price", params)
+};
+
+// src/data/categories/fund.ts
+init_client();
+var fund = {
+  /** Get a fund's **profile metadata**: X accounts, team members, recent research, and invested project count. This does NOT return the list of investments — use `/fund/portfolio` for that. Lookup by UUID (`id`) or name (`q`). Returns 404 if not found. */
+  detail: (params) => get("fund/detail", params),
+  /** List investment rounds for a fund's portfolio, sorted by date (newest first). A project may appear multiple times if the fund participated in multiple rounds. Each entry includes project name, logo, date, raise amount, and lead investor status. Lookup by UUID (`id`) or name (`q`). */
+  portfolio: (params) => get("fund/portfolio", params),
+  /** List top-ranked funds by metric. Available metrics: `tier` (lower is better), `portfolio_count` (number of invested projects). */
+  ranking: (params) => get("fund/ranking", params)
+};
+
+// src/data/categories/kalshi.ts
+init_client();
+var kalshi = {
+  /** Get Kalshi events with nested markets, optionally filtered by `event_ticker`. Each event includes market count and a list of markets. Data refresh: ~30 minutes */
+  events: (params) => get("kalshi/events", params),
+  /** Get Kalshi markets, optionally filtered by `market_ticker`. Each market includes price, volume, and status. Data refresh: ~30 minutes */
+  markets: (params) => get("kalshi/markets", params),
+  /** Get daily open interest history for a Kalshi market filtered by `time_range`. Data refresh: ~30 minutes */
+  open_interest: (params) => get("kalshi/open-interest", params),
+  /** Get price history for a Kalshi market. Use `interval=1d` for daily OHLC from market reports (~30 min delay), or `interval=latest` for real-time price from trades. Data refresh: ~30 minutes (daily), real-time (latest) */
+  prices: (params) => get("kalshi/prices", params),
+  /** Get top-ranked Kalshi markets by last day's `notional_volume_usd` or `open_interest`. Filter by `status`. Data refresh: ~30 minutes */
+  ranking: (params) => get("kalshi/ranking", params),
+  /** Get individual trade records for a Kalshi market. Filter by `taker_side`, `min_contracts`, and date range. Sort by `timestamp` or `num_contracts`. Data refresh: real-time */
+  trades: (params) => get("kalshi/trades", params),
+  /** Get daily trading volume history for a Kalshi market filtered by `time_range`. Data refresh: ~30 minutes */
+  volumes: (params) => get("kalshi/volumes", params)
+};
+
+// src/data/categories/market.ts
+init_client();
+var market = {
+  /** Get daily ETF flow history for US spot ETFs — net flow (USD), token price, and per-ticker breakdown. Sorted by date descending. `symbol`: `BTC` or `ETH`. */
+  etf: (params) => get("market/etf", params),
+  /** Get Bitcoin Fear & Greed Index history — index value (0-100), classification label, and BTC price at each data point. Sorted newest-first. Use `from`/`to` to filter by date range. */
+  fear_greed: (params) => get("market/fear-greed", params),
+  /** Get futures market data across all tracked tokens — open interest, funding rate, long/short ratio, and 24h volume. Sort by `sort_by` (default: volume_24h). */
+  futures: (params) => get("market/futures", params),
+  /** Get OHLC-style aggregated liquidation data for a token on a specific exchange. Filter by `symbol`, `exchange`, and `interval`. Useful for charting liquidation volume over time. */
+  liquidation_chart: (params) => get("market/liquidation-chart", params),
+  /** Get liquidation breakdown by exchange — total, long, and short volumes in USD. Filter by `symbol` and `time_range` (`1h`, `4h`, `12h`, `24h`). */
+  liquidation_exchange_list: (params) => get("market/liquidation-exchange-list", params),
+  /** Get individual large liquidation orders above a USD threshold (`min_amount`, default 10000). Filter by `exchange` and `symbol`. For aggregate totals and long/short breakdown by exchange, use `/market/liquidation/exchange-list`. For historical liquidation charts, use `/market/liquidation/chart`. */
+  liquidation_order: (params) => get("market/liquidation-order", params),
+  /** Get on-chain indicator time-series for BTC or ETH. Metrics: `nupl`, `sopr`, `mvrv`, `puell-multiple`, `nvm`, `nvt`, `nvt-golden-cross`, `exchange-flows` (inflow/outflow/netflow/reserve). */
+  onchain_indicator: (params) => get("market/onchain-indicator", params),
+  /** Get options market data — open interest, volume, put/call ratio, and max pain price for a `symbol`. */
+  options: (params) => get("market/options", params),
+  /** Get historical price data points for a token. Use `time_range` for predefined windows (`1d`, `7d`, `14d`, `30d`, `90d`, `180d`, `365d`, `max`) or `from`/`to` for a custom date range (Unix timestamp or YYYY-MM-DD). Granularity is automatic: 5-min for 1d, hourly for 7-90d, daily for 180d+. */
+  price: (params) => get("market/price", params),
+  /** Get a technical indicator for a trading pair on a given exchange and interval. Set `from`/`to` for time-series mode, omit for latest value. Use `options` for indicator-specific tuning (e.g. `period:7`, `fast_period:8,slow_period:21,signal_period:5`, `period:10,stddev:1.5`). Indicators: `rsi`, `macd`, `ema`, `sma`, `bbands`, `stoch`, `adx`, `atr`, `cci`, `obv`, `vwap`, `dmi`, `ichimoku`, `supertrend`. */
+  price_indicator: (params) => get("market/price-indicator", params),
+  /** List tokens ranked by metric. Available metrics: `market_cap`, `top_gainers`, `top_losers`, `volume`. Note: `top_gainers` and `top_losers` rank by 24h price change within the top 250 coins by market cap. For circulating supply, FDV, ATH/ATL, use `/project/detail?fields=token_info`. */
+  ranking: (params) => get("market/ranking", params)
+};
+
+// src/data/categories/news.ts
+init_client();
+var news = {
+  /** Returns the full content of a single news article by its ID (returned as `id` in feed and search results). */
+  detail: (params) => get("news/detail", params),
+  /** Browse crypto news from major sources. Filter by `source` (enum), `project`, and time range (`from`/`to`). Sort by `recency` (default) or `trending`. Use the detail endpoint with article `id` for full content. */
+  feed: (params) => get("news/feed", params)
+};
+
+// src/data/categories/onchain.ts
+init_client();
+var onchain = {
+  /** List bridge protocols ranked by total USD volume over a time range. */
+  bridge_ranking: (params) => get("onchain/bridge-ranking", params),
+  /** Get the current gas price for an EVM chain via `eth_gasPrice` JSON-RPC. Returns gas price in both wei (raw) and Gwei (human-readable). **Supported chains:** `ethereum`, `polygon`, `bsc`, `arbitrum`, `optimism`, `base`, `avalanche`, `fantom`, `linea`, `cyber`. */
+  gas_price: (params) => get("onchain/gas-price", params),
+  /** Execute a structured JSON query on blockchain data. No raw SQL needed — specify source, fields, filters, sort, and pagination. All tables live in the **agent** database. Use `GET /v1/onchain/schema` to discover available tables and their columns. - Source format: `agent.<table_name>` like `agent.ethereum_transactions` or `agent.ethereum_dex_trades` - Max 10,000 rows (default 20), 30s timeout. - **Always filter on block_date** — it is the partition key. Without it, queries scan billions of rows and will timeout. - **Data refresh:** ~24 hours. */
+  structured_query: (body) => post("onchain/structured-query", body),
+  /** Get table metadata — database, table, column names, types, and comments for all available on-chain databases. */
+  schema: () => get("onchain/schema"),
+  /** Execute a raw SQL SELECT query against blockchain data. All tables live in the **agent** database. Use `GET /v1/onchain/schema` to discover available tables and their columns before writing queries. */
+  sql: (body) => post("onchain/sql", body),
+  /** Get transaction details by hash. All numeric fields are hex-encoded — use parseInt(hex, 16) to convert. **Supported chains:** `ethereum`, `polygon`, `bsc`, `arbitrum`, `optimism`, `base`, `avalanche`, `fantom`, `linea`, `cyber`. Returns 404 if the transaction is not found. */
+  tx: (params) => get("onchain/tx", params),
+  /** List DeFi yield pools ranked by APY or TVL. Returns the latest snapshot. Filter by protocol. */
+  yield_ranking: (params) => get("onchain/yield-ranking", params)
+};
+
+// src/data/categories/polymarket.ts
+init_client();
+var polymarket = {
+  /** Get trade and redemption activity for a Polymarket wallet. Data refresh: ~30 minutes */
+  activity: (params) => get("polymarket/activity", params),
+  /** Get Polymarket events with nested markets, optionally filtered by `event_slug`. Each event includes aggregated status, volume, and a list of markets with `side_a`/`side_b` outcomes. Data refresh: ~30 minutes */
+  events: (params) => get("polymarket/events", params),
+  /** Get Polymarket markets, optionally filtered by `market_slug`. Each market includes `side_a` and `side_b` outcomes. Current prices are available via `/polymarket/prices` using the `condition_id`. Data refresh: ~30 minutes */
+  markets: (params) => get("polymarket/markets", params),
+  /** Get daily open interest history for a Polymarket market. Data refresh: ~30 minutes */
+  open_interest: (params) => get("polymarket/open-interest", params),
+  /** Get wallet positions on Polymarket markets. Data refresh: ~30 minutes */
+  positions: (params) => get("polymarket/positions", params),
+  /** Get aggregated price history for a Polymarket market. Use `interval=latest` for the most recent price snapshot. Data refresh: ~30 minutes */
+  prices: (params) => get("polymarket/prices", params),
+  /** Get top-ranked Polymarket markets by `volume_24h`, `volume_7d`, `open_interest`, or `trade_count`. Filter by `status` and `end_before`. Data refresh: ~30 minutes */
+  ranking: (params) => get("polymarket/ranking", params),
+  /** Get paginated trade records for a Polymarket market or wallet. Filter by `condition_id` (market) or `address` (wallet), plus `outcome_label`, `min_amount`, and date range. At least one of `condition_id` or `address` is required. Sort by `newest`, `oldest`, or `largest`. Data refresh: ~30 minutes */
+  trades: (params) => get("polymarket/trades", params),
+  /** Get trading volume and trade count history for a Polymarket market. Data refresh: ~30 minutes */
+  volumes: (params) => get("polymarket/volumes", params)
+};
+
+// src/data/categories/prediction_market.ts
+init_client();
+var prediction_market = {
+  /** Get daily notional volume and open interest aggregated by category across Kalshi and Polymarket. Filter by `source` or `category`. Data refresh: daily */
+  category_metrics: (params) => get("prediction-market/category-metrics", params)
+};
+
+// src/data/categories/project.ts
+init_client();
+var project = {
+  /** Get time-series DeFi metrics for a project. Available metrics: `volume`, `fee`, `fees`, `revenue`, `tvl`, `users`. Lookup by UUID (`id`) or name (`q`). Filter by `chain` and date range (`from`/`to`). Returns 404 if the project is not found. **Note:** this endpoint only returns data for DeFi protocol projects (e.g. `aave`, `uniswap`, `lido`, `makerdao`). Use `q` with a DeFi protocol name. */
+  defi_metrics: (params) => get("project/defi-metrics", params),
+  /** Get top DeFi projects ranked by a protocol metric. Available metrics: `tvl`, `revenue`, `fees`, `volume`, `users`. */
+  defi_ranking: (params) => get("project/defi-ranking", params),
+  /** Get multiple project sub-resources in a single request. Use `fields` to select: `overview`, `token_info`, `tokenomics`, `funding`, `team`, `contracts`, `social`, `tge_status`. **Accepts project names directly** via `q` (e.g. `?q=aave`) — no need to call `/search/project` first. Also accepts UUID via `id`. Returns 404 if not found. For DeFi metrics (TVL, fees, revenue, volume, users) and per-chain breakdown, use `/project/defi/metrics`. */
+  detail: (params) => get("project/detail", params)
+};
+
+// src/data/categories/search.ts
+init_client();
+var search = {
+  /** Search and filter airdrop opportunities by keyword, status, reward type, and task type. Returns paginated results with optional task details. */
+  airdrop: (params) => get("search/airdrop", params),
+  /** Search project events by keyword, optionally filtered by `type`. Valid types: `launch`, `upgrade`, `partnership`, `news`, `airdrop`, `listing`, `twitter`. Lookup by UUID (`id`) or name (`q`). Returns 404 if the project is not found. */
+  events: (params) => get("search/events", params),
+  /** Search funds by keyword. Returns matching funds with name, tier, type, logo, and top invested projects. */
+  fund: (params) => get("search/fund", params),
+  /** Search Kalshi events by keyword and/or category. Filter by keyword matching event title, subtitle, or market title; or by category. At least one of `q` or `category` is required. Returns events with nested markets. Data refresh: ~30 minutes */
+  kalshi: (params) => get("search/kalshi", params),
+  /** Search crypto news articles by keyword. Returns top 10 results ranked by relevance with highlighted matching fragments. */
+  news: (params) => get("search/news", params),
+  /** Search Polymarket events by keyword, tags, and/or category. Filter by keyword matching market question, event title, or description; by comma-separated tag labels; or by Surf-curated category. At least one of `q`, `tags`, or `category` is required. Returns events with nested markets ranked by volume. Data refresh: ~30 minutes */
+  polymarket: (params) => get("search/polymarket", params),
+  /** Search crypto projects by keyword. Returns matching projects with name, description, chains, and logo. */
+  project: (params) => get("search/project", params),
+  /** Search X (Twitter) users by keyword. Returns user profiles with handle, display name, bio, follower count, and avatar. */
+  social_people: (params) => get("search/social-people", params),
+  /** Search X (Twitter) posts by keyword or `from:handle` syntax. Returns posts with author, content, engagement metrics, and timestamp. To load more results, check `meta.has_more`; if true, pass `meta.next_cursor` as the `cursor` query parameter in the next request. */
+  social_posts: (params) => get("search/social-posts", params),
+  /** Search wallets by ENS name, address label, or address prefix. Returns matching wallet addresses with entity labels. */
+  wallet: (params) => get("search/wallet", params),
+  /** Search web pages, articles, and content by keyword. Filter by domain with `site` like `coindesk.com`. Returns titles, URLs, and content snippets. */
+  web: (params) => get("search/web", params)
+};
+
+// src/data/categories/social.ts
+init_client();
+var social = {
+  /** Get a **point-in-time snapshot** of social analytics: sentiment score, follower geo breakdown, and top smart followers. Use `fields` to select: `sentiment`, `follower_geo`, `smart_followers`. Lookup by X account ID (`x_id`) or project name (`q`, e.g. `uniswap`, `solana`). The `q` parameter must be a crypto project name, not a personal Twitter handle. Returns 404 if the project has no linked Twitter account. For sentiment **trends over time**, use `/social/mindshare` instead. */
+  detail: (params) => get("social/detail", params),
+  /** Get mindshare (social view count) **time-series trend** for a project, aggregated by `interval`. Use this when the user asks about sentiment **trends**, mindshare **over time**, or social momentum changes. `interval` can be `5m`, `1h`, `1d`, or `7d`. Filter by date range with `from`/`to` (Unix seconds). Lookup by name (`q`). For a **point-in-time snapshot** of social analytics (sentiment score, follower geo, smart followers), use `/social/detail` instead. */
+  mindshare: (params) => get("social/mindshare", params),
+  /** Get top crypto projects ranked by mindshare (social view count), sourced directly from Argus real-time data (refreshed every 5 minutes). Filter by `tag` to scope to a category (e.g. `dex`, `l1`, `meme`). Use `time_range` (`24h`, `48h`, `7d`, `30d`) to control the ranking window. Supports `limit`/`offset` pagination. */
+  ranking: (params) => get("social/ranking", params),
+  /** Get smart follower count time-series for a project, sorted by date descending. Lookup by X account ID (`x_id`) or project name (`q`). The `q` parameter must be a project name (e.g. `uniswap`, `ethereum`), not a personal X handle — use `x_id` for individual accounts. Returns 404 if the project has no linked X account. */
+  smart_followers_history: (params) => get("social/smart-followers-history", params),
+  /** Returns replies/comments on a specific tweet. Lookup by `tweet_id`. */
+  tweet_replies: (params) => get("social/tweet-replies", params),
+  /** Get X (Twitter) posts by numeric post ID strings. Pass up to 100 comma-separated IDs via the `ids` query parameter. */
+  tweets: (params) => get("social/tweets", params),
+  /** Get an X (Twitter) user profile — display name, follower count, following count, and bio. Lookup by `handle` (without @). */
+  user: (params) => get("social/user", params),
+  /** Returns a list of followers for the specified handle on X (Twitter). Lookup by `handle` (without @). */
+  user_followers: (params) => get("social/user-followers", params),
+  /** Returns a list of users that the specified handle follows on X (Twitter). Lookup by `handle` (without @). */
+  user_following: (params) => get("social/user-following", params),
+  /** Get recent X (Twitter) posts by a specific user, ordered by recency. Lookup by `handle` (without @). Use `filter=original` to exclude retweets. To load more results, check `meta.has_more`; if true, pass `meta.next_cursor` as the `cursor` query parameter in the next request. */
+  user_posts: (params) => get("social/user-posts", params),
+  /** Returns recent replies by the specified handle on X (Twitter). Lookup by `handle` (without @). */
+  user_replies: (params) => get("social/user-replies", params)
+};
+
+// src/data/categories/token.ts
+init_client();
+var token = {
+  /** Get recent DEX swap events for a token contract address. Covers DEXes like `uniswap`, `sushiswap`, `curve`, and `balancer` on `ethereum` and `base`. Returns trading pair, amounts, USD value, and taker address. Data refresh: ~24 hours · Chain: Ethereum, Base */
+  dex_trades: (params) => get("token/dex-trades", params),
+  /** Get top token holders for a contract address — wallet address, balance, and percentage. Lookup by `address` and `chain`. Supports EVM chains and Solana. */
+  holders: (params) => get("token/holders", params),
+  /** Get token unlock time-series — unlock events with amounts and allocation breakdowns. Lookup by project UUID (`id`) or token `symbol`. Filter by date range with `from`/`to`. Defaults to the current calendar month when omitted. Returns 404 if no token found. */
+  tokenomics: (params) => get("token/tokenomics", params),
+  /** Get recent transfer events **for a specific token** (ERC-20/TRC-20 contract). Pass the **token contract address** in `address` — returns every on-chain transfer of that token regardless of sender/receiver. Each record includes sender, receiver, raw amount, and block timestamp. Use this to analyze a token's on-chain activity (e.g. large movements, distribution patterns). Lookup: `address` (token contract) + `chain`. Sort by `asc` or `desc`. Data refresh: ~24 hours · Chain: Ethereum, Base, TRON (Solana uses a different source with no delay) */
+  transfers: (params) => get("token/transfers", params)
+};
+
+// src/data/categories/wallet.ts
+init_client();
+var wallet = {
+  /** Get multiple wallet sub-resources in a single request. Lookup by `address`. Use `fields` to select: `balance`, `tokens`, `labels`, `nft`. Partial failures return available fields with per-field error info. Returns 422 if `fields` is invalid. */
+  detail: (params) => get("wallet/detail", params),
+  /** Get full transaction history for a wallet — swaps, transfers, and contract interactions. Lookup by `address`. Filter by `chain` — supports `ethereum`, `polygon`, `bsc`, `arbitrum`, `optimism`, `avalanche`, `fantom`, `base`. */
+  history: (params) => get("wallet/history", params),
+  /** Get entity labels for multiple wallet addresses. Pass up to 100 comma-separated addresses via the `addresses` query parameter. Returns entity name, type, and labels per address. */
+  labels_batch: (params) => get("wallet/labels-batch", params),
+  /** Get a time-series of the wallet's total net worth in USD. Returns ~288 data points at 5-minute intervals covering the last 24 hours. Fixed window — no custom time range supported. */
+  net_worth: (params) => get("wallet/net-worth", params),
+  /** Get all DeFi protocol positions for a wallet — lending, staking, LP, and farming with token breakdowns and USD values. Lookup by `address`. */
+  protocols: (params) => get("wallet/protocols", params),
+  /** Get recent token transfers **sent or received by a wallet**. Pass the **wallet address** in `address` — returns all ERC-20/SPL token transfers where this wallet is the sender or receiver. Each record includes token contract, counterparty, raw amount, and block timestamp. Use this to audit a wallet's token flow (e.g. inflows, outflows, airdrop receipts). Lookup: `address` (wallet, raw 0x hex or base58 — ENS not supported). Filter by `chain` — supports `ethereum`, `base`, `solana`. Data refresh: ~24 hours · Chain: Ethereum, Base (Solana uses a different source with no delay) */
+  transfers: (params) => get("wallet/transfers", params)
+};
+
+// src/data/categories/web.ts
+init_client();
+var web = {
+  /** Fetch a web page and convert it to clean, LLM-friendly markdown. Use `target_selector` to extract specific page sections and `remove_selector` to strip unwanted elements. Returns 400 if the URL is invalid or unreachable. */
+  fetch: (params) => get("web/fetch", params)
+};
+
+// src/data/data-api.ts
+var dataApi = {
+  /** Escape hatch: raw GET to any endpoint path. */
+  get,
+  /** Escape hatch: raw POST to any endpoint path. */
+  post,
+  exchange,
+  fund,
+  kalshi,
+  market,
+  news,
+  onchain,
+  polymarket,
+  prediction_market,
+  project,
+  search,
+  social,
+  token,
+  wallet,
+  web
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createServer,
+  dataApi
+});