@guiie/buda-mcp 1.0.0

package/.github/workflows/publish.yml

@@ -0,0 +1,58 @@
+name: Publish
+
+on:
+  release:
+    types: [published]
+
+jobs:
+  # ── 1. Build & test ──────────────────────────────────────────────
+  test:
+    name: Build & test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+      - run: npm ci
+      - run: npm run build
+      - run: npm test
+
+  # ── 2. Publish to npm ────────────────────────────────────────────
+  npm:
+    name: Publish to npm
+    needs: test
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          registry-url: "https://registry.npmjs.org"
+          cache: "npm"
+      - run: npm ci
+      - run: npm run build
+      - run: npm publish --access public --provenance
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+  # ── 3. Publish to MCP Registry ───────────────────────────────────
+  mcp-registry:
+    name: Publish to MCP Registry
+    needs: npm
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install mcp-publisher
+        run: |
+          curl -L "https://github.com/modelcontextprotocol/registry/releases/latest/download/mcp-publisher_linux_amd64.tar.gz" \
+            | tar xz mcp-publisher
+          sudo mv mcp-publisher /usr/local/bin/
+      - name: Publish to MCP Registry
+        run: mcp-publisher publish
+        env:
+          MCP_REGISTRY_TOKEN: ${{ secrets.MCP_REGISTRY_TOKEN }}

package/PUBLISH.md

