@nirholas/bnbchain-mcp 1.0.0

package/src/vendors/indicators/strategies/trendStrategies.js

@@ -0,0 +1,220 @@
+/**
+ * @author Nich
+ * @website x.com/nichxbt
+ * @github github.com/nirholas
+ * @license MIT
+ */
+const { z } = require("zod");
+const {
+  absolutePriceOscillatorStrategy, aroonStrategy, balanceOfPowerStrategy,
+  chandeForecastOscillatorStrategy, kdjStrategy, macdStrategy, parabolicSarStrategy,
+  typicalPriceStrategy, volumeWeightedMovingAverageStrategy, vortexStrategy,
+} = require("indicatorts");
+const fetchOhlcvData = require("../utils/fetchOhlcvData");
+
+module.exports = (server) => {
+  server.tool(
+    "calculate_absolute_price_oscillator_strategy",
+    "Calculate the Absolute Price Oscillator Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      fastPeriod: z.number().default(12).describe("Fast period for APO"),
+      slowPeriod: z.number().default(26).describe("Slow period for APO"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, fastPeriod, slowPeriod, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = absolutePriceOscillatorStrategy(asset, { fast: fastPeriod, slow: slowPeriod });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_aroon_strategy",
+    "Calculate the Aroon Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for Aroon"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = aroonStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_balance_of_power_strategy",
+    "Calculate the Balance of Power Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for BOP"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = balanceOfPowerStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_chande_forecast_oscillator_strategy",
+    "Calculate the Chande Forecast Oscillator Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for CFO"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = chandeForecastOscillatorStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_kdj_strategy",
+    "Calculate the KDJ Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(9).describe("Period length for KDJ"),
+      signalPeriod: z.number().default(3).describe("Signal period for KDJ"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, signalPeriod, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = kdjStrategy(asset, { period, signal: signalPeriod });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_macd_strategy",
+    "Calculate the MACD Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      fastPeriod: z.number().default(12).describe("Fast period for MACD"),
+      slowPeriod: z.number().default(26).describe("Slow period for MACD"),
+      signalPeriod: z.number().default(9).describe("Signal period for MACD"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, fastPeriod, slowPeriod, signalPeriod, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = macdStrategy(asset, { fast: fastPeriod, slow: slowPeriod, signal: signalPeriod });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_parabolic_sar_strategy",
+    "Calculate the Parabolic SAR Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      accelerationFactorStep: z.number().default(0.02).describe("Acceleration factor step for PSAR"),
+      accelerationFactorMax: z.number().default(0.2).describe("Maximum acceleration factor for PSAR"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, accelerationFactorStep, accelerationFactorMax, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = parabolicSarStrategy(asset, { accelerationFactorStep, accelerationFactorMax });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_typical_price_strategy",
+    "Calculate the Typical Price Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for Typical Price"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = typicalPriceStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_volume_weighted_moving_average_strategy",
+    "Calculate the VWMA Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for VWMA"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = volumeWeightedMovingAverageStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_vortex_strategy",
+    "Calculate the Vortex Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for Vortex"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = vortexStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+};

package/src/vendors/indicators/strategies/volatilityStrategies.js

@@ -0,0 +1,74 @@
+/**
+ * @author Nich
+ * @website x.com/nichxbt
+ * @github github.com/nirholas
+ * @license MIT
+ */
+const { z } = require("zod");
+const {
+  accelerationBandsStrategy, bollingerBandsStrategy, projectionOscillatorStrategy,
+} = require("indicatorts");
+const fetchOhlcvData = require("../utils/fetchOhlcvData");
+
+module.exports = (server) => {
+  server.tool(
+    "calculate_acceleration_bands_strategy",
+    "Calculate the Acceleration Bands Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(20).describe("Period length for AB"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = accelerationBandsStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_bollinger_bands_strategy",
+    "Calculate the Bollinger Bands Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(20).describe("Period length for BB"),
+      stdDev: z.number().default(2).describe("Standard deviation multiplier"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, stdDev, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = bollingerBandsStrategy(asset, { period, stdDev });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_projection_oscillator_strategy",
+    "Calculate the Projection Oscillator Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for PO"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = projectionOscillatorStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+};

package/src/vendors/indicators/strategies/volumeStrategies.js

@@ -0,0 +1,134 @@
+/**
+ * @author Nich
+ * @website x.com/nichxbt
+ * @github github.com/nirholas
+ * @license MIT
+ */
+const { z } = require("zod");
+const {
+  chaikinMoneyFlowStrategy, easeOfMovementStrategy, forceIndexStrategy,
+  moneyFlowIndexStrategy, negativeVolumeIndexStrategy, volumeWeightedAveragePriceStrategy,
+} = require("indicatorts");
+const fetchOhlcvData = require("../utils/fetchOhlcvData");
+
+module.exports = (server) => {
+  server.tool(
+    "calculate_chaikin_money_flow_strategy",
+    "Calculate the Chaikin Money Flow Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(20).describe("Period length for CMF"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = chaikinMoneyFlowStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_ease_of_movement_strategy",
+    "Calculate the Ease of Movement Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for EMV"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = easeOfMovementStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_force_index_strategy",
+    "Calculate the Force Index Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(13).describe("Period length for FI"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = forceIndexStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_money_flow_index_strategy",
+    "Calculate the Money Flow Index Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for MFI"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = moneyFlowIndexStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_negative_volume_index_strategy",
+    "Calculate the Negative Volume Index Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for NVI"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = negativeVolumeIndexStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+
+  server.tool(
+    "calculate_volume_weighted_average_price_strategy",
+    "Calculate the VWAP Strategy for a given trading pair using Binance OHLCV data. Outputs: -1 (SELL), 0 (HOLD), 1 (BUY)",
+    {
+      symbol: z.string().describe("Trading pair, e.g., 'BTC/USDT'"),
+      timeframe: z.string().default("1h").describe("Timeframe, e.g., '1m', '1h', '1d'"),
+      period: z.number().default(14).describe("Period length for VWAP"),
+      limit: z.number().default(100).describe("Number of OHLCV data points to fetch"),
+    },
+    async ({ symbol, timeframe, period, limit }) => {
+      try {
+        const asset = await fetchOhlcvData(symbol, timeframe, limit);
+        const result = volumeWeightedAveragePriceStrategy(asset, { period });
+        return { content: [{ type: "text", text: JSON.stringify(result) }] };
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  );
+};

package/src/vendors/indicators/utils/fetchOhlcvData.js

@@ -0,0 +1,35 @@
+/**
+ * @author Nich
+ * @website x.com/nichxbt
+ * @github github.com/nirholas
+ * @license MIT
+ */
+const ccxt = require("ccxt");
+
+// Initialize ccxt client
+const exid = process.env.EXCHANGE_NAME || "binance"
+const exchange = new ccxt[exid]({
+  enableRateLimit: true,
+});
+
+// Reusable function to fetch OHLCV data and return an Asset object
+async function fetchOhlcvData(symbol, timeframe, limit) {
+  try {
+    if (!exchange.has["fetchOHLCV"]) {
+      throw new Error(`${exid} does not support fetchOHLCV`);
+    }  
+    const ohlcv = await exchange.fetchOHLCV(symbol, timeframe, undefined, limit);
+    return {
+      dates: ohlcv.map((row) => new Date(row[0])), // Timestamps as Date objects
+      openings: ohlcv.map((row) => row[1]), // Open prices
+      highs: ohlcv.map((row) => row[2]),    // High prices
+      lows: ohlcv.map((row) => row[3]),     // Low prices
+      closings: ohlcv.map((row) => row[4]), // Close prices (required)
+      volumes: ohlcv.map((row) => row[5]),  // Volumes
+    };
+  } catch (error) {
+    throw new Error(`Failed to fetch OHLCV data: ${error.message}`);
+  }
+}
+
+module.exports = fetchOhlcvData;

package/src/vendors/market-data/config/constants.ts

@@ -0,0 +1,8 @@
+/**
+ * @author Nich
+ * @website x.com/nichxbt
+ * @github github.com/nirholas
+ * @license MIT
+ */
+export const UNIVERSAL_CRYPTO_API_BASE = 'https://openapiv1.universal-crypto.app';
+export const UNIVERSAL_CRYPTO_API_KEY = process.env.UNIVERSAL_CRYPTO_API_KEY || '';

package/src/vendors/market-data/index.ts

@@ -0,0 +1,35 @@
+/**
+ * @author Nich
+ * @website x.com/nichxbt
+ * @github github.com/nirholas
+ * @license MIT
+ */
+#!/usr/bin/env node
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { registerTools } from './tools/toolFactory.js';
+import { allToolConfigs } from './tools/toolConfigs.js';
+
+// Create server instance
+const server = new McpServer({
+    name: 'universal-crypto-mcp',
+    version: '1.0.0',
+    capabilities: {
+        resources: {},
+        tools: {},
+    },
+});
+
+// Register all tools from configurations
+registerTools(server, allToolConfigs);
+
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('Universal Crypto MCP running on stdio');
+}
+
+main().catch((error) => {
+    console.error('Fatal error in main():', error);
+    process.exit(1);
+});

package/src/vendors/market-data/services/request.ts

@@ -0,0 +1,103 @@
+/**
+ * @author Nich
+ * @website x.com/nichxbt
+ * @github github.com/nirholas
+ * @license MIT
+ */
+import { UNIVERSAL_CRYPTO_API_KEY } from '../config/constants.js';
+
+// Helper function for making Universal Crypto API requests
+export async function makeRequestCsApi<T>(url: string, method: string = 'GET', params: Record<string, any> = {}, body?: any): Promise<T | null> {
+    const headers = {
+        'X-API-KEY': UNIVERSAL_CRYPTO_API_KEY,
+        'Content-Type': 'application/json',
+    };
+
+    try {
+        // Build request options
+        const options: RequestInit = { method, headers };
+
+        // Add body for non-GET requests if provided
+        if (method !== 'GET' && body) {
+            options.body = JSON.stringify(body);
+        }
+
+        // Add query params for all requests
+        const queryParams = new URLSearchParams(params);
+        const queryString = queryParams.toString();
+        const urlWithParams = queryString ? `${url}?${queryString}` : url;
+
+        const response = await fetch(urlWithParams, options);
+        if (!response.ok) {
+            throw new Error(`HTTP error! status: ${response.status}`);
+        }
+        return (await response.json()) as T;
+    } catch (error) {
+        return null;
+    }
+}
+
+// Universal handler for API requests
+export async function universalApiHandler<T>(
+    basePath: string,
+    endpoint: string,
+    method: string = 'GET',
+    params: Record<string, any> = {},
+    body?: any
+): Promise<{
+    content: Array<{ type: 'text'; text: string; isError?: boolean }>;
+}> {
+    try {
+        // Handle path parameters - replace {paramName} in endpoint with actual values
+        let processedEndpoint = endpoint;
+        let processedParams = { ...params };
+
+        // Find all path parameters in the endpoint (e.g., {coinId}, {id}, {type})
+        const pathParamMatches = endpoint.match(/\{([^}]+)\}/g);
+
+        if (pathParamMatches) {
+            for (const match of pathParamMatches) {
+                const paramName = match.slice(1, -1); // Remove { and }
+
+                if (processedParams[paramName] !== undefined) {
+                    // Replace the placeholder with the actual value
+                    processedEndpoint = processedEndpoint.replace(match, processedParams[paramName]);
+                    // Remove the parameter from query params since it's now part of the path
+                    delete processedParams[paramName];
+                } else {
+                    throw new Error(`Required path parameter '${paramName}' is missing`);
+                }
+            }
+        }
+
+        // MCP clients might not support '~' in parameter names, so we replace '-' with '~' specifically for the /coins endpoint before making the request.
+        if (endpoint === '/coins') {
+            processedParams = Object.entries(processedParams).reduce((acc, [key, value]) => {
+                acc[key.replace(/-/g, '~')] = value;
+                return acc;
+            }, {} as Record<string, any>);
+        }
+
+        const url = `${basePath}${processedEndpoint}`;
+        const data = await makeRequestCsApi<T>(url, method, processedParams, body);
+
+        if (!data) {
+            return {
+                content: [{ type: 'text', text: 'Something went wrong', isError: true }],
+            };
+        }
+
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: JSON.stringify(data),
+                },
+            ],
+        };
+    } catch (error) {
+        return {
+            content: [{ type: 'text', text: `Error: ${error}`, isError: true }],
+        };
+    }
+}