@guiie/buda-mcp 1.2.2 → 1.4.0

package/CHANGELOG.md

@@ -7,6 +7,74 @@ This project uses [Semantic Versioning](https://semver.org/).
 
 ---
 
+## [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
+
+- **`src/utils.ts`** — shared `flattenAmount(amount: Amount)` helper (returns `{ value: number, currency: string }`) and `getLiquidityRating(spreadPct: number)` helper (`"high"` / `"medium"` / `"low"`) used across multiple tools and unit-testable in isolation.
+
+- **`get_arbitrage_opportunities`** (`src/tools/arbitrage.ts`) — new public tool that detects cross-country price discrepancies for a given asset across Buda's CLP, COP, and PEN markets, normalised to USDC. Inputs: `base_currency` (e.g. `"BTC"`) and optional `threshold_pct` (default `0.5`). Algorithm: fetches all tickers, converts each local price to USDC via the current USDC-CLP / USDC-COP / USDC-PEN rates, computes all pairwise discrepancy percentages, filters by threshold, and sorts descending. Output includes a `fees_note` reminding callers that Buda's 0.8% taker fee per leg (~1.6% round-trip) must be deducted. Exports `handleArbitrageOpportunities` for unit testing.
+
+- **`get_market_summary`** (`src/tools/market_summary.ts`) — new public tool that returns a single unified object with everything relevant about a market: `last_price`, `last_price_currency`, `bid`, `ask`, `spread_pct`, `volume_24h`, `volume_24h_currency`, `price_change_24h`, `price_change_7d`, and `liquidity_rating` (`"high"` when spread < 0.3%, `"medium"` when 0.3–1%, `"low"` when > 1%). Makes 2 API calls in parallel (ticker + volume); spread is derived from the ticker without a third call. Exports `handleMarketSummary` for unit testing.
+
+- **`buda://summary/{market}`** MCP Resource — registered in both stdio (`src/index.ts`) and HTTP (`src/http.ts`) transports. Returns the same JSON as `get_market_summary`. Added to the server-card `resources` array.
+
+- **Unit tests (12 new, 35 total)** in `test/unit.ts`:
+  - **f. Numeric flattening** (4 tests): `flattenAmount` returns a `number`, not a string; handles decimals and zero correctly; result is not an array.
+  - **g. `get_arbitrage_opportunities`** (3 tests): mocked tickers verify correct USDC-normalised discrepancy calculation (~3.95% for BTC CLP vs PEN at the given rates); threshold 5% correctly excludes the opportunity; returns `isError` when fewer than 2 markets have USDC rates.
+  - **h. `get_market_summary` / `getLiquidityRating`** (5 tests): boundary tests for all three liquidity tiers; end-to-end mock verifies `liquidity_rating: "high"` at 0.2% spread and that `last_price` is a number type.
+
+### Changed
+
+- **Flat response schemas across all tools** — every tool that previously returned Buda `[amount_string, currency_string]` tuples now returns flat, typed fields. All numeric strings are cast to `parseFloat`; the currency is separated into a `_currency`-suffixed sibling field. Specific changes per tool:
+  - **`get_ticker`** — `last_price`, `min_ask`, `max_bid`, `volume` flattened; `price_variation_24h` / `price_variation_7d` cast to float.
+  - **`get_market_volume`** — all four `*_volume_*` Amount fields flattened with `_currency` suffix.
+  - **`get_orderbook`** — bids and asks converted from `[price, amount]` tuples to `{ price: float, amount: float }` objects.
+  - **`get_trades`** — entries converted from `[timestamp_ms, amount, price, direction]` tuples to `{ timestamp_ms: int, amount: float, price: float, direction: string }` objects.
+  - **`get_spread`** — `best_bid`, `best_ask`, `spread_absolute`, `last_price` → floats; `spread_percentage` → float (the "%" suffix is dropped); `currency` renamed to `price_currency`.
+  - **`compare_markets`** — per-market `last_price` + `last_price_currency` (was `last_price` + `currency`); `best_bid`, `best_ask`, `volume_24h` → floats; `price_change_*` → floats in percent (was strings like `"1.23%"`).
+  - **`get_price_history`** — OHLCV candle fields `open`, `high`, `low`, `close`, `volume` → floats (were strings).
+  - **`get_balances`** — all four Amount fields per balance entry (`amount`, `available_amount`, `frozen_amount`, `pending_withdraw_amount`) flattened with `_currency` suffix.
+  - **`get_orders`** — all Amount fields (`limit`, `amount`, `original_amount`, `traded_amount`, `total_exchanged`, `paid_fee`) flattened; `limit` renamed to `limit_price` / `limit_price_currency`.
+
+- **Improved tool descriptions** — all 12 tool descriptions (10 public + 2 auth) rewritten to be specific about return shape, include units, and give a concrete example question an LLM might ask.
+
+- **`package.json`** version bumped to `1.3.0`.
+- **`marketplace/`** and **`PUBLISH_CHECKLIST.md`** updated to reflect v1.3.0 changes.
+
+---
+
 ## [1.2.0] – 2026-04-11
 
 ### Added

package/PUBLISH_CHECKLIST.md

@@ -1,6 +1,8 @@
-# Publish Checklist — buda-mcp v1.2.0
+# Publish Checklist — buda-mcp v1.4.0
 
-Steps to publish `v1.2.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.2.0` to npm, the MCP registry, and notify community directo
 
 ```bash
 # Confirm version
-node -e "console.log(require('./package.json').version)"  # should print 1.2.0
+node -e "console.log(require('./package.json').version)"  # should print 1.4.0
 
 # Build and test
 npm run build
@@ -39,49 +41,51 @@ Verify: https://www.npmjs.com/package/@guiie/buda-mcp
 
 ```bash
 git add -A
-git commit -m "chore: release v1.2.0
-
-- Single version source-of-truth via src/version.ts (no more hardcoded strings)
-- Programmatic server-card in http.ts (toolSchema exported per tool)
-- .env.example with documented BUDA_API_KEY / BUDA_API_SECRET
-- Input sanitization: validateMarketId regex on all market_id inputs
-- 429 retry with Retry-After (seconds, per RFC 7231), default 1s
-- get_price_history: limit raised to 1000, UTC bucketing documented
-- 23 unit tests: HMAC signing, cache dedup, confirmation guard, sanitization, 429 retry
-- Integration tests: graceful skip when Buda API is unreachable"
-
-git tag v1.2.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.2.0
+## buda-mcp v1.4.0 — Trading Tools
+
+### 5 new tools
+
+**`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.
 
-### What's new
+**`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.
 
-**Bug fixes & maintenance**
-- Single version source-of-truth: all version strings now read from `package.json` at startup via `src/version.ts` — no more drift between files
-- `http.ts` server-card assembled programmatically from exported `toolSchema` constants — adding a tool no longer requires touching `http.ts`
+**`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.
 
-**Security / reliability**
-- Input sanitization: all `market_id` inputs validated against `/^[A-Z0-9]{2,10}-[A-Z0-9]{2,10}$/i` before URL interpolation — rejects path traversal and malformed IDs with structured errors
-- 429 retry: `BudaClient` retries once on rate-limit responses, honoring the `Retry-After` header (seconds, per RFC 7231; defaults to 1s if absent). Double-429 throws `BudaApiError` with `retryAfterMs`.
+**`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.
 
-**DX improvements**
-- `.env.example` added for easy credential setup
-- `get_price_history` limit raised from 100 to 1000 trades; UTC bucketing documented prominently
-- `npm run sync-version` syncs `server.json` from `package.json` automatically
+**`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**
-- 23 new unit tests (no live API needed): HMAC signing exactness, cache deduplication, confirmation_token guards, input sanitization, 429 retry behavior
-- Integration tests skip gracefully when Buda API is unreachable (CI-friendly)
-- New scripts: `npm run test:unit`, `npm run test:integration`
+### 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
@@ -96,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
@@ -117,19 +115,19 @@ Verify: https://smithery.ai/server/@guiie/buda-mcp
 **Email/message template:**
 
 ```
-Subject: [Update] buda-mcp v1.2.0 — input sanitization, 429 retry, 23 unit tests
+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.2.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:
-- Input sanitization: all market IDs validated against a strict regex before URL use
-- 429 rate-limit retry: honors Retry-After header (seconds, RFC 7231), defaults to 1s
-- get_price_history: limit raised to 1000 trades for deeper history
-- 23 unit tests added (no live API required): HMAC, cache dedup, confirmation guards, sanitization, retry
-- Single version source-of-truth (package.json → all files via src/version.ts)
-- .env.example added for easy credential setup
+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
@@ -148,22 +146,23 @@ Thank you!
 **Message template:**
 
 ```
-Subject: [Update] buda-mcp v1.2.0
+Subject: [Update] buda-mcp v1.4.0
 
 Hi Glama team,
 
-buda-mcp has been updated to v1.2.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.2.0
+Version: 1.4.0
 
-Changes:
-- Input validation on all market_id inputs (structured isError: true on failure)
-- 429 retry with Retry-After support (RFC 7231 seconds; default 1s)
-- get_price_history limit raised to 1000 trades; UTC bucket timestamps documented
-- 23 unit tests: HMAC signing, cache deduplication, confirmation guards, sanitization, retry
-- Single version source (package.json); .env.example added
+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
@@ -178,12 +177,21 @@ Thank you!
 
 ## 8. Post-publish verification
 
-- [ ] `npx @guiie/buda-mcp@1.2.0` starts successfully
-- [ ] `npm info @guiie/buda-mcp version` returns `1.2.0`
-- [ ] GitHub release tag `v1.2.0` is visible
-- [ ] MCP Registry entry reflects v1.2.0
-- [ ] Smithery server card lists 8 public tools (with updated get_price_history description)
-- [ ] `GET /health` returns `"version":"1.2.0"` on Railway deployment
-- [ ] `GET /.well-known/mcp/server-card.json` returns tools with updated schemas (no hardcoded JSON)
+- [ ] `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

@@ -12,10 +12,18 @@ import * as volume from "./tools/volume.js";
 import * as spread from "./tools/spread.js";
 import * as compareMarkets from "./tools/compare_markets.js";
 import * as priceHistory from "./tools/price_history.js";
+import * as arbitrage from "./tools/arbitrage.js";
+import * as marketSummary from "./tools/market_summary.js";
 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);
 const authEnabled = client.hasAuth();
