@guiie/buda-mcp 1.3.0 → 1.4.1

package/test/unit.ts

@@ -9,9 +9,14 @@ import { MemoryCache } from "../src/cache.js";
 import { validateMarketId } from "../src/validation.js";
 import { handlePlaceOrder } from "../src/tools/place_order.js";
 import { handleCancelOrder } from "../src/tools/cancel_order.js";
-import { flattenAmount, getLiquidityRating } from "../src/utils.js";
+import { flattenAmount, getLiquidityRating, aggregateTradesToCandles } from "../src/utils.js";
 import { handleArbitrageOpportunities } from "../src/tools/arbitrage.js";
 import { handleMarketSummary } from "../src/tools/market_summary.js";
+import { handleSimulateOrder } from "../src/tools/simulate_order.js";
+import { handleCalculatePositionSize } from "../src/tools/calculate_position_size.js";
+import { handleMarketSentiment } from "../src/tools/market_sentiment.js";
+import { handleTechnicalIndicators } from "../src/tools/technical_indicators.js";
+import { handleScheduleCancelAll, handleRenewCancelTimer, handleDisarmCancelTimer } from "../src/tools/dead_mans_switch.js";
 
 // ----------------------------------------------------------------
 // Minimal test harness
@@ -655,6 +660,505 @@ await test("handleMarketSummary returns correct liquidity_rating from mocked API
   }
 });
 