@@ -0,0 +1,206 @@
+# Publishing checklist
+
+Everything that could be automated is already done.
+This file contains only what requires your manual action, in order.
+
+---
+
+## What's already done
+
+- [x] GitHub repo created and pushed → https://github.com/gtorreal/buda-mcp
+- [x] `package.json` updated with `mcpName`, `repository`, `bin`, `keywords`
+- [x] `server.json` generated for the official MCP registry
+- [x] `marketplace/` assets generated for Cursor, Claude, ChatGPT, Gemini
+- [x] GitHub Actions workflow created (`.github/workflows/publish.yml`)
+  - Triggers automatically on every GitHub Release you create
+  - Runs: build → test → npm publish → MCP registry publish
+- [x] `mcp-publisher` CLI installed on your machine
+- [x] `NPM_TOKEN` and `MCP_REGISTRY_TOKEN` secret slots created on GitHub
+  - They contain placeholder values — you'll fill them in steps 1 and 3 below
+
+---
+
+## Step 1 — npm (one-time setup, ~5 min)
+
+### 1a. Create an npm account if you don't have one
+https://www.npmjs.com/signup
+
+### 1b. Log in and publish
+
+```bash
+npm login
+# Opens browser → log in → authorize
+
+cd ~/Projects/buda-mcp
+npm run build
+npm publish --access public
+```
+
+### 1c. Put your npm token into GitHub Actions
+1. Go to https://www.npmjs.com/settings/gtorreal/tokens
+2. Create a new **Automation** token (type: "Granular Access Token" → select `@guiie/buda-mcp`)
+3. Run:
+```bash
+gh secret set NPM_TOKEN --repo gtorreal/buda-mcp
+# Paste the token when prompted
+```
+
+After this, every GitHub Release you create will auto-publish to npm.
+
+---
+
+## Step 2 — Official MCP Registry (~3 min)
+
+`mcp-publisher` is already installed. Just run:
+
+```bash
+cd ~/Projects/buda-mcp
+
+# Authenticate with GitHub (opens browser, one-time)
+mcp-publisher login github
+
+# Publish (uses the server.json already in the repo)
+mcp-publisher publish
+```
+
+You'll see: `✓ Successfully published — io.github.gtorreal/buda-mcp version 1.0.0`
+
+### 2b. Put your MCP Registry token into GitHub Actions (for auto-publish on release)
+
+After `mcp-publisher login github`, your token is stored locally at `~/.config/mcp-publisher/`.
+
+```bash
+cat ~/.config/mcp-publisher/credentials.json
+# Copy the token value, then:
+gh secret set MCP_REGISTRY_TOKEN --repo gtorreal/buda-mcp
+# Paste the token when prompted
+```
+
+---
+
+## Step 3 — Community directories (web forms, ~10 min total)
+
+These all auto-populate from the official MCP Registry within a week, but submitting
+directly gets you listed faster.
+
+### PulseMCP
+URL: https://www.pulsemcp.com/submit
+Fill in:
+- Name: `buda-mcp`
+- GitHub: `https://github.com/gtorreal/buda-mcp`
+- npm: `@guiie/buda-mcp`
+- Description: copy from `marketplace/claude-listing.md`
+
+### Glama.ai
+URL: https://glama.ai/mcp/servers → "Add Server" button
+- GitHub URL: `https://github.com/gtorreal/buda-mcp`
+- Glama scans it automatically
+
+### mcp.so
+URL: https://mcp.so — look for "Submit" or open a GitHub issue at their repo
+- GitHub URL: `https://github.com/gtorreal/buda-mcp`
+
+### mcpcentral.io
+URL: https://mcpcentral.io/submit-server
+- Fill in repo URL and npm package name
+
+### awesome-mcp-servers (GitHub PR)
+1. Fork https://github.com/punkpeye/awesome-mcp-servers
+2. Add this line under the **Finance / Crypto** section:
+   ```
+   - [buda-mcp](https://github.com/gtorreal/buda-mcp) — Real-time market data from Buda.com (Chile/Colombia/Peru): prices, order books, trades, volume. No auth required.
+   ```
+3. Open a PR
+
+---
+
+## Step 4 — Smithery (~30 min, requires deployment)
+
+Smithery requires an HTTP endpoint, not stdio. Steps:
+
+### 4a. Create a Railway account
+https://railway.app → sign in with GitHub
+
+### 4b. Deploy
+```bash
+npm install -g @railway/cli
+cd ~/Projects/buda-mcp
+railway login
+railway init   # select "Empty project"
+railway up
+```
+
+You'll get a URL like `https://buda-mcp-production.up.railway.app`.
+
+### 4c. Add HTTP transport to the server
+
+You'll need to add a Streamable HTTP transport alongside the existing stdio one.
+This requires a small code change — let me know and I'll implement it.
+
+### 4d. Submit to Smithery
+URL: https://smithery.ai/new
+- Paste your Railway URL
+- Smithery auto-scans and extracts the 5 tools
+
+---
+
+## Step 5 — ChatGPT GPT Action (~15 min, requires deployment from Step 4)
+
+Once you have the Railway URL from Step 4:
+
+1. Open `marketplace/openapi.yaml`
+2. Replace `https://YOUR_DEPLOYED_DOMAIN` with your Railway URL
+3. Go to https://chatgpt.com → Explore GPTs → Create → Configure → Add Action
+4. Paste the contents of `marketplace/openapi.yaml`
+5. Set Authentication to **None**
+6. Save and publish the GPT
+
+---
+
+## Step 6 — Gemini / Google AI Studio
+
+The `marketplace/gemini-tools.json` function declarations are ready to use now — no
+deployment needed. To share them publicly:
+
+1. In Google AI Studio (https://aistudio.google.com), create a new prompt
+2. Click "Tools" → "Add function" → paste each declaration from `gemini-tools.json`
+3. Save as a shared prompt and publish the link
+
+For the Gemini Extensions marketplace (currently invite-only):
+- Apply at https://ai.google.dev/gemini-api/docs/extensions
+- Use `marketplace/gemini-tools.json` as your tool schema
+
+---
+
+## Step 7 — Create a GitHub Release (triggers auto-publish)
+
+Once npm token and MCP registry token are set in GitHub Actions secrets (Steps 1c and 2b):
+
+```bash
+gh release create v1.0.0 \
+  --title "v1.0.0 — Initial release" \
+  --notes "5 public market data tools for Buda.com: get_markets, get_ticker, get_orderbook, get_trades, get_market_volume." \
+  --latest
+```
+
+This triggers the Actions workflow: build → test → npm publish → MCP registry publish.
+All future releases will auto-publish the same way.
+
+---
+
+## Summary
+
+| Marketplace | Status | Time needed from you |
+|---|---|---|
+| GitHub | ✅ Done | — |
+| npm | Needs your login | ~5 min |
+| Official MCP Registry | Needs OAuth | ~3 min |
+| PulseMCP | Web form | ~2 min |
+| Glama.ai | Web form | ~1 min |
+| mcp.so | Web form | ~2 min |
+| mcpcentral.io | Web form | ~2 min |
+| awesome-mcp-servers | GitHub PR | ~3 min |
+| Smithery | Needs deployment | ~30 min |
+| ChatGPT GPT Action | Needs deployment | ~15 min (after Smithery) |
+| Gemini | Ready now | ~5 min |
+| **GitHub Actions auto-publish** | Needs token secrets | ~5 min |

package/README.md

@@ -0,0 +1,122 @@
+# buda-mcp
+
+A production-ready [MCP](https://modelcontextprotocol.io/) server for the [Buda.com](https://www.buda.com/) cryptocurrency exchange public API. Exposes real-time market data tools to any MCP-compatible AI client (Claude Code, Cursor, ChatGPT, etc.).
+
+## Tools
+
+| Tool | Description |
+|---|---|
+| `get_markets` | List all trading pairs, or get details for one market |
+| `get_ticker` | Current price, bid/ask, volume, and price change for a market |
+| `get_orderbook` | Full order book (bids + asks) for a market |
+| `get_trades` | Recent trade history for a market |
+| `get_market_volume` | 24h and 7-day transacted volume for a market |
+
+All tools use Buda.com's **public** endpoints — no API key required.
+
+## Requirements
+
+- Node.js 18+
+- npm 8+
+
+## Installation
+
+```bash
+git clone https://github.com/gtorreal/buda-mcp.git
+cd buda-mcp
+npm install
+npm run build
+```
+
+## Running the test suite
+
+Calls each tool against the live Buda API and prints the results:
+
+```bash
+npm test
+```
+
+## Usage
+
+### Claude Code
+
+Add the server with the `claude` CLI:
+
+```bash
+claude mcp add buda-mcp -- node /absolute/path/to/buda-mcp/dist/index.js
+```
+
+Then ask Claude things like:
+
+> What is the current BTC-CLP price?
+> Show me the order book for ETH-CLP.
+> How much Bitcoin was traded in the last 7 days on BTC-CLP?
+
+### Cursor
+
+Add to `.cursor/mcp.json` in your project (or `~/.cursor/mcp.json` globally):
+
+```json
+{
+  "mcpServers": {
+    "buda-mcp": {
+      "command": "node",
+      "args": ["/absolute/path/to/buda-mcp/dist/index.js"]
+    }
+  }
+}
+```
+
+Restart Cursor and the tools will be available to the AI agent in chat.
+
+### ChatGPT (Actions / Custom GPT)
+
+ChatGPT does not natively support the stdio MCP transport. To use this server with ChatGPT you need an HTTP bridge. The simplest option is [mcp-server-proxy](https://github.com/sparfenyuk/mcp-proxy):
+
+```bash
+pip install mcp-proxy
+mcp-proxy --port 8000 -- node /absolute/path/to/buda-mcp/dist/index.js
+```
+
+Then register `http://localhost:8000` (or your deployed URL) as a GPT Action endpoint. Use the auto-generated OpenAPI schema that `mcp-proxy` exposes at `/openapi.json`.
+
+## Project structure
+
+```
+src/
+  index.ts          — MCP server entry point
+  client.ts         — BudaClient HTTP wrapper (extend here for auth)
+  types.ts          — TypeScript types for all API responses
+  tools/
+    markets.ts      — get_markets
+    ticker.ts       — get_ticker
+    orderbook.ts    — get_orderbook
+    trades.ts       — get_trades
+    volume.ts       — get_market_volume
+test/
+  run-all.ts        — integration test script
+```
+
+## Adding private endpoints
+
+`BudaClient` in `src/client.ts` is structured for easy extension. To add authenticated endpoints (balances, orders, withdrawals):
+
+1. Add `apiKey` and `apiSecret` constructor parameters.
+2. Implement HMAC-SHA2 signing in a `signedGet` / `signedPost` method (see [Buda auth docs](https://api.buda.com/en/#rest-api-private-endpoints-authentication)).
+3. Drop new tool files under `src/tools/` and call `register(server, client)` in `src/index.ts`.
+
+## Markets available
+
+Buda.com operates in Chile, Colombia, and Peru:
+
+| Quote currency | Country |
+|---|---|
+| CLP | Chile |
+| COP | Colombia |
+| PEN | Peru |
+
+Common markets: `BTC-CLP`, `ETH-CLP`, `BTC-COP`, `ETH-COP`, `BTC-PEN`, `ETH-PEN`, `ETH-BTC`, `XRP-BTC`, etc.
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,18 @@
+export declare class BudaApiError extends Error {
+    readonly status: number;
+    readonly path: string;
+    constructor(status: number, path: string, message: string);
+}
+export declare class BudaClient {
+    private readonly baseUrl;
+    constructor(baseUrl?: string);
+    /**
+     * Perform an authenticated GET request.
+     *
+     * Private endpoints (balances, orders, etc.) require HMAC-SHA2 signing.
+     * To add auth later, extend this method with the `apiKey` + `apiSecret`
+     * constructor params and sign the nonce/path headers here before fetching.
+     */
+    get<T>(path: string, params?: Record<string, string | number>): Promise<T>;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAEA,qBAAa,YAAa,SAAQ,KAAK;aAEnB,MAAM,EAAE,MAAM;aACd,IAAI,EAAE,MAAM;gBADZ,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,MAAM,EAC5B,OAAO,EAAE,MAAM;CAKlB;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,OAAO,GAAE,MAAiB;IAItC;;;;;;OAMG;IACG,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC;CA6BjF"}

package/dist/client.js

@@ -0,0 +1,52 @@
+const BASE_URL = "https://www.buda.com/api/v2";
+export class BudaApiError extends Error {
+    status;
+    path;
+    constructor(status, path, message) {
+        super(message);
+        this.status = status;
+        this.path = path;
+        this.name = "BudaApiError";
+    }
+}
+export class BudaClient {
+    baseUrl;
+    constructor(baseUrl = BASE_URL) {
+        this.baseUrl = baseUrl;
+    }
+    /**
+     * Perform an authenticated GET request.
+     *
+     * Private endpoints (balances, orders, etc.) require HMAC-SHA2 signing.
+     * To add auth later, extend this method with the `apiKey` + `apiSecret`
+     * constructor params and sign the nonce/path headers here before fetching.
+     */
+    async get(path, params) {
+        const url = new URL(`${this.baseUrl}${path}.json`);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                url.searchParams.set(key, String(value));
+            }
+        }
+        const response = await fetch(url.toString(), {
+            headers: {
+                Accept: "application/json",
+                "User-Agent": "buda-mcp/1.0.0",
+            },
+        });
+        if (!response.ok) {
+            let detail = response.statusText;
+            try {
+                const body = (await response.json());
+                if (body.message)
+                    detail = body.message;
+            }
+            catch {
+                // ignore parse error, use statusText
+            }
+            throw new BudaApiError(response.status, path, `Buda API ${response.status}: ${detail}`);
+        }
+        return response.json();
+    }
+}
+//# sourceMappingURL=client.js.map

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,23 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { BudaClient } from "./client.js";
+import * as markets from "./tools/markets.js";
+import * as ticker from "./tools/ticker.js";
+import * as orderbook from "./tools/orderbook.js";
+import * as trades from "./tools/trades.js";
+import * as volume from "./tools/volume.js";
+const server = new McpServer({
+    name: "buda-mcp",
+    version: "1.0.0",
+});
+const client = new BudaClient();
+// Register all public-endpoint tools
+markets.register(server, client);
+ticker.register(server, client);
+orderbook.register(server, client);
+trades.register(server, client);
+volume.register(server, client);
+// Start the server over stdio (standard MCP transport)
+const transport = new StdioServerTransport();
+await server.connect(transport);
+//# sourceMappingURL=index.js.map

package/dist/tools/markets.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BudaClient } from "../client.js";
+export declare function register(server: McpServer, client: BudaClient): void;
+//# sourceMappingURL=markets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"markets.d.ts","sourceRoot":"","sources":["../../src/tools/markets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CA6BpE"}

package/dist/tools/markets.js

@@ -0,0 +1,22 @@
+import { z } from "zod";
+export function register(server, client) {
+    server.tool("get_markets", "List all available trading pairs on Buda.com, or get details for a specific market. " +
+        "Returns base/quote currencies, fees, and minimum order sizes.", {
+        market_id: z
+            .string()
+            .optional()
+            .describe("Optional market ID (e.g. 'BTC-CLP', 'ETH-BTC'). Omit to list all markets."),
+    }, async ({ market_id }) => {
+        if (market_id) {
+            const data = await client.get(`/markets/${market_id.toLowerCase()}`);
+            return {
+                content: [{ type: "text", text: JSON.stringify(data.market, null, 2) }],
+            };
+        }
+        const data = await client.get("/markets");
+        return {
+            content: [{ type: "text", text: JSON.stringify(data.markets, null, 2) }],
+        };
+    });
+}
+//# sourceMappingURL=markets.js.map

package/dist/tools/orderbook.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BudaClient } from "../client.js";
+export declare function register(server: McpServer, client: BudaClient): void;
+//# sourceMappingURL=orderbook.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"orderbook.d.ts","sourceRoot":"","sources":["../../src/tools/orderbook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAkCpE"}

package/dist/tools/orderbook.js

@@ -0,0 +1,28 @@
+import { z } from "zod";
+export function register(server, client) {
+    server.tool("get_orderbook", "Get the current order book for a Buda.com market. Returns sorted arrays of " +
+        "bids (buy orders) and asks (sell orders), each as [price, amount] pairs.", {
+        market_id: z
+            .string()
+            .describe("Market ID (e.g. 'BTC-CLP', 'ETH-BTC')."),
+        limit: z
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe("Maximum number of levels to return per side (default: all)."),
+    }, async ({ market_id, limit }) => {
+        const data = await client.get(`/markets/${market_id.toLowerCase()}/order_book`);
+        const book = data.order_book;
+        const result = {
+            bids: limit ? book.bids.slice(0, limit) : book.bids,
+            asks: limit ? book.asks.slice(0, limit) : book.asks,
+            bid_count: book.bids.length,
+            ask_count: book.asks.length,
+        };
+        return {
+            content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        };
+    });
+}
+//# sourceMappingURL=orderbook.js.map

package/dist/tools/ticker.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BudaClient } from "../client.js";
+export declare function register(server: McpServer, client: BudaClient): void;
+//# sourceMappingURL=ticker.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"ticker.d.ts","sourceRoot":"","sources":["../../src/tools/ticker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAmBpE"}

package/dist/tools/ticker.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export function register(server, client) {
+    server.tool("get_ticker", "Get the current ticker for a Buda.com market: last traded price, best bid/ask, " +
+        "24h volume, and price change over 24h and 7d.", {
+        market_id: z
+            .string()
+            .describe("Market ID (e.g. 'BTC-CLP', 'ETH-BTC', 'BTC-COP')."),
+    }, async ({ market_id }) => {
+        const data = await client.get(`/markets/${market_id.toLowerCase()}/ticker`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data.ticker, null, 2) }],
+        };
+    });
+}
+//# sourceMappingURL=ticker.js.map

