@guiie/buda-mcp 1.3.0 → 1.4.1

package/CHANGELOG.md

@@ -7,6 +7,47 @@ This project uses [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [1.4.1] – 2026-04-11
+
+### Fixed
+
+- **`simulate_order`**: `taker_fee` returned by Buda API is already expressed as a percentage (`0.8` = 0.8%), not a decimal. Dividing by 100 before use gives correct fee calculations. Previously this caused fee_amount and total_cost to be ~100× too large.
+- Integration test (`test/run-all.ts`): added live checks for all 5 v1.4.0 tools; fixed field name `candles_available` (was `candles_used`).
+- Unit test mocks: updated `taker_fee` mock values from `"0.008"`/`"0.005"` to `"0.8"`/`"0.5"` to match the real Buda API format.
+
+---
+
+## [1.4.0] – 2026-04-11
+
+### Added
+
+- **`simulate_order`** (`src/tools/simulate_order.ts`) — public tool that simulates a buy or sell order using live ticker and market data without placing a real order. Inputs: `market_id`, `side` (`buy`|`sell`), `amount`, optional `price` (omit for market order). Fetches ticker (cached) + market info (cached) in parallel to determine fill price, fee rate, and slippage. Uses the actual `taker_fee` from the market (0.8% crypto / 0.5% stablecoin). All responses include `simulation: true`. Exports `handleSimulateOrder` for unit testing.
+
+- **`calculate_position_size`** (`src/tools/calculate_position_size.ts`) — public tool for Kelly-style position sizing from capital, risk %, entry price, and stop-loss. Fully client-side — no API calls. Infers `side` (`buy`/`sell`) from the stop vs entry relationship. Validates that stop ≠ entry. Returns `units`, `capital_at_risk`, `position_value`, `fee_impact` (0.8% conservative taker), and a plain-text `risk_reward_note`. Exports `handleCalculatePositionSize` for unit testing.
+
+- **`get_market_sentiment`** (`src/tools/market_sentiment.ts`) — public tool computing a composite sentiment score (−100 to +100) from three weighted components: price variation 24h (40%), volume vs 7-day daily average (35%), bid/ask spread vs market-type baseline (25%). Spread baseline: 1.0% for crypto pairs, 0.3% for stablecoin pairs (USDT/USDC/DAI/TUSD). Returns `score`, `label` (`bearish`/`neutral`/`bullish`), `component_breakdown`, `data_timestamp`, and a `disclaimer`. Exports `handleMarketSentiment` for unit testing.
+
+- **`get_technical_indicators`** (`src/tools/technical_indicators.ts`) — public tool computing RSI (14), MACD (12/26/9), Bollinger Bands (20, 2σ), SMA 20, and SMA 50 from Buda trade history. No external math libraries — all algorithms implemented inline. Uses at least 500 trades (minimum enforced). Returns signal interpretations: RSI overbought/oversold/neutral, MACD bullish/bearish crossover/neutral, BB above/below/within bands. Returns a structured `{ indicators: null, warning: "insufficient_data" }` object when fewer than 50 candles are available. Includes `disclaimer` field. Exports `handleTechnicalIndicators` for unit testing.
+
+- **`schedule_cancel_all` + `renew_cancel_timer` + `disarm_cancel_timer`** (`src/tools/dead_mans_switch.ts`) — three auth-gated tools implementing an in-memory dead man's switch. `schedule_cancel_all` requires `confirmation_token="CONFIRM"`, `ttl_seconds` (10–300), and a `market_id`; arms a `setTimeout` that fetches all pending orders and cancels each one if not renewed. `renew_cancel_timer` resets the countdown for a market (no confirmation). `disarm_cancel_timer` clears the timer without cancelling orders (no confirmation). **WARNING: timer state is lost on server restart — not suitable for hosted deployments (e.g. Railway). Use only on locally-run instances.** Timer state is module-level and persists across HTTP requests within a process. Exports `handleScheduleCancelAll`, `handleRenewCancelTimer`, `handleDisarmCancelTimer` for unit testing.
+
+- **`src/utils.ts` — `aggregateTradesToCandles(entries, period)`** — shared utility extracted from `get_price_history` logic. Takes raw Buda trade entries and a period string (`1h`/`4h`/`1d`), returns sorted `OhlcvCandle[]`. Used by both `get_price_history` and `get_technical_indicators`.
+
+- **`src/types.ts` — `OhlcvCandle` interface** — exported for use across tools.
+
+- **Unit tests (24 new, 59 total)** in `test/unit.ts`:
+  - **i. `simulate_order`** (5 tests): market buy fills at min_ask; market sell fills at max_bid; limit order_type_assumed; stablecoin 0.5% fee; invalid market_id.
+  - **j. `calculate_position_size`** (4 tests): buy scenario; sell scenario; stop == entry error; invalid market_id.
+  - **k. `get_market_sentiment`** (5 tests): disclaimer present; neutral label; bullish on strong positive variation; bearish on strong negative variation; invalid market_id.
+  - **l. `get_technical_indicators`** (4 tests): `aggregateTradesToCandles` OHLCV correctness; insufficient candles warning; sufficient candles with correct RSI signal; invalid market_id.
+  - **m. `schedule_cancel_all`** (6 tests): CONFIRM guard; invalid market_id; CONFIRM activates + expires_at; renew with no timer; disarm with no timer (no-op); disarm after arm clears timer.
+
+### Changed
+
+- **`src/tools/price_history.ts`** — refactored to use the new shared `aggregateTradesToCandles()` from `utils.ts`. Behaviour is identical.
+
+---
+
 ## [1.3.0] – 2026-04-11
 
 ### Added

package/PUBLISH_CHECKLIST.md

@@ -1,6 +1,8 @@
-# Publish Checklist — buda-mcp v1.3.0
+# Publish Checklist — buda-mcp v1.4.0
 
-Steps to publish `v1.3.0` to npm, the MCP registry, and notify community directories.
+Steps to publish `v1.4.0` to npm, the MCP registry, and notify community directories.
+
+> **Important for v1.4.0:** The new `schedule_cancel_all` tool uses in-memory timer state that is lost on server restart. This is prominently documented in the tool description, README auth section, and CHANGELOG. Do NOT encourage users to rely on this tool in hosted/Railway deployments.
 
 ---
 
@@ -8,7 +10,7 @@ Steps to publish `v1.3.0` to npm, the MCP registry, and notify community directo
 
 ```bash
 # Confirm version
-node -e "console.log(require('./package.json').version)"  # should print 1.3.0
+node -e "console.log(require('./package.json').version)"  # should print 1.4.0
 
 # Build and test
 npm run build
@@ -39,56 +41,51 @@ Verify: https://www.npmjs.com/package/@guiie/buda-mcp
 
 ```bash
 git add -A
-git commit -m "chore: release v1.3.0
-
-- Flatten all response schemas: all monetary amounts now floats with _currency fields
-- get_arbitrage_opportunities: cross-country price discrepancy detection (USDC-normalized)
-- get_market_summary: one-call market overview with liquidity_rating
-- buda://summary/{market} MCP Resource
-- Rewritten tool descriptions with concrete examples and units
-- 35 unit tests (12 new: flattenAmount, arbitrage discrepancy, liquidity_rating thresholds)
-- src/utils.ts: shared flattenAmount() and getLiquidityRating() helpers"
-
-git tag v1.3.0
+git commit -m "chore: release v1.4.0
+
+- simulate_order: live order cost simulation (no order placed, simulation: true)
+- calculate_position_size: Kelly-style sizing from capital/risk/entry/stop (client-side)
+- get_market_sentiment: composite score -100..+100 from price/volume/spread
+- get_technical_indicators: RSI/MACD/BB/SMA20/SMA50 from trade history (no libs)
+- schedule_cancel_all + renew_cancel_timer + disarm_cancel_timer: in-memory dead man's switch (auth-gated)
+- aggregateTradesToCandles() extracted to utils.ts (shared by price_history + technical_indicators)
+- OhlcvCandle interface moved to types.ts
+- 59 unit tests (24 new)"
+
+git tag v1.4.0
 git push origin main --tags
 ```
 
-Then create a GitHub Release from the tag with the following release notes:
+Then create a GitHub Release from the tag:
 
 ---
 
 **Release notes template (GitHub):**
 
 ```
-## buda-mcp v1.3.0 — Output Quality
+## buda-mcp v1.4.0 — Trading Tools
 
-### What's new
+### 5 new tools
 
-**Flat, typed response schemas (breaking change for field consumers)**
-All tools now return floats instead of `["amount", "currency"]` arrays.
-Every monetary Amount is split into a `value` (float) and `_currency` (string) field.
-For example, `last_price: ["65000000", "CLP"]` → `last_price: 65000000, last_price_currency: "CLP"`.
-Affected tools: get_ticker, get_market_volume, get_orderbook, get_trades, get_spread,
-compare_markets, get_price_history, get_balances, get_orders.
+**`simulate_order`** (public)
+Simulates a buy or sell order using live ticker data — no order placed. Returns estimated fill price, fee (actual taker rate from market data: 0.8% crypto / 0.5% stablecoin), total cost, and slippage vs mid. All outputs include simulation: true.
 
-**New tool: `get_market_summary`**
-One-call summary: last price, bid/ask, spread %, 24h volume, price change 24h/7d, and
-`liquidity_rating` ("high" < 0.3%, "medium" 0.3–1%, "low" > 1%). Best first tool to call.
+**`calculate_position_size`** (public)
+Kelly-style position sizing from capital, risk %, entry, and stop-loss. Fully client-side. Returns units, capital_at_risk, position_value, fee_impact, and a plain-text risk note.
 
-**New tool: `get_arbitrage_opportunities`**
-Detects cross-country price discrepancies for an asset across CLP/COP/PEN markets,
-normalized to USDC. Includes pairwise discrepancy %, sorted by size.
-Fees note: 0.8% taker fee per leg (~1.6% round-trip) included in every response.
+**`get_market_sentiment`** (public)
+Composite sentiment score (−100 to +100) from price variation 24h (40%), volume vs 7d average (35%), and spread vs market-type baseline (25%). Returns score, label, component breakdown, and disclaimer.
 
-**New MCP Resource: `buda://summary/{market}`**
-Same data as get_market_summary, served as an MCP Resource in both stdio and HTTP transports.
+**`get_technical_indicators`** (public)
+RSI (14), MACD (12/26/9), Bollinger Bands (20, 2σ), SMA 20, SMA 50 — computed server-side from Buda trade history with no external libraries. Returns signal interpretations and structured warning if insufficient candles.
 
-**Improved tool descriptions**
-All 12 tool descriptions rewritten: specific return types, units, and concrete example questions.
+**`schedule_cancel_all` + `renew_cancel_timer` + `disarm_cancel_timer`** (auth-gated)
+In-memory dead man's switch: arms a timer that cancels all open orders if not renewed. WARNING: timer state is lost on server restart. Use only on locally-run instances.
 
-**Test suite: 35 unit tests (was 23)**
-New sections: flattenAmount type correctness, arbitrage discrepancy calculation with mock data,
-liquidity_rating boundary tests.
+### Infrastructure
+- `aggregateTradesToCandles()` extracted to `utils.ts` — shared by `get_price_history` and `get_technical_indicators`
+- `OhlcvCandle` interface exported from `types.ts`
+- 59 unit tests (was 35)
 
 ```bash
 npx @guiie/buda-mcp
@@ -103,12 +100,6 @@ The GitHub Actions workflow (`.github/workflows/publish.yml`) runs automatically
 
 https://registry.modelcontextprotocol.io/servers/io.github.gtorreal/buda-mcp
 
-If the workflow doesn't trigger, run manually:
-
-```bash
-MCP_REGISTRY_TOKEN=<token> ./mcp-publisher publish
-```
-
 ---
 
 ## 5. Smithery
@@ -124,19 +115,19 @@ Verify: https://smithery.ai/server/@guiie/buda-mcp
 **Email/message template:**
 
 ```
-Subject: [Update] buda-mcp v1.3.0 — flat schemas, arbitrage tool, market summary tool
+Subject: [Update] buda-mcp v1.4.0 — simulate_order, technical indicators, sentiment, position sizing, dead man's switch
 
 Hi mcp.so team,
 
-I've released v1.3.0 of buda-mcp (@guiie/buda-mcp on npm).
+I've released v1.4.0 of buda-mcp (@guiie/buda-mcp on npm).
 
-Key changes:
-- All tools now return flat typed objects: floats + _currency fields instead of [amount, currency] arrays
-- New tool: get_market_summary — one-call overview with liquidity_rating (high/medium/low)
-- New tool: get_arbitrage_opportunities — cross-country BTC/ETH/etc price discrepancy detection (USDC-normalized)
-- New MCP Resource: buda://summary/{market}
-- All tool descriptions rewritten with concrete example questions and units
-- 35 unit tests (12 new)
+Key changes (5 new tools + 3 sub-tools):
+- simulate_order: live order cost simulation with actual fee rates (no order placed)
+- calculate_position_size: Kelly-style position sizing (fully client-side)
+- get_market_sentiment: composite score -100..+100 from price/volume/spread microstructure
+- get_technical_indicators: RSI/MACD/Bollinger Bands/SMA (no external libs, from trade history)
+- schedule_cancel_all / renew_cancel_timer / disarm_cancel_timer: in-memory dead man's switch (auth-gated)
+- 59 unit tests (was 35)
 
 Links:
 - npm: https://www.npmjs.com/package/@guiie/buda-mcp
@@ -155,23 +146,23 @@ Thank you!
 **Message template:**
 
 ```
-Subject: [Update] buda-mcp v1.3.0
+Subject: [Update] buda-mcp v1.4.0
 
 Hi Glama team,
 
-buda-mcp has been updated to v1.3.0.
+buda-mcp has been updated to v1.4.0.
 
 Package: @guiie/buda-mcp (npm)
 Registry: io.github.gtorreal/buda-mcp (MCP Registry)
-Version: 1.3.0
+Version: 1.4.0
 
-Changes:
-- Flat response schemas: all monetary amounts now floats with _currency fields (LLM-friendly)
-- New tool: get_market_summary (one-call overview, liquidity_rating)
-- New tool: get_arbitrage_opportunities (cross-country USDC-normalized price discrepancy)
-- New MCP Resource: buda://summary/{market}
-- Rewritten descriptions with examples and units for all 12 tools
-- 35 unit tests
+Changes (5 new tools + 3 sub-tools):
+- simulate_order: order simulation with live data, simulation: true always set
+- calculate_position_size: client-side position sizing
+- get_market_sentiment: composite sentiment score with disclaimers
+- get_technical_indicators: RSI/MACD/BB/SMA from trade history
+- schedule_cancel_all + renew/disarm: in-memory dead man's switch (auth-gated, local use only)
+- 59 unit tests
 
 Quick start:
   npx @guiie/buda-mcp
@@ -186,13 +177,21 @@ Thank you!
 
 ## 8. Post-publish verification
 
-- [ ] `npx @guiie/buda-mcp@1.3.0` starts successfully
-- [ ] `npm info @guiie/buda-mcp version` returns `1.3.0`
-- [ ] GitHub release tag `v1.3.0` is visible
-- [ ] MCP Registry entry reflects v1.3.0
-- [ ] Smithery server card lists 10 public tools (including get_market_summary, get_arbitrage_opportunities)
-- [ ] `GET /health` returns `"version":"1.3.0"` on Railway deployment
-- [ ] `GET /.well-known/mcp/server-card.json` returns 3 resources (including buda://summary/{market})
-- [ ] get_ticker response has `last_price: <number>` not `last_price: ["...", "CLP"]`
+- [ ] `npx @guiie/buda-mcp@1.4.0` starts successfully
+- [ ] `npm info @guiie/buda-mcp version` returns `1.4.0`
+- [ ] GitHub release tag `v1.4.0` is visible
+- [ ] MCP Registry entry reflects v1.4.0
+- [ ] Smithery server card lists 14 public tools (including 4 new: simulate_order, calculate_position_size, get_market_sentiment, get_technical_indicators)
+- [ ] Smithery server card lists 7 auth tools (including schedule_cancel_all, renew_cancel_timer, disarm_cancel_timer)
+- [ ] `GET /health` returns `"version":"1.4.0"` on Railway deployment
+- [ ] simulate_order response includes `simulation: true`
+- [ ] get_technical_indicators returns `warning: "insufficient_data"` for markets with few trades
+- [ ] schedule_cancel_all requires `confirmation_token="CONFIRM"` (test with wrong token)
 - [ ] mcp.so listing updated
 - [ ] Glama.ai listing updated
+
+---
+
+## ARCHIVED: v1.3.0 checklist
+
+See git tag `v1.3.0` for the v1.3.0 release notes and verification steps.

package/README.md

@@ -285,11 +285,11 @@ Authentication uses HMAC-SHA384 signing per the [Buda API docs](https://api.buda
 
 | Quote | Country | Sample pairs |
 |-------|---------|-------------|
-| CLP | Chile | BTC-CLP, ETH-CLP, XRP-CLP |
-| COP | Colombia | BTC-COP, ETH-COP, XRP-COP |
+| CLP | Chile | BTC-CLP, ETH-CLP, SOL-CLP |
+| COP | Colombia | BTC-COP, ETH-COP, SOL-COP |
 | PEN | Peru | BTC-PEN, ETH-PEN |
-| USDC | USD-pegged | BTC-USDC, ETH-USDC |
-| BTC | Cross | ETH-BTC, XRP-BTC, BCH-BTC |
+| USDC | USD-pegged | BTC-USDC, USDT-USDC |
+| BTC | Cross | ETH-BTC, LTC-BTC, BCH-BTC |
 
 ---
 

package/dist/http.js

@@ -18,6 +18,11 @@ import * as balances from "./tools/balances.js";
 import * as orders from "./tools/orders.js";
 import * as placeOrder from "./tools/place_order.js";
 import * as cancelOrder from "./tools/cancel_order.js";
+import * as simulateOrder from "./tools/simulate_order.js";
+import * as positionSize from "./tools/calculate_position_size.js";
+import * as marketSentiment from "./tools/market_sentiment.js";
+import * as technicalIndicators from "./tools/technical_indicators.js";
+import * as deadMansSwitch from "./tools/dead_mans_switch.js";
 import { handleMarketSummary } from "./tools/market_summary.js";
 const PORT = parseInt(process.env.PORT ?? "3000", 10);
 const client = new BudaClient(undefined, process.env.BUDA_API_KEY, process.env.BUDA_API_SECRET);
@@ -35,12 +40,19 @@ const PUBLIC_TOOL_SCHEMAS = [
     priceHistory.toolSchema,
     arbitrage.toolSchema,
     marketSummary.toolSchema,
+    simulateOrder.toolSchema,
+    positionSize.toolSchema,
+    marketSentiment.toolSchema,
+    technicalIndicators.toolSchema,
 ];
 const AUTH_TOOL_SCHEMAS = [
     balances.toolSchema,
     orders.toolSchema,
     placeOrder.toolSchema,
     cancelOrder.toolSchema,
+    deadMansSwitch.toolSchema,
+    deadMansSwitch.renewToolSchema,
+    deadMansSwitch.disarmToolSchema,
 ];
 function createServer() {
     const server = new McpServer({ name: "buda-mcp", version: VERSION });
@@ -56,11 +68,16 @@ function createServer() {
     priceHistory.register(server, client, reqCache);
     arbitrage.register(server, client, reqCache);
     marketSummary.register(server, client, reqCache);
+    simulateOrder.register(server, client, reqCache);
+    positionSize.register(server);
+    marketSentiment.register(server, client, reqCache);
+    technicalIndicators.register(server, client);
     if (authEnabled) {
         balances.register(server, client);
         orders.register(server, client);
         placeOrder.register(server, client);
         cancelOrder.register(server, client);
+        deadMansSwitch.register(server, client);
     }
     // MCP Resources
     server.resource("buda-markets", "buda://markets", async (uri) => {

package/dist/index.js

@@ -19,6 +19,11 @@ import * as balances from "./tools/balances.js";
 import * as orders from "./tools/orders.js";
 import * as placeOrder from "./tools/place_order.js";
 import * as cancelOrder from "./tools/cancel_order.js";
+import * as simulateOrder from "./tools/simulate_order.js";
+import * as positionSize from "./tools/calculate_position_size.js";
+import * as marketSentiment from "./tools/market_sentiment.js";
+import * as technicalIndicators from "./tools/technical_indicators.js";
+import * as deadMansSwitch from "./tools/dead_mans_switch.js";
 import { handleMarketSummary } from "./tools/market_summary.js";
 const client = new BudaClient(undefined, process.env.BUDA_API_KEY, process.env.BUDA_API_SECRET);
 const server = new McpServer({
@@ -36,12 +41,17 @@ compareMarkets.register(server, client, cache);
 priceHistory.register(server, client, cache);
 arbitrage.register(server, client, cache);
 marketSummary.register(server, client, cache);
+simulateOrder.register(server, client, cache);
+positionSize.register(server);
+marketSentiment.register(server, client, cache);
+technicalIndicators.register(server, client);
 // Auth-gated tools — only registered when API credentials are present
 if (client.hasAuth()) {
     balances.register(server, client);
     orders.register(server, client);
     placeOrder.register(server, client);
     cancelOrder.register(server, client);
+    deadMansSwitch.register(server, client);
 }
 // MCP Resources
 server.resource("buda-markets", "buda://markets", async (uri) => {

package/dist/tools/calculate_position_size.d.ts

@@ -0,0 +1,48 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare const toolSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            market_id: {
+                type: string;
+                description: string;
+            };
+            capital: {
+                type: string;
+                description: string;
+            };
+            risk_pct: {
+                type: string;
+                description: string;
+            };
+            entry_price: {
+                type: string;
+                description: string;
+            };
+            stop_loss_price: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+type CalculatePositionSizeArgs = {
+    market_id: string;
+    capital: number;
+    risk_pct: number;
+    entry_price: number;
+    stop_loss_price: number;
+};
+export declare function handleCalculatePositionSize(args: CalculatePositionSizeArgs): {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+};
+export declare function register(server: McpServer): void;
+export {};
+//# sourceMappingURL=calculate_position_size.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"calculate_position_size.d.ts","sourceRoot":"","sources":["../../src/tools/calculate_position_size.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAIpE,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAkCtB,CAAC;AAEF,KAAK,yBAAyB,GAAG;IAC/B,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;IACjB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;CACzB,CAAC;AAEF,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,yBAAyB,GAC9B;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,CA0DvE;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,GAAG,IAAI,CA8BhD"}

package/dist/tools/calculate_position_size.js

@@ -0,0 +1,111 @@
+import { z } from "zod";
+import { validateMarketId } from "../validation.js";
+export const toolSchema = {
+    name: "calculate_position_size",
+    description: "Calculates position size based on your capital, risk tolerance, entry price, and stop-loss. " +
+        "Determines how many units to buy or sell so that a stop-loss hit costs exactly risk_pct% of capital. " +
+        "Fully client-side — no API call is made. " +
+        "Example: 'How many BTC can I buy on BTC-CLP if I have 1,000,000 CLP, risk 2%, entry 80,000,000 CLP, stop at 78,000,000 CLP?'",
+    inputSchema: {
+        type: "object",
+        properties: {
+            market_id: {
+                type: "string",
+                description: "Market ID (e.g. 'BTC-CLP', 'ETH-COP'). Used to derive the quote currency.",
+            },
+            capital: {
+                type: "number",
+                description: "Total available capital in the quote currency (e.g. CLP for BTC-CLP).",
+            },
+            risk_pct: {
+                type: "number",
+                description: "Percentage of capital to risk on this trade (0.1–10, e.g. 2 = 2%).",
+            },
+            entry_price: {
+                type: "number",
+                description: "Planned entry price in quote currency.",
+            },
+            stop_loss_price: {
+                type: "number",
+                description: "Stop-loss price in quote currency. Must be below entry for buys, above entry for sells.",
+            },
+        },
+        required: ["market_id", "capital", "risk_pct", "entry_price", "stop_loss_price"],
+    },
+};
+export function handleCalculatePositionSize(args) {
+    const { market_id, capital, risk_pct, entry_price, stop_loss_price } = args;
+    const validationError = validateMarketId(market_id);
+    if (validationError) {
+        return {
+            content: [{ type: "text", text: JSON.stringify({ error: validationError, code: "INVALID_MARKET_ID" }) }],
+            isError: true,
+        };
+    }
+    if (stop_loss_price === entry_price) {
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        error: "stop_loss_price must differ from entry_price.",
+                        code: "INVALID_STOP_LOSS",
+                    }),
+                },
+            ],
+            isError: true,
+        };
+    }
+    const quoteCurrency = market_id.split("-")[1].toUpperCase();
+    const baseCurrency = market_id.split("-")[0].toUpperCase();
+    const side = stop_loss_price < entry_price ? "buy" : "sell";
+    const capitalAtRisk = capital * (risk_pct / 100);
+    const riskPerUnit = Math.abs(entry_price - stop_loss_price);
+    const units = capitalAtRisk / riskPerUnit;
+    const positionValue = units * entry_price;
+    const feeImpact = parseFloat((positionValue * 0.008).toFixed(8));
+    const riskRewardNote = `${side === "buy" ? "Buy" : "Sell"} ${units.toFixed(8)} ${baseCurrency} at ${entry_price} ${quoteCurrency} ` +
+        `with stop at ${stop_loss_price} ${quoteCurrency}. ` +
+        `Risking ${risk_pct}% of capital (${capitalAtRisk.toFixed(2)} ${quoteCurrency}) ` +
+        `on a ${riskPerUnit.toFixed(2)} ${quoteCurrency}/unit move. ` +
+        `Estimated entry fee: ${feeImpact.toFixed(2)} ${quoteCurrency} (0.8% taker, conservative estimate).`;
+    const result = {
+        market_id: market_id.toUpperCase(),
+        side,
+        units: parseFloat(units.toFixed(8)),
+        base_currency: baseCurrency,
+        capital_at_risk: parseFloat(capitalAtRisk.toFixed(2)),
+        position_value: parseFloat(positionValue.toFixed(2)),
+        fee_impact: feeImpact,
+        fee_currency: quoteCurrency,
+        risk_reward_note: riskRewardNote,
+    };
+    return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+    };
+}
+export function register(server) {
+    server.tool(toolSchema.name, toolSchema.description, {
+        market_id: z
+            .string()
+            .describe("Market ID (e.g. 'BTC-CLP', 'ETH-COP'). Used to derive the quote currency."),
+        capital: z
+            .number()
+            .positive()
+            .describe("Total available capital in the quote currency (e.g. CLP for BTC-CLP)."),
+        risk_pct: z
+            .number()
+            .min(0.1)
+            .max(10)
+            .describe("Percentage of capital to risk on this trade (0.1–10, e.g. 2 = 2%)."),
+        entry_price: z
+            .number()
+            .positive()
+            .describe("Planned entry price in quote currency."),
+        stop_loss_price: z
+            .number()
+            .positive()
+            .describe("Stop-loss price in quote currency. Must be below entry for buys, above entry for sells."),
+    }, (args) => handleCalculatePositionSize(args));
+}
+//# sourceMappingURL=calculate_position_size.js.map

package/dist/tools/dead_mans_switch.d.ts

@@ -0,0 +1,84 @@
+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;
+            };
+            ttl_seconds: {
+                type: string;
+                description: string;
+            };
+            confirmation_token: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const renewToolSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            market_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const disarmToolSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            market_id: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+type ScheduleArgs = {
+    market_id: string;
+    ttl_seconds: number;
+    confirmation_token: string;
+};
+export declare function handleScheduleCancelAll(args: ScheduleArgs, client: BudaClient): Promise<{
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+}>;
+type MarketOnlyArgs = {
+    market_id: string;
+};
+export declare function handleRenewCancelTimer({ market_id }: MarketOnlyArgs, client: BudaClient): {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+};
+export declare function handleDisarmCancelTimer({ market_id }: MarketOnlyArgs): {
+    content: Array<{
+        type: "text";
+        text: string;
+    }>;
+    isError?: boolean;
+};
+export declare function register(server: McpServer, client: BudaClient): void;
+export {};
+//# sourceMappingURL=dead_mans_switch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dead_mans_switch.d.ts","sourceRoot":"","sources":["../../src/tools/dead_mans_switch.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAgB,MAAM,cAAc,CAAC;AAiDxD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;CA2BtB,CAAC;AAEF,eAAO,MAAM,eAAe;;;;;;;;;;;;;CAgB3B,CAAC;AAEF,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;CAgB5B,CAAC;AAIF,KAAK,YAAY,GAAG;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;IACpB,kBAAkB,EAAE,MAAM,CAAC;CAC5B,CAAC;AAEF,wBAAsB,uBAAuB,CAC3C,IAAI,EAAE,YAAY,EAClB,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,CA+ChF;AAED,KAAK,cAAc,GAAG;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5C,wBAAgB,sBAAsB,CACpC,EAAE,SAAS,EAAE,EAAE,cAAc,EAC7B,MAAM,EAAE,UAAU,GACjB;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,CA0CvE;AAED,wBAAgB,uBAAuB,CACrC,EAAE,SAAS,EAAE,EAAE,cAAc,GAC5B;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,CAwCvE;AAID,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CA0CpE"}