@guiie/buda-mcp 1.2.2 → 1.4.0

package/test/unit.ts

@@ -9,6 +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, 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
@@ -401,6 +409,756 @@ await test("defaults to 1000ms when Retry-After header is absent", async () => {
   }
 });
 
+// ----------------------------------------------------------------
+// f. Numeric flattening — flattenAmount returns typed float, not string
+// ----------------------------------------------------------------
+
+section("f. Numeric flattening — flattenAmount");
+
+await test("flattenAmount returns a number value, not a string", () => {
+  const result = flattenAmount(["65000000", "CLP"]);
+  assert(typeof result.value === "number", "value should be a number");
+  assertEqual(result.value, 65000000, "value should equal 65000000");
+  assertEqual(result.currency, "CLP", "currency should equal CLP");
+});
+
+await test("flattenAmount handles decimal strings correctly", () => {
+  const result = flattenAmount(["4.99123456", "BTC"]);
+  assert(typeof result.value === "number", "value should be a number");
+  assertEqual(result.value, 4.99123456, "value should equal 4.99123456");
+  assertEqual(result.currency, "BTC", "currency should equal BTC");
+});
+
+await test("flattenAmount on zero amount", () => {
+  const result = flattenAmount(["0.0", "CLP"]);
+  assertEqual(result.value, 0, "zero should parse to 0");
+});
+
+await test("flattenAmount value is not a string array", () => {
+  const result = flattenAmount(["65000000", "CLP"]);
+  assert(!Array.isArray(result), "result should not be an array");
+  assert(typeof result.value !== "string", "value should not be a string");
+});
+
+// ----------------------------------------------------------------
+// g. get_arbitrage_opportunities — discrepancy calculation
+// ----------------------------------------------------------------
+
+section("g. get_arbitrage_opportunities — discrepancy calculation");
+
+await test("correctly computes USDC-normalized price discrepancy between CLP and PEN markets", async () => {
+  const savedFetch = globalThis.fetch;
+
+  // BTC-CLP: 65000000 CLP, USDC-CLP: 1000 CLP → BTC in USDC = 65000
+  // BTC-PEN: 250000000 PEN, USDC-PEN: 3700 PEN → BTC in USDC ≈ 67567.567...
+  // Discrepancy: (67567.567 - 65000) / 65000 * 100 ≈ 3.95%
+  const mockTickers = {
+    tickers: [
+      { 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" },
+      { market_id: "BTC-PEN", last_price: ["250000000", "PEN"], max_bid: ["249500000", "PEN"], min_ask: ["250500000", "PEN"], volume: ["1.5", "BTC"], price_variation_24h: "0.012", price_variation_7d: "0.04" },
+      { market_id: "USDC-CLP", last_price: ["1000", "CLP"], max_bid: ["999", "CLP"], min_ask: ["1001", "CLP"], volume: ["100", "USDC"], price_variation_24h: "0.001", price_variation_7d: "0.002" },
+      { market_id: "USDC-PEN", last_price: ["3700", "PEN"], max_bid: ["3695", "PEN"], min_ask: ["3705", "PEN"], volume: ["50", "USDC"], price_variation_24h: "0.001", price_variation_7d: "0.002" },
+    ],
+  };
+
+  globalThis.fetch = async (): Promise<Response> => {
+    return new Response(JSON.stringify(mockTickers), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  };
+
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleArbitrageOpportunities(
+      { base_currency: "BTC", threshold_pct: 0.5 },
+      client,
+      cache,
+    );
+
+    assert(!result.isError, "should not return an error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      opportunities: Array<{ market_a: string; market_b: string; discrepancy_pct: number }>;
+      markets_analyzed: Array<{ market_id: string; price_usdc: number }>;
+    };
+
+    assertEqual(parsed.markets_analyzed.length, 2, "should have 2 markets analyzed");
+    assertEqual(parsed.opportunities.length, 1, "should have exactly 1 opportunity");
+
+    const opp = parsed.opportunities[0];
+    const expectedDiscrepancy = ((67567.5676 - 65000) / 65000) * 100;
+    assert(
+      Math.abs(opp.discrepancy_pct - expectedDiscrepancy) < 0.01,
+      `discrepancy_pct should be ≈${expectedDiscrepancy.toFixed(2)}%, got ${opp.discrepancy_pct}`,
+    );
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("threshold filtering excludes opportunities below threshold", async () => {
+  const savedFetch = globalThis.fetch;
+
+  // ~3.95% discrepancy between CLP and PEN — threshold 5% should exclude it
+  const mockTickers = {
+    tickers: [
+      { 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" },
+      { market_id: "BTC-PEN", last_price: ["250000000", "PEN"], max_bid: ["249500000", "PEN"], min_ask: ["250500000", "PEN"], volume: ["1.5", "BTC"], price_variation_24h: "0.012", price_variation_7d: "0.04" },
+      { market_id: "USDC-CLP", last_price: ["1000", "CLP"], max_bid: ["999", "CLP"], min_ask: ["1001", "CLP"], volume: ["100", "USDC"], price_variation_24h: "0.001", price_variation_7d: "0.002" },
+      { market_id: "USDC-PEN", last_price: ["3700", "PEN"], max_bid: ["3695", "PEN"], min_ask: ["3705", "PEN"], volume: ["50", "USDC"], price_variation_24h: "0.001", price_variation_7d: "0.002" },
+    ],
+  };
+
+  globalThis.fetch = async (): Promise<Response> => {
+    return new Response(JSON.stringify(mockTickers), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  };
+
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleArbitrageOpportunities(
+      { base_currency: "BTC", threshold_pct: 5.0 },
+      client,
+      cache,
+    );
+
+    assert(!result.isError, "should not return an error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      opportunities: Array<unknown>;
+    };
+    assertEqual(parsed.opportunities.length, 0, "threshold 5% should exclude the ~3.95% discrepancy");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("returns error when fewer than 2 markets are found", async () => {
+  const savedFetch = globalThis.fetch;
+
+  // Only CLP market available, no PEN or COP
+  const mockTickers = {
+    tickers: [
+      { 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" },
+      { market_id: "USDC-CLP", last_price: ["1000", "CLP"], max_bid: ["999", "CLP"], min_ask: ["1001", "CLP"], volume: ["100", "USDC"], price_variation_24h: "0.001", price_variation_7d: "0.002" },
+    ],
+  };
+
+  globalThis.fetch = async (): Promise<Response> => {
+    return new Response(JSON.stringify(mockTickers), {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+    });
+  };
+
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleArbitrageOpportunities(
+      { base_currency: "BTC", threshold_pct: 0.5 },
+      client,
+      cache,
+    );
+    assert(result.isError === true, "should return isError when not enough markets");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// h. get_market_summary — liquidity_rating thresholds
+// ----------------------------------------------------------------
+
+section("h. get_market_summary — liquidity_rating thresholds");
+
+await test("getLiquidityRating: spread < 0.3% → 'high'", () => {
+  assertEqual(getLiquidityRating(0), "high", "0% spread should be high");
+  assertEqual(getLiquidityRating(0.1), "high", "0.1% spread should be high");
+  assertEqual(getLiquidityRating(0.29), "high", "0.29% spread should be high");
+});
+
+await test("getLiquidityRating: spread at 0.3% boundary → 'medium'", () => {
+  assertEqual(getLiquidityRating(0.3), "medium", "exactly 0.3% spread should be medium");
+});
+
+await test("getLiquidityRating: spread 0.3–1% → 'medium'", () => {
+  assertEqual(getLiquidityRating(0.5), "medium", "0.5% spread should be medium");
+  assertEqual(getLiquidityRating(1.0), "medium", "exactly 1.0% spread should be medium");
+});
+
+await test("getLiquidityRating: spread > 1% → 'low'", () => {
+  assertEqual(getLiquidityRating(1.01), "low", "1.01% spread should be low");
+  assertEqual(getLiquidityRating(5.0), "low", "5% spread should be low");
+});
+
+await test("handleMarketSummary returns correct liquidity_rating from mocked API", async () => {
+  const savedFetch = globalThis.fetch;
+  let callCount = 0;
+
+  // Ticker: bid 64870, ask 65000 → spread = 130 / 65000 * 100 = 0.2% → "high"
+  const mockTicker = {
+    ticker: {
+      market_id: "BTC-CLP",
+      last_price: ["65000", "CLP"],
+      max_bid: ["64870", "CLP"],
+      min_ask: ["65000", "CLP"],
+      volume: ["4.99", "BTC"],
+      price_variation_24h: "0.012",
+      price_variation_7d: "0.05",
+    },
+  };
+  const mockVolume = {
+    volume: {
+      market_id: "BTC-CLP",
+      ask_volume_24h: ["10.5", "BTC"],
+      ask_volume_7d: ["72.1", "BTC"],
+      bid_volume_24h: ["9.8", "BTC"],
+      bid_volume_7d: ["68.3", "BTC"],
+    },
+  };
+
+  globalThis.fetch = async (url: string | URL): Promise<Response> => {
+    callCount++;
+    const urlStr = url.toString();
+    if (urlStr.includes("/volume")) {
+      return new Response(JSON.stringify(mockVolume), { status: 200, headers: { "Content-Type": "application/json" } });
+    }
+    return new Response(JSON.stringify(mockTicker), { status: 200, headers: { "Content-Type": "application/json" } });
+  };
+
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleMarketSummary({ market_id: "BTC-CLP" }, client, cache);
+
+    assert(!result.isError, "should not return an error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      market_id: string;
+      last_price: number;
+      last_price_currency: string;
+      bid: number;
+      ask: number;
+      spread_pct: number;
+      volume_24h: number;
+      liquidity_rating: string;
+    };
+
+    assertEqual(parsed.market_id, "BTC-CLP", "market_id should match");
+    assertEqual(parsed.last_price, 65000, "last_price should be a number");
+    assert(typeof parsed.last_price === "number", "last_price should be a number type");
+    assertEqual(parsed.last_price_currency, "CLP", "currency should be CLP");
+    assertEqual(parsed.bid, 64870, "bid should be a float");
+    assertEqual(parsed.ask, 65000, "ask should be a float");
+    // spread = (65000 - 64870) / 65000 * 100 = 130/65000*100 = 0.2%
+    assertEqual(parsed.liquidity_rating, "high", "spread 0.2% should yield 'high' liquidity");
+    assertEqual(parsed.volume_24h, 10.5, "volume_24h should be a float");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// i. simulate_order — simulation outputs
+// ----------------------------------------------------------------
+
+section("i. simulate_order");
+
+function makeMockFetchForSimulate(takerFee = "0.008"): 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 should be 0.8% for crypto");
+  } 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.005");
+  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");
+  } 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
 // ----------------------------------------------------------------