@@ -30,12 +38,21 @@ const PUBLIC_TOOL_SCHEMAS = [
     spread.toolSchema,
     compareMarkets.toolSchema,
     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 });
@@ -49,11 +66,18 @@ function createServer() {
     spread.register(server, client, reqCache);
     compareMarkets.register(server, client, reqCache);
     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) => {
@@ -81,6 +105,20 @@ function createServer() {
             ],
         };
     });
+    server.resource("buda-summary", new ResourceTemplate("buda://summary/{market}", { list: undefined }), async (uri, params) => {
+        const marketId = params.market.toUpperCase();
+        const result = await handleMarketSummary({ market_id: marketId }, client, reqCache);
+        const text = result.content[0].text;
+        return {
+            contents: [
+                {
+                    uri: uri.href,
+                    mimeType: "application/json",
+                    text,
+                },
+            ],
+        };
+    });
     return server;
 }
 const app = express();
@@ -104,6 +142,7 @@ app.get("/.well-known/mcp/server-card.json", (_req, res) => {
         resources: [
             { uri: "buda://markets", name: "All Buda.com markets", mimeType: "application/json" },
             { uri: "buda://ticker/{market}", name: "Ticker for a specific market", mimeType: "application/json" },
+            { uri: "buda://summary/{market}", name: "Full market summary with liquidity rating", mimeType: "application/json" },
         ],
         prompts: [],
     });