+// ----------------------------------------------------------------
+// i. simulate_order — simulation outputs
+// ----------------------------------------------------------------
+
+section("i. simulate_order");
+
+function makeMockFetchForSimulate(takerFee = "0.8"): typeof fetch {
+  const mockTicker = {
+    ticker: {
+      market_id: "BTC-CLP",
+      last_price: ["65000000", "CLP"],
+      max_bid: ["64900000", "CLP"],
+      min_ask: ["65100000", "CLP"],
+      volume: ["4.99", "BTC"],
+      price_variation_24h: "0.01",
+      price_variation_7d: "0.05",
+    },
+  };
+  const mockMarket = {
+    market: {
+      id: "btc-clp",
+      name: "BTC-CLP",
+      base_currency: "BTC",
+      quote_currency: "CLP",
+      taker_fee: takerFee,
+      maker_fee: "0.004",
+      minimum_order_amount: ["0.0001", "BTC"],
+      max_orders_per_minute: 50,
+      maker_discount_percentage: "0",
+      taker_discount_percentage: "0",
+      maker_discount_tiers: {},
+      taker_discount_tiers: {},
+    },
+  };
+  return async (url: string | URL): Promise<Response> => {
+    const urlStr = url.toString();
+    if (urlStr.includes("/ticker")) {
+      return new Response(JSON.stringify(mockTicker), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response(JSON.stringify(mockMarket), { status: 200, headers: { "Content-Type": "application/json" } });
+  };
+}
+
+await test("market buy: estimated_fill_price = min_ask, simulation: true", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = makeMockFetchForSimulate();
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleSimulateOrder({ market_id: "BTC-CLP", side: "buy", amount: 0.01 }, client, cache);
+    assert(!result.isError, "should not be an error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      simulation: boolean;
+      estimated_fill_price: number;
+      order_type_assumed: string;
+      fee_rate_pct: number;
+    };
+    assertEqual(parsed.simulation, true, "simulation flag must be true");
+    assertEqual(parsed.estimated_fill_price, 65100000, "market buy fills at min_ask");
+    assertEqual(parsed.order_type_assumed, "market", "order_type_assumed should be market");
+    assertEqual(parsed.fee_rate_pct, 0.8, "fee_rate_pct should be 0.8 for crypto (0.8% taker fee)");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("market sell: estimated_fill_price = max_bid", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = makeMockFetchForSimulate();
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleSimulateOrder({ market_id: "BTC-CLP", side: "sell", amount: 0.01 }, client, cache);
+    assert(!result.isError, "should not be an error");
+    const parsed = JSON.parse(result.content[0].text) as { estimated_fill_price: number };
+    assertEqual(parsed.estimated_fill_price, 64900000, "market sell fills at max_bid");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("limit order: order_type_assumed = 'limit'", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = makeMockFetchForSimulate();
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleSimulateOrder({ market_id: "BTC-CLP", side: "buy", amount: 0.01, price: 64000000 }, client, cache);
+    assert(!result.isError, "should not be an error");
+    const parsed = JSON.parse(result.content[0].text) as { order_type_assumed: string };
+    assertEqual(parsed.order_type_assumed, "limit", "order_type_assumed should be limit");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("stablecoin market uses 0.5% fee", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = makeMockFetchForSimulate("0.5");
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleSimulateOrder({ market_id: "BTC-CLP", side: "buy", amount: 1 }, client, cache);
+    assert(!result.isError, "should not be an error");
+    const parsed = JSON.parse(result.content[0].text) as { fee_rate_pct: number };
+    assertEqual(parsed.fee_rate_pct, 0.5, "fee_rate_pct should be 0.5 for stablecoin (0.5% taker fee)");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("simulate_order: invalid market_id returns INVALID_MARKET_ID error", async () => {
+  const fakeClient = {} as BudaClient;
+  const cache = new MemoryCache();
+  const result = await handleSimulateOrder({ market_id: "INVALID", side: "buy", amount: 1 }, fakeClient, cache);
+  assert(result.isError === true, "should be an error");
+  const parsed = JSON.parse(result.content[0].text) as { code: string };
+  assertEqual(parsed.code, "INVALID_MARKET_ID", "error code should be INVALID_MARKET_ID");
+});
+
+// ----------------------------------------------------------------
+// j. calculate_position_size — position math
+// ----------------------------------------------------------------
+
+section("j. calculate_position_size");
+
+await test("buy scenario: stop < entry, side = buy", () => {
+  const result = handleCalculatePositionSize({
+    market_id: "BTC-CLP",
+    capital: 1_000_000,
+    risk_pct: 2,
+    entry_price: 80_000_000,
+    stop_loss_price: 78_000_000,
+  });
+  assert(!result.isError, "should not be an error");
+  const parsed = JSON.parse(result.content[0].text) as {
+    side: string;
+    units: number;
+    capital_at_risk: number;
+    position_value: number;
+    fee_currency: string;
+  };
+  assertEqual(parsed.side, "buy", "side should be buy");
+  // capital_at_risk = 1_000_000 * 0.02 = 20_000; risk_per_unit = 2_000_000; units = 0.01
+  assertEqual(parsed.capital_at_risk, 20000, "capital_at_risk should be 20000");
+  assertEqual(parsed.units, 0.01, "units should be 0.01");
+  assertEqual(parsed.position_value, 800000, "position_value = 0.01 * 80_000_000");
+  assertEqual(parsed.fee_currency, "CLP", "fee_currency should be quote currency CLP");
+});
+
+await test("sell scenario: stop > entry, side = sell", () => {
+  const result = handleCalculatePositionSize({
+    market_id: "ETH-BTC",
+    capital: 1,
+    risk_pct: 1,
+    entry_price: 0.05,
+    stop_loss_price: 0.06,
+  });
+  assert(!result.isError, "should not be an error");
+  const parsed = JSON.parse(result.content[0].text) as { side: string; fee_currency: string };
+  assertEqual(parsed.side, "sell", "side should be sell");
+  assertEqual(parsed.fee_currency, "BTC", "fee_currency should be BTC");
+});
+
+await test("stop == entry returns INVALID_STOP_LOSS error", () => {
+  const result = handleCalculatePositionSize({
+    market_id: "BTC-CLP",
+    capital: 1_000_000,
+    risk_pct: 2,
+    entry_price: 80_000_000,
+    stop_loss_price: 80_000_000,
+  });
+  assert(result.isError === true, "should be an error");
+  const parsed = JSON.parse(result.content[0].text) as { code: string };
+  assertEqual(parsed.code, "INVALID_STOP_LOSS", "error code should be INVALID_STOP_LOSS");
+});
+
+await test("calculate_position_size: invalid market_id returns error", () => {
+  const result = handleCalculatePositionSize({
+    market_id: "bad",
+    capital: 100,
+    risk_pct: 1,
+    entry_price: 10,
+    stop_loss_price: 9,
+  });
+  assert(result.isError === true, "should be an error for invalid market_id");
+});
+
+// ----------------------------------------------------------------
+// k. get_market_sentiment — scoring and labels
+// ----------------------------------------------------------------
+
+section("k. get_market_sentiment");
+
+function makeMockFetchForSentiment(
+  priceVariation24h: string,
+  ask24h: string,
+  bid24h: string,
+  ask7d: string,
+  bid7d: string,
+  bid: string,
+  ask: string,
+): typeof fetch {
+  const mockTicker = {
+    ticker: {
+      market_id: "BTC-CLP",
+      last_price: ["65000000", "CLP"],
+      max_bid: [bid, "CLP"],
+      min_ask: [ask, "CLP"],
+      volume: ["4.99", "BTC"],
+      price_variation_24h: priceVariation24h,
+      price_variation_7d: "0.05",
+    },
+  };
+  const mockVolume = {
+    volume: {
+      market_id: "BTC-CLP",
+      ask_volume_24h: [ask24h, "BTC"],
+      ask_volume_7d: [ask7d, "BTC"],
+      bid_volume_24h: [bid24h, "BTC"],
+      bid_volume_7d: [bid7d, "BTC"],
+    },
+  };
+  return async (url: string | URL): Promise<Response> => {
+    const urlStr = url.toString();
+    if (urlStr.includes("/volume")) {
+      return new Response(JSON.stringify(mockVolume), { status: 200 });
+    }
+    return new Response(JSON.stringify(mockTicker), { status: 200 });
+  };
+}
+
+await test("disclaimer is always present in sentiment output", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = makeMockFetchForSentiment("0.01", "5", "5", "35", "35", "64900000", "65100000");
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleMarketSentiment({ market_id: "BTC-CLP" }, client, cache);
+    assert(!result.isError, "should not be an error");
+    const parsed = JSON.parse(result.content[0].text) as { disclaimer: string };
+    assert(parsed.disclaimer.length > 0, "disclaimer should be present and non-empty");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("neutral market produces label 'neutral' (score between -20 and 20)", async () => {
+  const savedFetch = globalThis.fetch;
+  // 0% price variation, volume ratio ~1 (neutral), spread at baseline
+  globalThis.fetch = makeMockFetchForSentiment("0", "5", "5", "35", "35", "64350000", "65000000");
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleMarketSentiment({ market_id: "BTC-CLP" }, client, cache);
+    assert(!result.isError, "should not be an error");
+    const parsed = JSON.parse(result.content[0].text) as { label: string; score: number };
+    assert(
+      parsed.label === "neutral" || parsed.label === "bearish" || parsed.label === "bullish",
+      `label should be a valid sentiment: got ${parsed.label}`,
+    );
+    assert(typeof parsed.score === "number", "score should be a number");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("strongly positive price variation produces bullish label", async () => {
+  const savedFetch = globalThis.fetch;
+  // +10% price variation → large positive price component → bullish
+  globalThis.fetch = makeMockFetchForSentiment("0.10", "10", "10", "35", "35", "64900000", "65100000");
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleMarketSentiment({ market_id: "BTC-CLP" }, client, cache);
+    assert(!result.isError, "should not be an error");
+    const parsed = JSON.parse(result.content[0].text) as { label: string };
+    assertEqual(parsed.label, "bullish", "strong positive price change should yield bullish");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("strongly negative price variation produces bearish label", async () => {
+  const savedFetch = globalThis.fetch;
+  // -10% price variation → bearish
+  globalThis.fetch = makeMockFetchForSentiment("-0.10", "5", "5", "35", "35", "64900000", "65100000");
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleMarketSentiment({ market_id: "BTC-CLP" }, client, cache);
+    assert(!result.isError, "should not be an error");
+    const parsed = JSON.parse(result.content[0].text) as { label: string };
+    assertEqual(parsed.label, "bearish", "strong negative price change should yield bearish");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("sentiment: invalid market_id returns error", async () => {
+  const fakeClient = {} as BudaClient;
+  const cache = new MemoryCache();
+  const result = await handleMarketSentiment({ market_id: "NOHYPHEN" }, fakeClient, cache);
+  assert(result.isError === true, "should be an error");
+});
+
+// ----------------------------------------------------------------
+// l. get_technical_indicators — math and edge cases
+// ----------------------------------------------------------------
+
+section("l. get_technical_indicators");
+
+await test("aggregateTradesToCandles: produces correct OHLCV from sorted trades", () => {
+  const now = Date.now();
+  const hourMs = 3600000;
+  const bucket = Math.floor(now / hourMs) * hourMs;
+  // 3 trades in the same 1h bucket
+  const entries: [string, string, string, string][] = [
+    [String(bucket + 1000), "0.1", "100", "buy"],
+    [String(bucket + 2000), "0.2", "110", "sell"],
+    [String(bucket + 3000), "0.05", "95", "buy"],
+  ];
+  const candles = aggregateTradesToCandles(entries, "1h");
+  assertEqual(candles.length, 1, "should produce 1 candle");
+  const c = candles[0];
+  assertEqual(c.open, 100, "open = first trade price");
+  assertEqual(c.close, 95, "close = last trade price");
+  assertEqual(c.high, 110, "high = max trade price");
+  assertEqual(c.low, 95, "low = min trade price");
+  assertEqual(c.trade_count, 3, "trade_count = 3");
+});
+
+await test("technical indicators: insufficient candles returns warning", async () => {
+  const savedFetch = globalThis.fetch;
+  // Return only 5 trades — will produce < 50 candles
+  const now = Date.now();
+  const hourMs = 3600000;
+  const entries = Array.from({ length: 5 }, (_, i) => {
+    const ts = now - (50 - i) * hourMs - 1000;
+    return [String(ts), "0.1", String(65000000 + i * 10000), "buy"];
+  });
+  const mockTrades = {
+    trades: {
+      market_id: "BTC-CLP",
+      timestamp: String(now),
+      last_timestamp: String(now),
+      entries,
+    },
+  };
+  globalThis.fetch = async (): Promise<Response> => {
+    return new Response(JSON.stringify(mockTrades), { status: 200 });
+  };
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleTechnicalIndicators({ market_id: "BTC-CLP", period: "1h" }, client);
+    assert(!result.isError, "should not be isError");
+    const parsed = JSON.parse(result.content[0].text) as {
+      warning: string;
+      indicators: null;
+      candles_available: number;
+      minimum_required: number;
+    };
+    assertEqual(parsed.warning, "insufficient_data", "should return insufficient_data warning");
+    assertEqual(parsed.indicators, null, "indicators should be null");
+    assertEqual(parsed.minimum_required, 50, "minimum_required should be 50");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("technical indicators: sufficient candles returns indicator values", async () => {
+  const savedFetch = globalThis.fetch;
+  // Generate 60 trades, each in its own 1h bucket, with steadily increasing prices
+  const now = Date.now();
+  const hourMs = 3600000;
+  const entries = Array.from({ length: 60 }, (_, i) => {
+    const ts = now - (60 - i) * hourMs - 1000;
+    return [String(ts), "0.1", String(60_000_000 + i * 100_000), "buy"];
+  });
+  const mockTrades = {
+    trades: {
+      market_id: "BTC-CLP",
+      timestamp: String(now),
+      last_timestamp: String(now),
+      entries,
+    },
+  };
+  globalThis.fetch = async (): Promise<Response> => {
+    return new Response(JSON.stringify(mockTrades), { status: 200 });
+  };
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleTechnicalIndicators({ market_id: "BTC-CLP", period: "1h" }, client);
+    assert(!result.isError, "should not be isError");
+    const parsed = JSON.parse(result.content[0].text) as {
+      indicators: { rsi: number; sma_20: number; sma_50: number };
+      signals: { rsi_signal: string };
+      disclaimer: string;
+    };
+    assert(parsed.indicators !== null, "indicators should not be null");
+    assert(typeof parsed.indicators.rsi === "number", "rsi should be a number");
+    assert(typeof parsed.indicators.sma_20 === "number", "sma_20 should be a number");
+    assert(typeof parsed.indicators.sma_50 === "number", "sma_50 should be a number");
+    // Steadily increasing prices → RSI should be high (overbought)
+    assertEqual(parsed.signals.rsi_signal, "overbought", "rising prices should yield overbought RSI");
+    assert(parsed.disclaimer.length > 0, "disclaimer should be present");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("technical indicators: invalid market_id returns error", async () => {
+  const fakeClient = {} as BudaClient;
+  const result = await handleTechnicalIndicators({ market_id: "BAD", period: "1h" }, fakeClient);
+  assert(result.isError === true, "should be an error for invalid market_id");
+});
+
+// ----------------------------------------------------------------
+// m. schedule_cancel_all (dead man's switch)
+// ----------------------------------------------------------------
+
+section("m. schedule_cancel_all (dead man's switch)");
+
+await test("schedule_cancel_all: requires CONFIRM token", async () => {
+  const fakeClient = {} as BudaClient;
+  const result = await handleScheduleCancelAll(
+    { market_id: "BTC-CLP", ttl_seconds: 30, confirmation_token: "yes" },
+    fakeClient,
+  );
+  assert(result.isError === true, "should return error without CONFIRM");
+  const parsed = JSON.parse(result.content[0].text) as { code: string };
+  assertEqual(parsed.code, "CONFIRMATION_REQUIRED", "error code should be CONFIRMATION_REQUIRED");
+});
+
+await test("schedule_cancel_all: invalid market_id returns error", async () => {
+  const fakeClient = {} as BudaClient;
+  const result = await handleScheduleCancelAll(
+    { market_id: "BAD", ttl_seconds: 30, confirmation_token: "CONFIRM" },
+    fakeClient,
+  );
+  assert(result.isError === true, "should return error for invalid market_id");
+  const parsed = JSON.parse(result.content[0].text) as { code: string };
+  assertEqual(parsed.code, "INVALID_MARKET_ID", "error code should be INVALID_MARKET_ID");
+});
+
+await test("schedule_cancel_all: CONFIRM activates timer and returns expires_at", async () => {
+  const fakeClient = {} as BudaClient;
+  const before = Date.now();
+  const result = await handleScheduleCancelAll(
+    { market_id: "BTC-USDT", ttl_seconds: 60, confirmation_token: "CONFIRM" },
+    fakeClient,
+  );
+  const after = Date.now();
+  assert(!result.isError, "should not be an error");
+  const parsed = JSON.parse(result.content[0].text) as {
+    active: boolean;
+    expires_at: string;
+    ttl_seconds: number;
+    warning: string;
+  };
+  assertEqual(parsed.active, true, "active should be true");
+  assertEqual(parsed.ttl_seconds, 60, "ttl_seconds should match");
+  assert(parsed.warning.length > 0, "warning should be present");
+  const expiresAt = new Date(parsed.expires_at).getTime();
+  assert(expiresAt >= before + 60000 && expiresAt <= after + 60000, "expires_at should be ~60s from now");
+  // Clean up timer
+  handleDisarmCancelTimer({ market_id: "BTC-USDT" });
+});
+
+await test("renew_cancel_timer: returns NO_ACTIVE_TIMER when no timer exists", () => {
+  const fakeClient = {} as BudaClient;
+  const result = handleRenewCancelTimer({ market_id: "ETH-CLP" }, fakeClient);
+  assert(result.isError === true, "should return error if no timer active");
+  const parsed = JSON.parse(result.content[0].text) as { code: string };
+  assertEqual(parsed.code, "NO_ACTIVE_TIMER", "error code should be NO_ACTIVE_TIMER");
+});
+
+await test("disarm_cancel_timer: no-op returns disarmed:false when no timer exists", () => {
+  const result = handleDisarmCancelTimer({ market_id: "LTC-CLP" });
+  assert(!result.isError, "disarm should not error even if no timer");
+  const parsed = JSON.parse(result.content[0].text) as { disarmed: boolean };
+  assertEqual(parsed.disarmed, false, "disarmed should be false when no timer existed");
+});
+
+await test("disarm after arm: timer is cleared", async () => {
+  const fakeClient = {} as BudaClient;
+  await handleScheduleCancelAll(
+    { market_id: "BCH-CLP", ttl_seconds: 300, confirmation_token: "CONFIRM" },
+    fakeClient,
+  );
+  const result = handleDisarmCancelTimer({ market_id: "BCH-CLP" });
+  assert(!result.isError, "disarm should not error");
+  const parsed = JSON.parse(result.content[0].text) as { disarmed: boolean };
+  assertEqual(parsed.disarmed, true, "disarmed should be true after an active timer was cleared");
+  // Confirm no timer remains
+  const renewResult = handleRenewCancelTimer({ market_id: "BCH-CLP" }, fakeClient);
+  assert(renewResult.isError === true, "should have no timer left after disarm");
+});
+
 // ----------------------------------------------------------------
 // Summary
 // ----------------------------------------------------------------