@guiie/buda-mcp 1.3.0 → 1.4.0

package/dist/tools/dead_mans_switch.js

@@ -0,0 +1,236 @@
+import { z } from "zod";
+import { validateMarketId } from "../validation.js";
+const timers = new Map();
+async function cancelAllOrdersForMarket(marketId, client) {
+    try {
+        const data = await client.get(`/markets/${marketId}/orders`, { state: "pending", per: 300 });
+        const orders = data.orders ?? [];
+        await Promise.allSettled(orders.map((order) => client.put(`/orders/${order.id}`, { state: "canceling" })));
+        timers.delete(marketId);
+    }
+    catch {
+        // Swallow errors — the timer has fired; we cannot surface them to the caller
+        timers.delete(marketId);
+    }
+}
+function armTimer(marketId, ttlSeconds, client) {
+    const existing = timers.get(marketId);
+    if (existing)
+        clearTimeout(existing.timeout);
+    const expiresAt = Date.now() + ttlSeconds * 1000;
+    const timeout = setTimeout(() => {
+        void cancelAllOrdersForMarket(marketId, client);
+    }, ttlSeconds * 1000);
+    const entry = { timeout, expiresAt, ttlSeconds };
+    timers.set(marketId, entry);
+    return entry;
+}
+// ---- Tool schemas ----
+export const toolSchema = {
+    name: "schedule_cancel_all",
+    description: "WARNING: timer state is lost on server restart. Not suitable as a production dead man's switch " +
+        "on hosted deployments (e.g. Railway). Use only on locally-run instances.\n\n" +
+        "Arms an in-memory dead man's switch: if not renewed within ttl_seconds, all open orders for the " +
+        "market are automatically cancelled. Requires confirmation_token='CONFIRM' to activate. " +
+        "Use renew_cancel_timer to reset the countdown, or disarm_cancel_timer to cancel without touching orders. " +
+        "Requires BUDA_API_KEY and BUDA_API_SECRET environment variables.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            market_id: {
+                type: "string",
+                description: "Market ID to protect (e.g. 'BTC-CLP').",
+            },
+            ttl_seconds: {
+                type: "number",
+                description: "Seconds before all orders are cancelled if not renewed (10–300).",
+            },
+            confirmation_token: {
+                type: "string",
+                description: "Must equal exactly 'CONFIRM' (case-sensitive) to arm the switch.",
+            },
+        },
+        required: ["market_id", "ttl_seconds", "confirmation_token"],
+    },
+};
+export const renewToolSchema = {
+    name: "renew_cancel_timer",
+    description: "Resets the dead man's switch TTL for a market, preventing automatic order cancellation. " +
+        "No confirmation required. Requires an active timer set by schedule_cancel_all. " +
+        "Requires BUDA_API_KEY and BUDA_API_SECRET environment variables.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            market_id: {
+                type: "string",
+                description: "Market ID whose timer should be renewed (e.g. 'BTC-CLP').",
+            },
+        },
+        required: ["market_id"],
+    },
+};
+export const disarmToolSchema = {
+    name: "disarm_cancel_timer",
+    description: "Disarms the dead man's switch for a market without cancelling any orders. " +
+        "No confirmation required. Safe to call even if no timer is active. " +
+        "Requires BUDA_API_KEY and BUDA_API_SECRET environment variables.",
+    inputSchema: {
+        type: "object",
+        properties: {
+            market_id: {
+                type: "string",
+                description: "Market ID whose timer should be disarmed (e.g. 'BTC-CLP').",
+            },
+        },
+        required: ["market_id"],
+    },
+};
+export async function handleScheduleCancelAll(args, client) {
+    const { market_id, ttl_seconds, confirmation_token } = args;
+    if (confirmation_token !== "CONFIRM") {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "Dead man's switch not armed. confirmation_token must equal 'CONFIRM' to activate. " +
+                            "Review the parameters and set confirmation_token='CONFIRM' to proceed.",
+                        code: "CONFIRMATION_REQUIRED",
+                        market_id,
+                        ttl_seconds,
+                    }),
+                },
+            ],
+            isError: true,
+        };
+    }
+    const validationError = validateMarketId(market_id);
+    if (validationError) {
+        return {
+            content: [{ type: "text", text: JSON.stringify({ error: validationError, code: "INVALID_MARKET_ID" }) }],
+            isError: true,
+        };
+    }
+    const id = market_id.toLowerCase();
+    const entry = armTimer(id, ttl_seconds, client);
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    active: true,
+                    market_id: market_id.toUpperCase(),
+                    expires_at: new Date(entry.expiresAt).toISOString(),
+                    ttl_seconds,
+                    warning: "in-memory only — timer is lost on server restart. Not suitable for hosted deployments.",
+                }),
+            },
+        ],
+    };
+}
+export function handleRenewCancelTimer({ market_id }, client) {
+    const validationError = validateMarketId(market_id);
+    if (validationError) {
+        return {
+            content: [{ type: "text", text: JSON.stringify({ error: validationError, code: "INVALID_MARKET_ID" }) }],
+            isError: true,
+        };
+    }
+    const id = market_id.toLowerCase();
+    const existing = timers.get(id);
+    if (!existing) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: `No active dead man's switch for market ${market_id.toUpperCase()}. Arm one first with schedule_cancel_all.`,
+                        code: "NO_ACTIVE_TIMER",
+                        market_id: market_id.toUpperCase(),
+                    }),
+                },
+            ],
+            isError: true,
+        };
+    }
+    const entry = armTimer(id, existing.ttlSeconds, client);
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    active: true,
+                    market_id: market_id.toUpperCase(),
+                    expires_at: new Date(entry.expiresAt).toISOString(),
+                    ttl_seconds: entry.ttlSeconds,
+                }),
+            },
+        ],
+    };
+}
+export function handleDisarmCancelTimer({ market_id }) {
+    const validationError = validateMarketId(market_id);
+    if (validationError) {
+        return {
+            content: [{ type: "text", text: JSON.stringify({ error: validationError, code: "INVALID_MARKET_ID" }) }],
+            isError: true,
+        };
+    }
+    const id = market_id.toLowerCase();
+    const existing = timers.get(id);
+    if (!existing) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        disarmed: false,
+                        market_id: market_id.toUpperCase(),
+                        note: "No active timer for this market.",
+                    }),
+                },
+            ],
+        };
+    }
+    clearTimeout(existing.timeout);
+    timers.delete(id);
+    return {
+        content: [
+            {
+                type: "text",
+                text: JSON.stringify({
+                    disarmed: true,
+                    market_id: market_id.toUpperCase(),
+                }),
+            },
+        ],
+    };
+}
+// ---- Registration ----
+export function register(server, client) {
+    server.tool(toolSchema.name, toolSchema.description, {
+        market_id: z
+            .string()
+            .describe("Market ID to protect (e.g. 'BTC-CLP')."),
+        ttl_seconds: z
+            .number()
+            .int()
+            .min(10)
+            .max(300)
+            .describe("Seconds before all orders are cancelled if not renewed (10–300)."),
+        confirmation_token: z
+            .string()
+            .describe("Must equal exactly 'CONFIRM' (case-sensitive) to arm the switch."),
+    }, (args) => handleScheduleCancelAll(args, client));
+    server.tool(renewToolSchema.name, renewToolSchema.description, {
+        market_id: z
+            .string()
+            .describe("Market ID whose timer should be renewed (e.g. 'BTC-CLP')."),
+    }, (args) => handleRenewCancelTimer(args, client));
+    server.tool(disarmToolSchema.name, disarmToolSchema.description, {
+        market_id: z
+            .string()
+            .describe("Market ID whose timer should be disarmed (e.g. 'BTC-CLP')."),
+    }, (args) => handleDisarmCancelTimer(args));
+}
+//# sourceMappingURL=dead_mans_switch.js.map