package/dist/index.js

@@ -13,10 +13,18 @@ import * as volume from "./tools/volume.js";
 import * as spread from "./tools/spread.js";
 import * as compareMarkets from "./tools/compare_markets.js";
 import * as priceHistory from "./tools/price_history.js";
+import * as arbitrage from "./tools/arbitrage.js";
+import * as marketSummary from "./tools/market_summary.js";
 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({
     name: "buda-mcp",
@@ -31,12 +39,19 @@ volume.register(server, client, cache);
 spread.register(server, client, cache);
 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) => {
@@ -64,6 +79,20 @@ server.resource("buda-ticker", new ResourceTemplate("buda://ticker/{market}", {
         ],
     };
 });
+server.resource("buda-summary", new ResourceTemplate("buda://summary/{market}", { list: undefined }), async (uri, params) => {
+    const marketId = params.market.toUpperCase();
+    const result = await handleMarketSummary({ market_id: marketId }, client, cache);
+    const text = result.content[0].text;
+    return {
+        contents: [
+            {
+                uri: uri.href,
+                mimeType: "application/json",
+                text,
+            },
+        ],
+    };
+});
 const transport = new StdioServerTransport();
 await server.connect(transport);
 //# sourceMappingURL=index.js.map

package/dist/tools/arbitrage.d.ts

@@ -0,0 +1,35 @@
+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: {
+            base_currency: {
+                type: string;
+                description: string;
+            };
+            threshold_pct: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+interface ArbitrageInput {
+    base_currency: string;
+    threshold_pct?: number;
+}
+export declare function handleArbitrageOpportunities({ base_currency, threshold_pct }: ArbitrageInput, 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=arbitrage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"arbitrage.d.ts","sourceRoot":"","sources":["../../src/tools/arbitrage.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;AAGrD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;CAyBtB,CAAC;AAYF,UAAU,cAAc;IACtB,aAAa,EAAE,MAAM,CAAC;IACtB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,wBAAsB,4BAA4B,CAChD,EAAE,aAAa,EAAE,aAAmB,EAAE,EAAE,cAAc,EACtD,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,CAgIhF;AAED,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,WAAW,GAAG,IAAI,CAmBxF"}

package/dist/tools/arbitrage.js

@@ -0,0 +1,142 @@
+import { z } from "zod";
+import { BudaApiError } from "../client.js";
+import { CACHE_TTL } from "../cache.js";
+export const toolSchema = {
+    name: "get_arbitrage_opportunities",
+    description: "Detects cross-country price discrepancies for a given asset across Buda's CLP, COP, and PEN markets, " +
+        "normalized to USDC. Fetches all relevant tickers, converts each local price to USDC using the " +
+        "current USDC-CLP / USDC-COP / USDC-PEN rates, then computes pairwise discrepancy percentages. " +
+        "Results above threshold_pct are returned sorted by opportunity size. Note: Buda taker fee is 0.8% " +
+        "per leg (~1.6% round-trip) — always deduct fees before acting on any discrepancy. " +
+        "Example: 'Is there an arbitrage opportunity for BTC between Chile and Peru right now?'",
+    inputSchema: {
+        type: "object",
+        properties: {
+            base_currency: {
+                type: "string",
+                description: "Base asset to scan (e.g. 'BTC', 'ETH', 'XRP').",
+            },
+            threshold_pct: {
+                type: "number",
+                description: "Minimum price discrepancy percentage to include in results (default: 0.5). " +
+                    "Buda taker fee is 0.8% per leg, so a round-trip requires > 1.6% to be profitable.",
+            },
+        },
+        required: ["base_currency"],
+    },
+};
+export async function handleArbitrageOpportunities({ base_currency, threshold_pct = 0.5 }, client, cache) {
+    try {
+        const base = base_currency.toUpperCase();
+        const data = await cache.getOrFetch("tickers:all", CACHE_TTL.TICKER, () => client.get("/tickers"));
+        const tickerMap = new Map();
+        for (const t of data.tickers) {
+            tickerMap.set(t.market_id, t);
+        }
+        // Find USDC conversion rates for each fiat currency
+        const usdcClpTicker = tickerMap.get("USDC-CLP");
+        const usdcCopTicker = tickerMap.get("USDC-COP");
+        const usdcPenTicker = tickerMap.get("USDC-PEN");
+        const marketPrices = [];
+        const candidates = [
+            { suffix: "CLP", usdcTicker: usdcClpTicker },
+            { suffix: "COP", usdcTicker: usdcCopTicker },
+            { suffix: "PEN", usdcTicker: usdcPenTicker },
+        ];
+        for (const { suffix, usdcTicker } of candidates) {
+            const marketId = `${base}-${suffix}`;
+            const baseTicker = tickerMap.get(marketId);
+            if (!baseTicker || !usdcTicker)
+                continue;
+            const localPrice = parseFloat(baseTicker.last_price[0]);
+            const usdcRate = parseFloat(usdcTicker.last_price[0]);
+            if (isNaN(localPrice) || isNaN(usdcRate) || usdcRate === 0)
+                continue;
+            marketPrices.push({
+                market_id: marketId,
+                local_price: localPrice,
+                usdc_rate: usdcRate,
+                price_usdc: localPrice / usdcRate,
+            });
+        }
+        if (marketPrices.length < 2) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: JSON.stringify({
+                            error: `Not enough markets found for base currency '${base}' to compute arbitrage. ` +
+                                `Need at least 2 of: ${base}-CLP, ${base}-COP, ${base}-PEN with USDC rates available.`,
+                            code: "INSUFFICIENT_MARKETS",
+                        }),
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Compute all pairwise discrepancies
+        const opportunities = [];
+        for (let i = 0; i < marketPrices.length; i++) {
+            for (let j = i + 1; j < marketPrices.length; j++) {
+                const a = marketPrices[i];
+                const b = marketPrices[j];
+                const minPrice = Math.min(a.price_usdc, b.price_usdc);
+                const discrepancyPct = (Math.abs(a.price_usdc - b.price_usdc) / minPrice) * 100;
+                if (discrepancyPct < threshold_pct)
+                    continue;
+                const higherMarket = a.price_usdc > b.price_usdc ? a.market_id : b.market_id;
+                const lowerMarket = a.price_usdc < b.price_usdc ? a.market_id : b.market_id;
+                opportunities.push({
+                    market_a: a.market_id,
+                    market_b: b.market_id,
+                    price_a_usdc: parseFloat(a.price_usdc.toFixed(4)),
+                    price_b_usdc: parseFloat(b.price_usdc.toFixed(4)),
+                    discrepancy_pct: parseFloat(discrepancyPct.toFixed(4)),
+                    higher_market: higherMarket,
+                    lower_market: lowerMarket,
+                });
+            }
+        }
+        opportunities.sort((a, b) => b.discrepancy_pct - a.discrepancy_pct);
+        const result = {
+            base_currency: base,
+            threshold_pct,
+            markets_analyzed: marketPrices.map((m) => ({
+                market_id: m.market_id,
+                price_usdc: parseFloat(m.price_usdc.toFixed(4)),
+                local_price: m.local_price,
+                usdc_rate: m.usdc_rate,
+            })),
+            opportunities_found: opportunities.length,
+            opportunities,
+            fees_note: "Buda taker fee is 0.8% per leg. A round-trip arbitrage (buy on one market, sell on another) " +
+                "costs approximately 1.6% in fees. Only discrepancies well above 1.6% are likely profitable.",
+        };
+        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, {
+        base_currency: z
+            .string()
+            .describe("Base asset to scan (e.g. 'BTC', 'ETH', 'XRP')."),
+        threshold_pct: z
+            .number()
+            .min(0)
+            .default(0.5)
+            .describe("Minimum price discrepancy percentage to include in results (default: 0.5). " +
+            "Buda taker fee is 0.8% per leg, so a round-trip requires > 1.6% to be profitable."),
+    }, (args) => handleArbitrageOpportunities(args, client, cache));
+}
+//# sourceMappingURL=arbitrage.js.map

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

@@ -1 +1 @@
-{"version":3,"file":"balances.d.ts","sourceRoot":"","sources":["../../src/tools/balances.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAgB,MAAM,cAAc,CAAC;AAGxD,eAAO,MAAM,UAAU;;;;;;;CAUtB,CAAC;AAEF,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAuBpE"}
+{"version":3,"file":"balances.d.ts","sourceRoot":"","sources":["../../src/tools/balances.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACpE,OAAO,EAAE,UAAU,EAAgB,MAAM,cAAc,CAAC;AAIxD,eAAO,MAAM,UAAU;;;;;;;CAYtB,CAAC;AAEF,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CA2CpE"}