@aicoin/opendata-mcp 1.0.0

package/build/index.js

@@ -0,0 +1,2086 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/tools/coins.ts
+import { z } from "zod";
+
+// src/client/signature.ts
+import { createHmac, randomBytes } from "crypto";
+function generateSignature(accessKeyId, accessSecret) {
+  const nonce = randomBytes(4).toString("hex");
+  const ts = Math.floor(Date.now() / 1e3).toString();
+  const str = `AccessKeyId=${accessKeyId}&SignatureNonce=${nonce}&Timestamp=${ts}`;
+  const hex = createHmac("sha1", accessSecret).update(str).digest("hex");
+  const signature = Buffer.from(hex, "binary").toString(
+    "base64"
+  );
+  return {
+    AccessKeyId: accessKeyId,
+    SignatureNonce: nonce,
+    Timestamp: ts,
+    Signature: signature
+  };
+}
+
+// src/client/api.ts
+var DOMAIN = process.env.AICOIN_BASE_URL || "https://open.aicoin.com";
+function getCredentials() {
+  const key = process.env.AICOIN_ACCESS_KEY;
+  const secret = process.env.AICOIN_ACCESS_SECRET;
+  if (!key || !secret) {
+    throw new Error(
+      "Missing AICOIN_ACCESS_KEY or AICOIN_ACCESS_SECRET"
+    );
+  }
+  return { key, secret };
+}
+async function apiGet(path, params = {}) {
+  const { key, secret } = getCredentials();
+  const auth = generateSignature(key, secret);
+  const qs = new URLSearchParams({
+    ...params,
+    ...auth
+  });
+  const url = `${DOMAIN}${path}?${qs.toString()}`;
+  const res = await fetch(url);
+  if (!res.ok) {
+    const body = await res.text();
+    throw new Error(`API ${res.status}: ${body}`);
+  }
+  return res.json();
+}
+async function apiPost(path, body = {}) {
+  const { key, secret } = getCredentials();
+  const auth = generateSignature(key, secret);
+  const url = `${DOMAIN}${path}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ ...body, ...auth })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`API ${res.status}: ${text}`);
+  }
+  return res.json();
+}
+
+// src/tools/coins.ts
+function ok(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data) }]
+  };
+}
+function err(e) {
+  return {
+    content: [
+      { type: "text", text: `Error: ${e.message}` }
+    ],
+    isError: true
+  };
+}
+function registerCoinTools(server2) {
+  server2.tool(
+    "get_coin_list",
+    "Get list of all supported coins with basic info",
+    {},
+    async () => {
+      try {
+        return ok(await apiGet("/api/v2/coin"));
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_coin_ticker",
+    "Get real-time ticker data for coins (price, change, volume)",
+    {
+      coin_list: z.string().describe("Coin keys, comma-separated, e.g. bitcoin,ethereum")
+    },
+    async ({ coin_list }) => {
+      try {
+        return ok(
+          await apiGet("/api/v2/coin/ticker", { coin_list })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_coin_config",
+    "Get coin profile/description data",
+    {
+      coin_key: z.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin_key }) => {
+      try {
+        return ok(
+          await apiGet("/api/v2/coin/config", { coin_key })
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_ai_coin_analysis",
+    "Get AI interpretation and prediction for coins",
+    {
+      coin_keys: z.string().describe('Coin keys JSON array, e.g. ["bitcoin","ethereum"]'),
+      language: z.enum(["CN", "EN", "TC"]).optional().describe("Language: CN/EN/TC, default CN")
+    },
+    async ({ coin_keys, language }) => {
+      try {
+        const body = {
+          coinKeys: JSON.parse(coin_keys)
+        };
+        if (language) body.language = language;
+        return ok(
+          await apiPost("/api/v2/content/ai-coins", body)
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_funding_rate_history",
+    "Get funding rate history for a coin",
+    {
+      coin: z.string().describe("Coin key, e.g. bitcoin"),
+      interval: z.string().optional().describe("Interval, e.g. 8h")
+    },
+    async ({ coin, interval }) => {
+      try {
+        const params = { coin };
+        if (interval) params.interval = interval;
+        return ok(
+          await apiGet(
+            "/api/upgrade/v2/futures/funding-rate/history",
+            params
+          )
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_liquidation_map",
+    "Get liquidation heatmap data for a coin",
+    {
+      coin: z.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok(
+          await apiGet(
+            "/api/upgrade/v2/futures/liquidation/map",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_weighted_funding_rate_history",
+    "Get volume-weighted funding rate history",
+    {
+      coin: z.string().describe("Coin key, e.g. bitcoin"),
+      interval: z.string().optional().describe("Interval, e.g. 8h")
+    },
+    async ({ coin, interval }) => {
+      try {
+        const params = { coin };
+        if (interval) params.interval = interval;
+        return ok(
+          await apiGet(
+            "/api/upgrade/v2/futures/funding-rate/vol-weight-history",
+            params
+          )
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_aggregated_stablecoin_oi_history",
+    "Get aggregated stablecoin-margined open interest history",
+    {
+      coin: z.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok(
+          await apiGet(
+            "/api/upgrade/v2/futures/open-interest/aggregated-stablecoin-history",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_aggregated_coin_margin_oi_history",
+    "Get aggregated coin-margined open interest history",
+    {
+      coin: z.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok(
+          await apiGet(
+            "/api/upgrade/v2/futures/open-interest/aggregated-coin-margin-history",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_liquidation_history",
+    "Get liquidation order history",
+    {
+      coin: z.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok(
+          await apiGet(
+            "/api/upgrade/v2/futures/liquidation/history",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_estimated_liquidation_history",
+    "Get historical estimated liquidation chart data",
+    {
+      coin: z.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok(
+          await apiGet(
+            "/api/upgrade/v2/futures/estimated-liquidation/history",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_historical_depth",
+    "Get historical order book depth data",
+    {
+      coin: z.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok(
+          await apiGet(
+            "/api/upgrade/v2/futures/historical-depth",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_super_depth_history",
+    "Get large order depth history",
+    {
+      coin: z.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok(
+          await apiGet(
+            "/api/upgrade/v2/futures/super-depth/history",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_trade_data",
+    "Get latest trade data for futures",
+    {
+      coin: z.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok(
+          await apiGet(
+            "/api/upgrade/v2/futures/trade-data",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err(e);
+      }
+    }
+  );
+}
+
+// src/tools/contents.ts
+import { z as z2 } from "zod";
+function ok2(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data) }]
+  };
+}
+function err2(e) {
+  return {
+    content: [
+      { type: "text", text: `Error: ${e.message}` }
+    ],
+    isError: true
+  };
+}
+function registerContentTools(server2) {
+  server2.tool(
+    "get_newsflash",
+    "Get latest crypto flash news (kuaixun)",
+    {
+      page: z2.string().optional().describe("Page number, default 1"),
+      limit: z2.string().optional().describe("Items per page, default 20")
+    },
+    async ({ page, limit }) => {
+      try {
+        const params = {};
+        if (page) params.page = page;
+        if (limit) params.limit = limit;
+        return ok2(
+          await apiGet("/api/v2/content/newsflash", params)
+        );
+      } catch (e) {
+        return err2(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_news_list",
+    "Get news article list",
+    {
+      page: z2.string().optional().describe("Page number"),
+      limit: z2.string().optional().describe("Items per page")
+    },
+    async ({ page, limit }) => {
+      try {
+        const params = {};
+        if (page) params.page = page;
+        if (limit) params.limit = limit;
+        return ok2(
+          await apiGet("/api/v2/content/news-list", params)
+        );
+      } catch (e) {
+        return err2(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_news_detail",
+    "Get full content of a news article",
+    {
+      id: z2.string().describe("News article ID")
+    },
+    async ({ id }) => {
+      try {
+        return ok2(
+          await apiGet("/api/v2/content/news-detail", { id })
+        );
+      } catch (e) {
+        return err2(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_rss_news_list",
+    "Get RSS news list (dedicated RSS feed)",
+    {
+      page: z2.string().optional().describe("Page number"),
+      pageSize: z2.string().optional().describe("Page size, max 20")
+    },
+    async ({ page, pageSize }) => {
+      try {
+        const params = {};
+        if (page) params.page = page;
+        if (pageSize) params.pageSize = pageSize;
+        return ok2(
+          await apiGet(
+            "/api/v2/content/square/market/news-list",
+            params
+          )
+        );
+      } catch (e) {
+        return err2(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_flash_list",
+    "Get industry flash news (with flash type classification)",
+    {
+      language: z2.string().optional().describe("Language: cn, tc, en"),
+      createtime: z2.string().optional().describe("Filter by create time")
+    },
+    async ({ language, createtime }) => {
+      try {
+        const params = {};
+        if (language) params.language = language;
+        if (createtime) params.createtime = createtime;
+        return ok2(
+          await apiGet(
+            "/api/v2/content/flashList",
+            params
+          )
+        );
+      } catch (e) {
+        return err2(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_exchange_listing_flash",
+    "Get exchange coin listing/delisting news",
+    {
+      page: z2.string().optional().describe("Page number"),
+      limit: z2.string().optional().describe("Items per page")
+    },
+    async ({ page, limit }) => {
+      try {
+        const params = {};
+        if (page) params.page = page;
+        if (limit) params.limit = limit;
+        return ok2(
+          await apiGet(
+            "/api/v2/content/exchange-listing-flash",
+            params
+          )
+        );
+      } catch (e) {
+        return err2(e);
+      }
+    }
+  );
+}
+
+// src/tools/markets.ts
+import { z as z3 } from "zod";
+function ok3(data) {
+  return {
+    content: [
+      { type: "text", text: JSON.stringify(data) }
+    ]
+  };
+}
+function err3(e) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Error: ${e.message}`
+      }
+    ],
+    isError: true
+  };
+}
+function registerMarketTools(server2) {
+  server2.tool(
+    "get_kline_data",
+    "Get K-line (candlestick) data for a trading pair",
+    {
+      trading_pair: z3.string().describe("Trading pair key"),
+      period: z3.string().optional().describe("Period: 1min,5min,15min,1hour,4hour,1day,1week"),
+      limit: z3.string().optional().describe("Number of candles")
+    },
+    async ({ trading_pair, period, limit }) => {
+      try {
+        const params = {
+          trading_pair
+        };
+        if (period) params.period = period;
+        if (limit) params.limit = limit;
+        return ok3(
+          await apiGet(
+            "/api/v2/commonKline/dataRecords",
+            params
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_market_ticker",
+    "Get ticker data for a specific exchange platform",
+    {
+      platform: z3.string().describe("Exchange platform key, e.g. binance"),
+      type: z3.string().optional().describe("Market type filter")
+    },
+    async ({ platform, type }) => {
+      try {
+        const params = { platform };
+        if (type) params.type = type;
+        return ok3(
+          await apiGet("/api/v2/market/ticker", params)
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_markets",
+    "Get list of all supported exchange platforms",
+    {},
+    async () => {
+      try {
+        return ok3(await apiGet("/api/v2/market"));
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_futures_interest",
+    "Get futures open interest data",
+    {
+      coin: z3.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok3(
+          await apiGet("/api/v2/futures/interest", { coin })
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_crypto_stock_quotes",
+    "Get crypto-related stock quotes (MSTR, COIN, etc.)",
+    {
+      tickers: z3.string().optional().describe(
+        "Stock tickers, e.g. i:mstr:nasdaq,i:coin:nasdaq"
+      )
+    },
+    async ({ tickers }) => {
+      try {
+        const params = {};
+        if (tickers) params.tickers = tickers;
+        return ok3(
+          await apiGet(
+            "/api/upgrade/v2/crypto_stock/quotes",
+            params
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_index_price",
+    "Get index price data",
+    {
+      index_key: z3.string().describe("Index key")
+    },
+    async ({ index_key }) => {
+      try {
+        return ok3(
+          await apiGet("/api/v2/index/indexPrice", {
+            index_key
+          })
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_hot_tab_coins",
+    "Get trending/hot coins list by category",
+    {
+      tab: z3.string().optional().describe("Tab/category filter")
+    },
+    async ({ tab }) => {
+      try {
+        const params = {};
+        if (tab) params.tab = tab;
+        return ok3(
+          await apiGet(
+            "/api/v2/market/hotTabCoins",
+            params
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_crypto_company_info",
+    "Get crypto-related company details by stock symbol",
+    {
+      symbol: z3.string().describe("Stock symbol, e.g. mstr, coin")
+    },
+    async ({ symbol }) => {
+      try {
+        return ok3(
+          await apiGet(
+            `/api/upgrade/v2/crypto_stock/company/${symbol}`
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_index_info",
+    "Get index detail information",
+    {
+      index_key: z3.string().describe("Index key")
+    },
+    async ({ index_key }) => {
+      try {
+        return ok3(
+          await apiGet("/api/v2/index/indexInfo", {
+            index_key
+          })
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_index_list",
+    "Get list of all available indexes",
+    {},
+    async () => {
+      try {
+        return ok3(
+          await apiGet("/api/v2/index/getIndex")
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_indicator_kline_trading_pair",
+    "Get trading pairs for indicator K-line",
+    {
+      indicator: z3.string().optional().describe("Indicator name filter")
+    },
+    async ({ indicator }) => {
+      try {
+        const params = {};
+        if (indicator) params.indicator = indicator;
+        return ok3(
+          await apiGet(
+            "/api/v2/indicatorKline/getTradingPair",
+            params
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_indicator_kline_data",
+    "Get indicator K-line data records",
+    {
+      trading_pair: z3.string().describe("Trading pair key"),
+      indicator: z3.string().describe("Indicator name"),
+      period: z3.string().optional().describe("Period: 1min,5min,15min,1hour,4hour,1day"),
+      limit: z3.string().optional().describe("Number of records")
+    },
+    async ({ trading_pair, indicator, period, limit }) => {
+      try {
+        const params = {
+          trading_pair,
+          indicator
+        };
+        if (period) params.period = period;
+        if (limit) params.limit = limit;
+        return ok3(
+          await apiGet(
+            "/api/v2/indicatorKline/dataRecords",
+            params
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_coin_treasury_entities",
+    "Get coin treasury entity data (e.g. MicroStrategy BTC holdings)",
+    {
+      coin: z3.string().describe("Coin key, e.g. bitcoin"),
+      entity_type: z3.string().optional().describe("Entity type filter")
+    },
+    async ({ coin, entity_type }) => {
+      try {
+        const body = { coin };
+        if (entity_type) body.entity_type = entity_type;
+        return ok3(
+          await apiPost(
+            "/api/upgrade/v2/coin-treasuries/entities",
+            body
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_coin_treasury_history",
+    "Get coin treasury historical data",
+    {
+      coin: z3.string().describe("Coin key, e.g. bitcoin"),
+      entity_id: z3.string().optional().describe("Entity ID filter")
+    },
+    async ({ coin, entity_id }) => {
+      try {
+        const body = { coin };
+        if (entity_id) body.entity_id = entity_id;
+        return ok3(
+          await apiPost(
+            "/api/upgrade/v2/coin-treasuries/history",
+            body
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_coin_treasury_accumulated",
+    "Get accumulated coin treasury historical data",
+    {
+      coin: z3.string().describe("Coin key, e.g. bitcoin"),
+      entity_id: z3.string().optional().describe("Entity ID filter")
+    },
+    async ({ coin, entity_id }) => {
+      try {
+        const body = { coin };
+        if (entity_id) body.entity_id = entity_id;
+        return ok3(
+          await apiPost(
+            "/api/upgrade/v2/coin-treasuries/history/accumulated",
+            body
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_latest_coin_treasury_entities",
+    "Get latest coin treasury entity data",
+    {
+      coin: z3.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok3(
+          await apiGet(
+            "/api/upgrade/v2/coin-treasuries/latest/entities",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_latest_coin_treasury_history",
+    "Get latest coin treasury history data",
+    {
+      coin: z3.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok3(
+          await apiGet(
+            "/api/upgrade/v2/coin-treasuries/latest/history",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_coin_treasury_summary",
+    "Get coin treasury data summary",
+    {
+      coin: z3.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok3(
+          await apiGet(
+            "/api/upgrade/v2/coin-treasuries/summary",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_latest_depth",
+    "Get latest order book depth data for futures",
+    {
+      coin: z3.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok3(
+          await apiGet(
+            "/api/upgrade/v2/futures/latest-depth",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_full_depth",
+    "Get full order book depth data for futures",
+    {
+      coin: z3.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok3(
+          await apiGet(
+            "/api/upgrade/v2/futures/full-depth",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_full_depth_grouped",
+    "Get full depth data grouped by price level",
+    {
+      coin: z3.string().describe("Coin key, e.g. bitcoin")
+    },
+    async ({ coin }) => {
+      try {
+        return ok3(
+          await apiGet(
+            "/api/upgrade/v2/futures/full-depth/grouped",
+            { coin }
+          )
+        );
+      } catch (e) {
+        return err3(e);
+      }
+    }
+  );
+}
+
+// src/tools/features.ts
+import { z as z4 } from "zod";
+function ok4(data) {
+  return {
+    content: [
+      { type: "text", text: JSON.stringify(data) }
+    ]
+  };
+}
+function err4(e) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Error: ${e.message}`
+      }
+    ],
+    isError: true
+  };
+}
+function registerFeatureTools(server2) {
+  server2.tool(
+    "get_ls_ratio",
+    "Get long/short ratio data",
+    {
+      coin: z4.string().describe("Coin key, e.g. bitcoin"),
+      period: z4.string().optional().describe("Period filter")
+    },
+    async ({ coin, period }) => {
+      try {
+        const params = { coin };
+        if (period) params.period = period;
+        return ok4(
+          await apiGet("/api/v2/mix/ls-ratio", params)
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_liquidation_data",
+    "Get liquidation/forced-close data",
+    {
+      coin: z4.string().optional().describe("Coin key filter"),
+      period: z4.string().optional().describe("Period filter")
+    },
+    async ({ coin, period }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        if (period) params.period = period;
+        return ok4(
+          await apiGet("/api/v2/mix/liq", params)
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_big_orders",
+    "Get whale/large order tracking data",
+    {
+      coin: z4.string().optional().describe("Coin key filter"),
+      platform: z4.string().optional().describe("Exchange platform filter"),
+      page: z4.string().optional().describe("Page number")
+    },
+    async ({ coin, platform, page }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        if (platform) params.platform = platform;
+        if (page) params.page = page;
+        return ok4(
+          await apiGet("/api/v2/order/bigOrder", params)
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_agg_trades",
+    "Get aggregated large trades data",
+    {
+      coin: z4.string().optional().describe("Coin key filter"),
+      platform: z4.string().optional().describe("Exchange platform filter")
+    },
+    async ({ coin, platform }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        if (platform) params.platform = platform;
+        return ok4(
+          await apiGet("/api/v2/order/aggTrade", params)
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_trading_pair_ticker",
+    "Get ticker data for specific trading pairs",
+    {
+      trading_pairs: z4.string().describe(
+        "Trading pair keys, comma-separated"
+      )
+    },
+    async ({ trading_pairs }) => {
+      try {
+        return ok4(
+          await apiGet("/api/v2/trading-pair/ticker", {
+            trading_pairs
+          })
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_strategy_signal",
+    "Get indicator win-rate signal data",
+    {
+      coin: z4.string().optional().describe("Coin key filter")
+    },
+    async ({ coin }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        return ok4(
+          await apiGet(
+            "/api/v2/signal/strategySignal",
+            params
+          )
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_nav",
+    "Get navigation bar data (market overview)",
+    {},
+    async () => {
+      try {
+        return ok4(await apiGet("/api/v2/mix/nav"));
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_grayscale_trust",
+    "Get Grayscale trust fund data",
+    {},
+    async () => {
+      try {
+        return ok4(
+          await apiGet("/api/v2/mix/grayscale-trust")
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_gray_scale",
+    "Get Grayscale holdings data",
+    {},
+    async () => {
+      try {
+        return ok4(
+          await apiGet("/api/v2/mix/gray-scale")
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_stock_market",
+    "Get stock market data (crypto-related)",
+    {},
+    async () => {
+      try {
+        return ok4(
+          await apiGet("/api/v2/mix/stock-market")
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_signal_alert",
+    "Get signal alert data",
+    {
+      coin: z4.string().optional().describe("Coin key filter")
+    },
+    async ({ coin }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        return ok4(
+          await apiGet(
+            "/api/v2/signal/signalAlert",
+            params
+          )
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_signal_alert_config",
+    "Get signal alert configuration options",
+    {},
+    async () => {
+      try {
+        return ok4(
+          await apiGet("/api/v2/signal/signalAlertConf")
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "delete_signal_alert",
+    "Delete a signal alert by ID",
+    {
+      id: z4.string().describe("Signal alert ID")
+    },
+    async ({ id }) => {
+      try {
+        return ok4(
+          await apiGet(
+            "/api/v2/signal/delSignalAlert",
+            { id }
+          )
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "add_signal_alert",
+    "Add a new signal alert",
+    {
+      params_json: z4.string().describe("Alert params as JSON string")
+    },
+    async ({ params_json }) => {
+      try {
+        const params = JSON.parse(params_json);
+        return ok4(
+          await apiGet(
+            "/api/v2/signal/addSignalAlert",
+            params
+          )
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_signal_alert_list",
+    "Get signal alert settings list",
+    {},
+    async () => {
+      try {
+        return ok4(
+          await apiGet(
+            "/api/v2/signal/getSignalAlertSetList"
+          )
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_change_signal",
+    "Get abnormal movement signal data",
+    {
+      coin: z4.string().optional().describe("Coin key filter")
+    },
+    async ({ coin }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        return ok4(
+          await apiGet(
+            "/api/v2/signal/changeSignal",
+            params
+          )
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_trading_pair",
+    "Get trading pair info by key",
+    {
+      trading_pair: z4.string().describe("Trading pair key")
+    },
+    async ({ trading_pair }) => {
+      try {
+        return ok4(
+          await apiGet(
+            "/api/v2/trading-pair/getTradingPair",
+            { trading_pair }
+          )
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+  server2.tool(
+    "get_trading_pairs",
+    "Get trading pair list for a platform",
+    {
+      platform: z4.string().describe("Platform key, e.g. binance"),
+      type: z4.string().optional().describe("Market type filter")
+    },
+    async ({ platform, type }) => {
+      try {
+        const params = {
+          platform
+        };
+        if (type) params.type = type;
+        return ok4(
+          await apiGet("/api/v2/trading-pair", params)
+        );
+      } catch (e) {
+        return err4(e);
+      }
+    }
+  );
+}
+
+// src/tools/hyperliquid.ts
+import { z as z5 } from "zod";
+function ok5(data) {
+  return {
+    content: [
+      { type: "text", text: JSON.stringify(data) }
+    ]
+  };
+}
+function err5(e) {
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Error: ${e.message}`
+      }
+    ],
+    isError: true
+  };
+}
+function registerHyperliquidTools(server2) {
+  server2.tool(
+    "hl_get_tickers",
+    "Get all Hyperliquid ticker data",
+    {},
+    async () => {
+      try {
+        return ok5(await apiGet("/api/v2/hl/tickers"));
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_ticker_by_coin",
+    "Get Hyperliquid ticker for a specific coin",
+    {
+      coin: z5.string().describe("Coin symbol, e.g. BTC, ETH")
+    },
+    async ({ coin }) => {
+      try {
+        return ok5(
+          await apiGet(`/api/v2/hl/tickers/coin/${coin}`)
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_whale_positions",
+    "Get Hyperliquid whale open positions",
+    {
+      coin: z5.string().optional().describe("Coin filter, e.g. BTC"),
+      min_usd: z5.string().optional().describe("Min position size in USD")
+    },
+    async ({ coin, min_usd }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        if (min_usd) params.min_usd = min_usd;
+        return ok5(
+          await apiGet(
+            "/api/v2/hl/whales/open-positions",
+            params
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_liquidations",
+    "Get Hyperliquid liquidation history",
+    {
+      coin: z5.string().optional().describe("Coin filter")
+    },
+    async ({ coin }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        return ok5(
+          await apiGet(
+            "/api/v2/hl/liquidations/history",
+            params
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_trader_stats",
+    "Get Hyperliquid trader statistics by address",
+    {
+      address: z5.string().describe("Wallet address, e.g. 0x...")
+    },
+    async ({ address }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/traders/${address}/addr-stat`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_info",
+    "Generic Hyperliquid Info API (supports all info types)",
+    {
+      type: z5.string().describe(
+        "Info type, e.g. metaAndAssetCtxs, clearinghouseState, spotMeta, allMids, l2Book, openOrders, userFills, candleSnapshot"
+      ),
+      user: z5.string().optional().describe("User wallet address (for user-specific queries)"),
+      extra_params: z5.string().optional().describe('Extra params as JSON string, e.g. {"coin":"BTC"}')
+    },
+    async ({ type, user, extra_params }) => {
+      try {
+        const body = { type };
+        if (user) body.user = user;
+        if (extra_params) {
+          Object.assign(body, JSON.parse(extra_params));
+        }
+        return ok5(
+          await apiPost("/api/v2/hl/info", body)
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_fills_by_address",
+    "Get Hyperliquid user trade fills by wallet address",
+    {
+      address: z5.string().describe("Wallet address, e.g. 0x...")
+    },
+    async ({ address }) => {
+      try {
+        return ok5(
+          await apiGet(`/api/v2/hl/fills/${address}`)
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_fills_by_oid",
+    "Get Hyperliquid trade fills by order ID",
+    {
+      oid: z5.string().describe("Order ID")
+    },
+    async ({ oid }) => {
+      try {
+        return ok5(
+          await apiGet(`/api/v2/hl/fills/oid/${oid}`)
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_fills_by_twapid",
+    "Get Hyperliquid trade fills by TWAP ID",
+    {
+      twapid: z5.string().describe("TWAP ID")
+    },
+    async ({ twapid }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/fills/twapid/${twapid}`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_top_trades",
+    "Get Hyperliquid top trades",
+    {
+      coin: z5.string().optional().describe("Coin filter, e.g. BTC")
+    },
+    async ({ coin }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        return ok5(
+          await apiGet(
+            "/api/v2/hl/fills/top-trades",
+            params
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_filled_orders",
+    "Get filled orders by wallet address",
+    {
+      address: z5.string().describe("Wallet address")
+    },
+    async ({ address }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/filled-orders/${address}/latest`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_filled_order_by_oid",
+    "Get filled order by order ID",
+    {
+      oid: z5.string().describe("Order ID")
+    },
+    async ({ oid }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/filled-orders/oid/${oid}`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_orders",
+    "Get latest orders by wallet address",
+    {
+      address: z5.string().describe("Wallet address")
+    },
+    async ({ address }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/orders/${address}/latest`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_order_by_oid",
+    "Get order by order ID",
+    {
+      oid: z5.string().describe("Order ID")
+    },
+    async ({ oid }) => {
+      try {
+        return ok5(
+          await apiGet(`/api/v2/hl/orders/oid/${oid}`)
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_top_open_orders",
+    "Get top open orders on Hyperliquid",
+    {
+      coin: z5.string().optional().describe("Coin filter")
+    },
+    async ({ coin }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        return ok5(
+          await apiGet(
+            "/api/v2/hl/orders/top-open-orders",
+            params
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_active_stats",
+    "Get active order statistics",
+    {
+      coin: z5.string().optional().describe("Coin filter")
+    },
+    async ({ coin }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        return ok5(
+          await apiGet(
+            "/api/v2/hl/orders/active-stats",
+            params
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_portfolio",
+    "Get account value and PNL curves",
+    {
+      address: z5.string().describe("Wallet address"),
+      window: z5.string().describe("Time window, e.g. 1d, 7d, 30d")
+    },
+    async ({ address, window: win }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/portfolio/${address}/${win}`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_pnls",
+    "Get PNL curve data by address",
+    {
+      address: z5.string().describe("Wallet address")
+    },
+    async ({ address }) => {
+      try {
+        return ok5(
+          await apiGet(`/api/v2/hl/pnls/${address}`)
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_best_trades",
+    "Get most profitable trades by address",
+    {
+      address: z5.string().describe("Wallet address")
+    },
+    async ({ address }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/traders/${address}/best-trades`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_performance_by_coin",
+    "Get per-coin trading performance stats",
+    {
+      address: z5.string().describe("Wallet address")
+    },
+    async ({ address }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/traders/${address}/performance-by-coin`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_completed_trades",
+    "Get completed trades list by address",
+    {
+      address: z5.string().describe("Wallet address")
+    },
+    async ({ address }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/traders/${address}/completed-trades`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_current_position_history",
+    "Get current position history for a coin",
+    {
+      address: z5.string().describe("Wallet address"),
+      coin: z5.string().describe("Coin, e.g. BTC")
+    },
+    async ({ address, coin }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/traders/${address}/current-position-history/${coin}`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_completed_position_history",
+    "Get completed position history for a coin",
+    {
+      address: z5.string().describe("Wallet address"),
+      coin: z5.string().describe("Coin, e.g. BTC")
+    },
+    async ({ address, coin }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/traders/${address}/completed-position-history/${coin}`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_current_position_pnl",
+    "Get current position PnL for a coin",
+    {
+      address: z5.string().describe("Wallet address"),
+      coin: z5.string().describe("Coin, e.g. BTC")
+    },
+    async ({ address, coin }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/traders/${address}/current-position-pnl/${coin}`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_completed_position_pnl",
+    "Get completed position PnL for a coin",
+    {
+      address: z5.string().describe("Wallet address"),
+      coin: z5.string().describe("Coin, e.g. BTC")
+    },
+    async ({ address, coin }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/traders/${address}/completed-position-pnl/${coin}`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_current_position_executions",
+    "Get current position execution trace",
+    {
+      address: z5.string().describe("Wallet address"),
+      coin: z5.string().describe("Coin, e.g. BTC")
+    },
+    async ({ address, coin }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/traders/${address}/current-position-executions/${coin}`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_completed_position_executions",
+    "Get completed position execution trace",
+    {
+      address: z5.string().describe("Wallet address"),
+      coin: z5.string().describe("Coin, e.g. BTC")
+    },
+    async ({ address, coin }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/traders/${address}/completed-position-executions/${coin}`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_traders_accounts",
+    "Batch query trader account info",
+    {
+      addresses: z5.string().describe("Addresses as JSON array string")
+    },
+    async ({ addresses }) => {
+      try {
+        return ok5(
+          await apiPost("/api/v2/hl/traders/accounts", {
+            addresses: JSON.parse(addresses)
+          })
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_traders_statistics",
+    "Batch query trader statistics",
+    {
+      addresses: z5.string().describe("Addresses as JSON array string")
+    },
+    async ({ addresses }) => {
+      try {
+        return ok5(
+          await apiPost(
+            "/api/v2/hl/traders/statistics",
+            { addresses: JSON.parse(addresses) }
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_whale_events",
+    "Get latest whale position events",
+    {
+      coin: z5.string().optional().describe("Coin filter")
+    },
+    async ({ coin }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        return ok5(
+          await apiGet(
+            "/api/v2/hl/whales/latest-events",
+            params
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_whale_directions",
+    "Get whale position long/short counts",
+    {
+      coin: z5.string().optional().describe("Coin filter")
+    },
+    async ({ coin }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        return ok5(
+          await apiGet(
+            "/api/v2/hl/whales/directions",
+            params
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_whale_history_long_ratio",
+    "Get historical whale long/short ratio",
+    {
+      coin: z5.string().optional().describe("Coin filter")
+    },
+    async ({ coin }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        return ok5(
+          await apiGet(
+            "/api/v2/hl/whales/history-long-ratio",
+            params
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_liquidation_stats",
+    "Get Hyperliquid liquidation statistics",
+    {},
+    async () => {
+      try {
+        return ok5(
+          await apiGet("/api/v2/hl/liquidations/stat")
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_liquidation_stats_by_coin",
+    "Get liquidation statistics by coin",
+    {
+      coin: z5.string().optional().describe("Coin filter")
+    },
+    async ({ coin }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        return ok5(
+          await apiGet(
+            "/api/v2/hl/liquidations/stat-by-coin",
+            params
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_liquidation_top_positions",
+    "Get top liquidated positions",
+    {
+      coin: z5.string().optional().describe("Coin filter")
+    },
+    async ({ coin }) => {
+      try {
+        const params = {};
+        if (coin) params.coin = coin;
+        return ok5(
+          await apiGet(
+            "/api/v2/hl/liquidations/top-positions",
+            params
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_smart_find",
+    "Discover smart money addresses on Hyperliquid",
+    {
+      params_json: z5.string().describe("Search params as JSON string")
+    },
+    async ({ params_json }) => {
+      try {
+        return ok5(
+          await apiPost(
+            "/api/v2/hl/smart/find",
+            JSON.parse(params_json)
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_discover_traders",
+    "Discover traders by criteria",
+    {
+      params_json: z5.string().describe("Discovery params as JSON string")
+    },
+    async ({ params_json }) => {
+      try {
+        return ok5(
+          await apiPost(
+            "/api/v2/hl/traders/discover",
+            JSON.parse(params_json)
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_twap_states",
+    "Get TWAP order states by address",
+    {
+      address: z5.string().describe("Wallet address")
+    },
+    async ({ address }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/twap-states/${address}/latest`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_max_drawdown",
+    "Get max drawdown data by address",
+    {
+      address: z5.string().describe("Wallet address")
+    },
+    async ({ address }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/max-drawdown/${address}`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_net_flow",
+    "Get ledger net flow by address",
+    {
+      address: z5.string().describe("Wallet address")
+    },
+    async ({ address }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/ledger-updates/net-flow/${address}`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+  server2.tool(
+    "hl_get_klines_with_taker_vol",
+    "Get K-line data with taker volume",
+    {
+      coin: z5.string().describe("Coin, e.g. BTC"),
+      interval: z5.string().describe("Interval, e.g. 1h, 4h, 1d")
+    },
+    async ({ coin, interval }) => {
+      try {
+        return ok5(
+          await apiGet(
+            `/api/v2/hl/klines-with-taker-vol/${coin}/${interval}`
+          )
+        );
+      } catch (e) {
+        return err5(e);
+      }
+    }
+  );
+}
+
+// src/tools/index.ts
+function registerAllTools(server2) {
+  registerCoinTools(server2);
+  registerContentTools(server2);
+  registerMarketTools(server2);
+  registerFeatureTools(server2);
+  registerHyperliquidTools(server2);
+}
+
+// src/index.ts
+var server = new McpServer({
+  name: "aicoin-opendata",
+  version: "1.0.0"
+});
+registerAllTools(server);
+var transport = new StdioServerTransport();
+await server.connect(transport);