package/dist/tools/market_sentiment.d.ts

@@ -0,0 +1,30 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BudaClient } from "../client.js";
+import { MemoryCache } from "../cache.js";
+export declare const toolSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            market_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+type MarketSentimentArgs = {
+    market_id: string;
+};
+export declare function handleMarketSentiment({ market_id }: MarketSentimentArgs, client: BudaClient, cache: MemoryCache): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare function register(server: McpServer, client: BudaClient, cache: MemoryCache): void;
+export {};
+//# sourceMappingURL=market_sentiment.d.ts.map

package/dist/tools/market_sentiment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"market_sentiment.d.ts","sourceRoot":"","sources":["../../src/tools/market_sentiment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAgB,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,WAAW,EAAa,MAAM,aAAa,CAAC;AAIrD,eAAO,MAAM,UAAU;;;;;;;;;;;;;CAiBtB,CAAC;AAUF,KAAK,mBAAmB,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjD,wBAAsB,qBAAqB,CACzC,EAAE,SAAS,EAAE,EAAE,mBAAmB,EAClC,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,WAAW,GACjB,OAAO,CAAC;IAAE,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAuFhF;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAWxF"}

package/dist/tools/market_sentiment.js

@@ -0,0 +1,104 @@
+import { z } from "zod";
+import { BudaApiError } from "../client.js";
+import { CACHE_TTL } from "../cache.js";
+import { validateMarketId } from "../validation.js";
+export const toolSchema = {
+    name: "get_market_sentiment",
+    description: "Computes a composite sentiment score (−100 to +100) for a Buda.com market based on " +
+        "24h price variation (40%), volume vs 7-day average (35%), and bid/ask spread vs baseline (25%). " +
+        "Returns a score, a label (bearish/neutral/bullish), and a full component breakdown. " +
+        "Example: 'Is the BTC-CLP market currently bullish or bearish?'",
+    inputSchema: {
+        type: "object",
+        properties: {
+            market_id: {
+                type: "string",
+                description: "Market ID (e.g. 'BTC-CLP', 'ETH-BTC', 'BTC-USDT').",
+            },
+        },
+        required: ["market_id"],
+    },
+};
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function isStablecoinPair(marketId) {
+    return /-(USDT|USDC|DAI|TUSD)$/i.test(marketId);
+}
+export async function handleMarketSentiment({ market_id }, client, cache) {
+    const validationError = validateMarketId(market_id);
+    if (validationError) {
+        return {
+            content: [{ type: "text", text: JSON.stringify({ error: validationError, code: "INVALID_MARKET_ID" }) }],
+            isError: true,
+        };
+    }
+    try {
+        const id = market_id.toLowerCase();
+        const [tickerData, volumeData] = await Promise.all([
+            cache.getOrFetch(`ticker:${id}`, CACHE_TTL.TICKER, () => client.get(`/markets/${id}/ticker`)),
+            client.get(`/markets/${id}/volume`),
+        ]);
+        const ticker = tickerData.ticker;
+        const vol = volumeData.volume;
+        const bid = parseFloat(ticker.max_bid[0]);
+        const ask = parseFloat(ticker.min_ask[0]);
+        const priceVariation24h = parseFloat(ticker.price_variation_24h);
+        const ask24h = parseFloat(vol.ask_volume_24h[0]);
+        const bid24h = parseFloat(vol.bid_volume_24h[0]);
+        const ask7d = parseFloat(vol.ask_volume_7d[0]);
+        const bid7d = parseFloat(vol.bid_volume_7d[0]);
+        const spreadPct = ask > 0 ? ((ask - bid) / ask) * 100 : 0;
+        const spreadBaseline = isStablecoinPair(market_id) ? 0.3 : 1.0;
+        const volume24h = ask24h + bid24h;
+        const volume7d = ask7d + bid7d;
+        const volumeRatio = volume7d > 0 ? (volume24h * 7) / volume7d : 1;
+        // Price component: ±5% daily change → ±100 on this sub-score
+        const priceRaw = clamp(priceVariation24h * 2000, -100, 100);
+        const priceScore = parseFloat((priceRaw * 0.4).toFixed(4));
+        // Volume component: ratio vs 7d daily average
+        const volumeRaw = clamp((volumeRatio - 1) * 100, -100, 100);
+        const volumeScore = parseFloat((volumeRaw * 0.35).toFixed(4));
+        // Spread component: tighter spread is bullish
+        const spreadRaw = clamp((1 - spreadPct / spreadBaseline) * 100, -100, 100);
+        const spreadScore = parseFloat((spreadRaw * 0.25).toFixed(4));
+        const score = parseFloat((priceScore + volumeScore + spreadScore).toFixed(1));
+        const label = score < -20 ? "bearish" : score > 20 ? "bullish" : "neutral";
+        const result = {
+            market_id: ticker.market_id,
+            score,
+            label,
+            component_breakdown: {
+                price_variation_24h_pct: parseFloat((priceVariation24h * 100).toFixed(4)),
+                volume_ratio: parseFloat(volumeRatio.toFixed(4)),
+                spread_pct: parseFloat(spreadPct.toFixed(4)),
+                spread_baseline_pct: spreadBaseline,
+                price_score: priceScore,
+                volume_score: volumeScore,
+                spread_score: spreadScore,
+            },
+            data_timestamp: new Date().toISOString(),
+            disclaimer: "Sentiment is derived from market microstructure data only. Not investment advice.",
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof BudaApiError
+            ? { error: err.message, code: err.status, path: err.path }
+            : { error: String(err), code: "UNKNOWN" };
+        return {
+            content: [{ type: "text", text: JSON.stringify(msg) }],
+            isError: true,
+        };
+    }
+}
+export function register(server, client, cache) {
+    server.tool(toolSchema.name, toolSchema.description, {
+        market_id: z
+            .string()
+            .describe("Market ID (e.g. 'BTC-CLP', 'ETH-BTC', 'BTC-USDT')."),
+    }, (args) => handleMarketSentiment(args, client, cache));
+}
+//# sourceMappingURL=market_sentiment.js.map

package/dist/tools/price_history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"price_history.d.ts","sourceRoot":"","sources":["../../src/tools/price_history.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAgB,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAoB1C,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;CA4BtB,CAAC;AAEF,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,CAsHzF"}
+{"version":3,"file":"price_history.d.ts","sourceRoot":"","sources":["../../src/tools/price_history.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAgB,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAK1C,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;CA4BtB,CAAC;AAEF,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,IAAI,CAiFzF"}

package/dist/tools/price_history.js

@@ -1,11 +1,7 @@
 import { z } from "zod";
 import { BudaApiError } from "../client.js";
 import { validateMarketId } from "../validation.js";
-const PERIOD_MS = {
-    "1h": 60 * 60 * 1000,
-    "4h": 4 * 60 * 60 * 1000,
-    "1d": 24 * 60 * 60 * 1000,
-};
+import { aggregateTradesToCandles } from "../utils.js";
 export const toolSchema = {
     name: "get_price_history",
     description: "IMPORTANT: Candles are aggregated client-side from raw trades (Buda has no native candlestick " +
@@ -73,41 +69,7 @@ export function register(server, client, _cache) {
                     ],
                 };
             }
-            // Buda returns trades newest-first; sort ascending so open = first chronological price
-            // and close = last chronological price within each candle bucket.
-            const sortedEntries = [...entries].sort(([a], [b]) => parseInt(a, 10) - parseInt(b, 10));
-            const periodMs = PERIOD_MS[period];
-            const buckets = new Map();
-            for (const [tsMs, amount, price, _direction] of sortedEntries) {
-                const ts = parseInt(tsMs, 10);
-                const bucketStart = Math.floor(ts / periodMs) * periodMs;
-                const p = parseFloat(price);
-                const v = parseFloat(amount);
-                if (!buckets.has(bucketStart)) {
-                    buckets.set(bucketStart, {
-                        time: new Date(bucketStart).toISOString(),
-                        open: p,
-                        high: p,
-                        low: p,
-                        close: p,
-                        volume: v,
-                        trade_count: 1,
-                    });
-                }
-                else {
-                    const candle = buckets.get(bucketStart);
-                    if (p > candle.high)
-                        candle.high = p;
-                    if (p < candle.low)
-                        candle.low = p;
-                    candle.close = p;
-                    candle.volume = parseFloat((candle.volume + v).toFixed(8));
-                    candle.trade_count++;
-                }
-            }
-            const candles = Array.from(buckets.entries())
-                .sort(([a], [b]) => a - b)
-                .map(([, candle]) => candle);
+            const candles = aggregateTradesToCandles(entries, period);
             const result = {
                 market_id: market_id.toUpperCase(),
                 period,

package/dist/tools/simulate_order.d.ts

@@ -0,0 +1,45 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BudaClient } from "../client.js";
+import { MemoryCache } from "../cache.js";
+export declare const toolSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            market_id: {
+                type: string;
+                description: string;
+            };
+            side: {
+                type: string;
+                description: string;
+            };
+            amount: {
+                type: string;
+                description: string;
+            };
+            price: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+type SimulateOrderArgs = {
+    market_id: string;
+    side: "buy" | "sell";
+    amount: number;
+    price?: number;
+};
+export declare function handleSimulateOrder(args: SimulateOrderArgs, client: BudaClient, cache: MemoryCache): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare function register(server: McpServer, client: BudaClient, cache: MemoryCache): void;
+export {};
+//# sourceMappingURL=simulate_order.d.ts.map

package/dist/tools/simulate_order.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"simulate_order.d.ts","sourceRoot":"","sources":["../../src/tools/simulate_order.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAgB,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,WAAW,EAAa,MAAM,aAAa,CAAC;AAIrD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;CA+BtB,CAAC;AAEF,KAAK,iBAAiB,GAAG;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;IACrB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAsB,mBAAmB,CACvC,IAAI,EAAE,iBAAiB,EACvB,MAAM,EAAE,UAAU,EAClB,KAAK,EAAE,WAAW,GACjB,OAAO,CAAC;IAAE,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAyGhF;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAuBxF"}

package/dist/tools/simulate_order.js

@@ -0,0 +1,139 @@
+import { z } from "zod";
+import { BudaApiError } from "../client.js";
+import { CACHE_TTL } from "../cache.js";
+import { validateMarketId } from "../validation.js";
+export const toolSchema = {
+    name: "simulate_order",
+    description: "Simulates a buy or sell order on Buda.com using live ticker data — no order is placed. " +
+        "Returns estimated fill price, fee, total cost, and slippage vs mid-price. " +
+        "Omit 'price' for a market order simulation; supply 'price' for a limit order simulation. " +
+        "All outputs are labelled simulation: true — this tool never places a real order. " +
+        "Example: 'How much would it cost to buy 0.01 BTC on BTC-CLP right now?'",
+    inputSchema: {
+        type: "object",
+        properties: {
+            market_id: {
+                type: "string",
+                description: "Market ID (e.g. 'BTC-CLP', 'ETH-BTC').",
+            },
+            side: {
+                type: "string",
+                description: "'buy' or 'sell'.",
+            },
+            amount: {
+                type: "number",
+                description: "Order size in base currency (e.g. BTC for BTC-CLP).",
+            },
+            price: {
+                type: "number",
+                description: "Limit price in quote currency. Omit for a market order simulation.",
+            },
+        },
+        required: ["market_id", "side", "amount"],
+    },
+};
+export async function handleSimulateOrder(args, client, cache) {
+    const { market_id, side, amount, price } = args;
+    const validationError = validateMarketId(market_id);
+    if (validationError) {
+        return {
+            content: [{ type: "text", text: JSON.stringify({ error: validationError, code: "INVALID_MARKET_ID" }) }],
+            isError: true,
+        };
+    }
+    try {
+        const id = market_id.toLowerCase();
+        const [tickerData, marketData] = await Promise.all([
+            cache.getOrFetch(`ticker:${id}`, CACHE_TTL.TICKER, () => client.get(`/markets/${id}/ticker`)),
+            cache.getOrFetch(`market:${id}`, CACHE_TTL.MARKETS, () => client.get(`/markets/${id}`)),
+        ]);
+        const ticker = tickerData.ticker;
+        const market = marketData.market;
+        const minAsk = parseFloat(ticker.min_ask[0]);
+        const maxBid = parseFloat(ticker.max_bid[0]);
+        const quoteCurrency = ticker.min_ask[1];
+        if (isNaN(minAsk) || isNaN(maxBid) || minAsk <= 0 || maxBid <= 0) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: "Unable to simulate: invalid or zero bid/ask values in ticker.",
+                            code: "INVALID_TICKER",
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const mid = (minAsk + maxBid) / 2;
+        const takerFeeRate = parseFloat(market.taker_fee);
+        const orderTypeAssumed = price !== undefined ? "limit" : "market";
+        let estimatedFillPrice;
+        if (orderTypeAssumed === "market") {
+            estimatedFillPrice = side === "buy" ? minAsk : maxBid;
+        }
+        else {
+            // Limit order: fill at provided price if it crosses the spread, otherwise at limit price
+            if (side === "buy") {
+                estimatedFillPrice = price >= minAsk ? minAsk : price;
+            }
+            else {
+                estimatedFillPrice = price <= maxBid ? maxBid : price;
+            }
+        }
+        const grossValue = amount * estimatedFillPrice;
+        const feeAmount = parseFloat((grossValue * takerFeeRate).toFixed(8));
+        const totalCost = side === "buy"
+            ? parseFloat((grossValue + feeAmount).toFixed(8))
+            : parseFloat((grossValue - feeAmount).toFixed(8));
+        const slippageVsMidPct = parseFloat((((estimatedFillPrice - mid) / mid) * 100).toFixed(4));
+        const result = {
+            simulation: true,
+            market_id: ticker.market_id,
+            side,
+            amount,
+            order_type_assumed: orderTypeAssumed,
+            estimated_fill_price: parseFloat(estimatedFillPrice.toFixed(2)),
+            price_currency: quoteCurrency,
+            fee_amount: feeAmount,
+            fee_currency: quoteCurrency,
+            fee_rate_pct: parseFloat((takerFeeRate * 100).toFixed(3)),
+            total_cost: totalCost,
+            slippage_vs_mid_pct: slippageVsMidPct,
+            mid_price: parseFloat(mid.toFixed(2)),
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    }
+    catch (err) {
+        const msg = err instanceof BudaApiError
+            ? { error: err.message, code: err.status, path: err.path }
+            : { error: String(err), code: "UNKNOWN" };
+        return {
+            content: [{ type: "text", text: JSON.stringify(msg) }],
+            isError: true,
+        };
+    }
+}
+export function register(server, client, cache) {
+    server.tool(toolSchema.name, toolSchema.description, {
+        market_id: z
+            .string()
+            .describe("Market ID (e.g. 'BTC-CLP', 'ETH-BTC')."),
+        side: z
+            .enum(["buy", "sell"])
+            .describe("'buy' or 'sell'."),
+        amount: z
+            .number()
+            .positive()
+            .describe("Order size in base currency (e.g. BTC for BTC-CLP)."),
+        price: z
+            .number()
+            .positive()
+            .optional()
+            .describe("Limit price in quote currency. Omit for a market order simulation."),
+    }, (args) => handleSimulateOrder(args, client, cache));
+}
+//# sourceMappingURL=simulate_order.js.map

package/dist/tools/technical_indicators.d.ts

@@ -0,0 +1,39 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BudaClient } from "../client.js";
+export declare const toolSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            market_id: {
+                type: string;
+                description: string;
+            };
+            period: {
+                type: string;
+                description: string;
+            };
+            limit: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+type TechnicalIndicatorsArgs = {
+    market_id: string;
+    period: "1h" | "4h" | "1d";
+    limit?: number;
+};
+export declare function handleTechnicalIndicators(args: TechnicalIndicatorsArgs, client: BudaClient): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+export declare function register(server: McpServer, client: BudaClient): void;
+export {};
+//# sourceMappingURL=technical_indicators.d.ts.map

package/dist/tools/technical_indicators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"technical_indicators.d.ts","sourceRoot":"","sources":["../../src/tools/technical_indicators.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAgB,MAAM,cAAc,CAAC;AAKxD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;CA6BtB,CAAC;AAsGF,KAAK,uBAAuB,GAAG;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,MAAM,EAAE,IAAI,GAAG,IAAI,GAAG,IAAI,CAAC;IAC3B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,CAAC;AAEF,wBAAsB,yBAAyB,CAC7C,IAAI,EAAE,uBAAuB,EAC7B,MAAM,EAAE,UAAU,GACjB,OAAO,CAAC;IAAE,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CA2GhF;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAyBpE"}