package/dist/tools/trades.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BudaClient } from "../client.js";
+export declare function register(server: McpServer, client: BudaClient): void;
+//# sourceMappingURL=trades.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"trades.d.ts","sourceRoot":"","sources":["../../src/tools/trades.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAuCpE"}

package/dist/tools/trades.js

@@ -0,0 +1,32 @@
+import { z } from "zod";
+export function register(server, client) {
+    server.tool("get_trades", "Get recent trade history for a Buda.com market. Each entry contains " +
+        "[timestamp_ms, amount, price, direction]. Direction is 'buy' or 'sell'.", {
+        market_id: z
+            .string()
+            .describe("Market ID (e.g. 'BTC-CLP', 'ETH-BTC')."),
+        limit: z
+            .number()
+            .int()
+            .min(1)
+            .max(100)
+            .optional()
+            .describe("Number of trades to return (default: 50, max: 100)."),
+        timestamp: z
+            .number()
+            .int()
+            .optional()
+            .describe("Unix timestamp (seconds) to paginate from. Returns trades older than this timestamp."),
+    }, async ({ market_id, limit, timestamp }) => {
+        const params = {};
+        if (limit !== undefined)
+            params.limit = limit;
+        if (timestamp !== undefined)
+            params.timestamp = timestamp;
+        const data = await client.get(`/markets/${market_id.toLowerCase()}/trades`, Object.keys(params).length > 0 ? params : undefined);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data.trades, null, 2) }],
+        };
+    });
+}
+//# sourceMappingURL=trades.js.map

package/dist/tools/volume.d.ts

@@ -0,0 +1,4 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { BudaClient } from "../client.js";
+export declare function register(server: McpServer, client: BudaClient): void;
+//# sourceMappingURL=volume.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"volume.d.ts","sourceRoot":"","sources":["../../src/tools/volume.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEpE,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAG1C,wBAAgB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,UAAU,GAAG,IAAI,CAmBpE"}

package/dist/tools/volume.js

@@ -0,0 +1,15 @@
+import { z } from "zod";
+export function register(server, client) {
+    server.tool("get_market_volume", "Get 24h and 7-day transacted volume for a Buda.com market. " +
+        "Returns ask (sell) and bid (buy) volumes in the market's base currency.", {
+        market_id: z
+            .string()
+            .describe("Market ID (e.g. 'BTC-CLP', 'ETH-BTC')."),
+    }, async ({ market_id }) => {
+        const data = await client.get(`/markets/${market_id.toLowerCase()}/volume`);
+        return {
+            content: [{ type: "text", text: JSON.stringify(data.volume, null, 2) }],
+        };
+    });
+}
+//# sourceMappingURL=volume.js.map