@guiie/buda-mcp 1.2.2 → 1.3.0

package/src/http.ts

@@ -13,10 +13,13 @@ 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 { handleMarketSummary } from "./tools/market_summary.js";
 
 const PORT = parseInt(process.env.PORT ?? "3000", 10);
 
@@ -39,6 +42,8 @@ const PUBLIC_TOOL_SCHEMAS = [
   spread.toolSchema,
   compareMarkets.toolSchema,
   priceHistory.toolSchema,
+  arbitrage.toolSchema,
+  marketSummary.toolSchema,
 ];
 
 const AUTH_TOOL_SCHEMAS = [
@@ -62,6 +67,8 @@ function createServer(): McpServer {
   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);
 
   if (authEnabled) {
     balances.register(server, client);
@@ -114,6 +121,25 @@ function createServer(): McpServer {
     },
   );
 
+  server.resource(
+    "buda-summary",
+    new ResourceTemplate("buda://summary/{market}", { list: undefined }),
+    async (uri, params) => {
+      const marketId = (params.market as string).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;
 }
 
@@ -140,6 +166,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/src/index.ts

@@ -14,10 +14,13 @@ 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 { handleMarketSummary } from "./tools/market_summary.js";
 
 const client = new BudaClient(
   undefined,
@@ -39,6 +42,8 @@ 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);
 
 // Auth-gated tools — only registered when API credentials are present
 if (client.hasAuth()) {
@@ -92,5 +97,24 @@ server.resource(
   },
 );
 
+server.resource(
+  "buda-summary",
+  new ResourceTemplate("buda://summary/{market}", { list: undefined }),
+  async (uri, params) => {
+    const marketId = (params.market as string).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);

package/src/tools/arbitrage.ts

@@ -0,0 +1,202 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { BudaClient, BudaApiError } from "../client.js";
+import { MemoryCache, CACHE_TTL } from "../cache.js";
+import type { AllTickersResponse, Ticker } from "../types.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" as const,
+    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"],
+  },
+};
+
+interface ArbitrageOpportunity {
+  market_a: string;
+  market_b: string;
+  price_a_usdc: number;
+  price_b_usdc: number;
+  discrepancy_pct: number;
+  higher_market: string;
+  lower_market: string;
+}
+
+interface ArbitrageInput {
+  base_currency: string;
+  threshold_pct?: number;
+}
+
+export async function handleArbitrageOpportunities(
+  { base_currency, threshold_pct = 0.5 }: ArbitrageInput,
+  client: BudaClient,
+  cache: MemoryCache,
+): Promise<{ content: Array<{ type: "text"; text: string }>; isError?: boolean }> {
+  try {
+    const base = base_currency.toUpperCase();
+    const data = await cache.getOrFetch<AllTickersResponse>(
+      "tickers:all",
+      CACHE_TTL.TICKER,
+      () => client.get<AllTickersResponse>("/tickers"),
+    );
+
+    const tickerMap = new Map<string, Ticker>();
+    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");
+
+    // Build list of markets for the requested base currency with USDC-normalized prices
+    interface MarketPrice {
+      market_id: string;
+      local_price: number;
+      usdc_rate: number;
+      price_usdc: number;
+    }
+
+    const marketPrices: MarketPrice[] = [];
+
+    const candidates: Array<{ suffix: string; usdcTicker: Ticker | undefined }> = [
+      { 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: ArbitrageOpportunity[] = [];
+
+    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: McpServer, client: BudaClient, cache: MemoryCache): void {
+  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),
+  );
+}

package/src/tools/balances.ts

@@ -1,13 +1,16 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { BudaClient, BudaApiError } from "../client.js";
+import { flattenAmount } from "../utils.js";
 import type { BalancesResponse } from "../types.js";
 
 export const toolSchema = {
   name: "get_balances",
   description:
-    "Get all currency balances for the authenticated Buda.com account. " +
-    "Returns total, available, frozen, and pending withdrawal amounts per currency. " +
-    "Requires BUDA_API_KEY and BUDA_API_SECRET environment variables.",
+    "Returns all currency balances for the authenticated Buda.com account as flat typed objects. " +
+    "Each currency entry includes total amount, available amount (not frozen), frozen amount, and " +
+    "pending withdrawal amount — all as floats with separate _currency fields. " +
+    "Requires BUDA_API_KEY and BUDA_API_SECRET. " +
+    "Example: 'How much BTC do I have available to trade right now?'",
   inputSchema: {
     type: "object" as const,
     properties: {},
@@ -22,8 +25,28 @@ export function register(server: McpServer, client: BudaClient): void {
     async () => {
       try {
         const data = await client.get<BalancesResponse>("/balances");
+
+        const result = data.balances.map((b) => {
+          const amount = flattenAmount(b.amount);
+          const available = flattenAmount(b.available_amount);
+          const frozen = flattenAmount(b.frozen_amount);
+          const pending = flattenAmount(b.pending_withdraw_amount);
+
+          return {
+            id: b.id,
+            amount: amount.value,
+            amount_currency: amount.currency,
+            available_amount: available.value,
+            available_amount_currency: available.currency,
+            frozen_amount: frozen.value,
+            frozen_amount_currency: frozen.currency,
+            pending_withdraw_amount: pending.value,
+            pending_withdraw_amount_currency: pending.currency,
+          };
+        });
+
         return {
-          content: [{ type: "text", text: JSON.stringify(data.balances, null, 2) }],
+          content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
         };
       } catch (err) {
         const msg =

package/src/tools/compare_markets.ts

@@ -7,9 +7,10 @@ import type { AllTickersResponse } from "../types.js";
 export const toolSchema = {
   name: "compare_markets",
   description:
-    "Compare ticker data for all trading pairs of a given base currency across Buda.com's " +
-    "supported quote currencies (CLP, COP, PEN, BTC, USDC, ETH). " +
-    "For example, passing 'BTC' returns side-by-side data for BTC-CLP, BTC-COP, BTC-PEN, etc.",
+    "Returns side-by-side ticker data for all trading pairs of a given base currency across Buda.com's " +
+    "supported quote currencies (CLP, COP, PEN, BTC, USDC, ETH). All prices are floats; " +
+    "price_change_24h and price_change_7d are floats in percent (e.g. 1.23 means +1.23%). " +
+    "Example: 'In which country is Bitcoin currently most expensive on Buda?'",
   inputSchema: {
     type: "object" as const,
     properties: {
@@ -67,16 +68,16 @@ export function register(server: McpServer, client: BudaClient, cache: MemoryCac
           base_currency: base,
           markets: matching.map((t) => ({
             market_id: t.market_id,
-            last_price: t.last_price[0],
-            currency: t.last_price[1],
-            best_bid: t.max_bid ? t.max_bid[0] : null,
-            best_ask: t.min_ask ? t.min_ask[0] : null,
-            volume_24h: t.volume ? t.volume[0] : null,
+            last_price: parseFloat(t.last_price[0]),
+            last_price_currency: t.last_price[1],
+            best_bid: t.max_bid ? parseFloat(t.max_bid[0]) : null,
+            best_ask: t.min_ask ? parseFloat(t.min_ask[0]) : null,
+            volume_24h: t.volume ? parseFloat(t.volume[0]) : null,
             price_change_24h: t.price_variation_24h
-              ? (parseFloat(t.price_variation_24h) * 100).toFixed(2) + "%"
+              ? parseFloat((parseFloat(t.price_variation_24h) * 100).toFixed(4))
               : null,
             price_change_7d: t.price_variation_7d
-              ? (parseFloat(t.price_variation_7d) * 100).toFixed(2) + "%"
+              ? parseFloat((parseFloat(t.price_variation_7d) * 100).toFixed(4))
               : null,
           })),
         };

package/src/tools/market_summary.ts

@@ -0,0 +1,124 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { BudaClient, BudaApiError } from "../client.js";
+import { MemoryCache, CACHE_TTL } from "../cache.js";
+import { validateMarketId } from "../validation.js";
+import { flattenAmount, getLiquidityRating } from "../utils.js";
+import type { TickerResponse, VolumeResponse } from "../types.js";
+
+export const toolSchema = {
+  name: "get_market_summary",
+  description:
+    "One-call summary of everything relevant about a market: last price, best bid/ask, spread %, " +
+    "24h volume, 24h and 7d price change, and a liquidity_rating ('high' / 'medium' / 'low' based on " +
+    "spread thresholds: < 0.3% = high, 0.3–1% = medium, > 1% = low). All prices and volumes are floats. " +
+    "Best first tool to call when a user asks about any specific market. " +
+    "Example: 'Give me a complete overview of the BTC-CLP market right now.'",
+  inputSchema: {
+    type: "object" as const,
+    properties: {
+      market_id: {
+        type: "string",
+        description: "Market ID (e.g. 'BTC-CLP', 'ETH-COP', 'BTC-PEN').",
+      },
+    },
+    required: ["market_id"],
+  },
+};
+
+export interface MarketSummaryResult {
+  market_id: string;
+  last_price: number;
+  last_price_currency: string;
+  bid: number;
+  ask: number;
+  spread_pct: number;
+  volume_24h: number;
+  volume_24h_currency: string;
+  price_change_24h: number;
+  price_change_7d: number;
+  liquidity_rating: "high" | "medium" | "low";
+}
+
+interface MarketSummaryInput {
+  market_id: string;
+}
+
+export async function handleMarketSummary(
+  { market_id }: MarketSummaryInput,
+  client: BudaClient,
+  cache: MemoryCache,
+): Promise<{ content: Array<{ type: "text"; text: string }>; isError?: boolean }> {
+  try {
+    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();
+
+    // Fetch ticker and volume in parallel
+    const [tickerData, volumeData] = await Promise.all([
+      cache.getOrFetch<TickerResponse>(
+        `ticker:${id}`,
+        CACHE_TTL.TICKER,
+        () => client.get<TickerResponse>(`/markets/${id}/ticker`),
+      ),
+      client.get<VolumeResponse>(`/markets/${id}/volume`),
+    ]);
+
+    const t = tickerData.ticker;
+    const v = volumeData.volume;
+
+    const lastPrice = flattenAmount(t.last_price);
+    const bid = parseFloat(t.max_bid[0]);
+    const ask = parseFloat(t.min_ask[0]);
+    const volume24h = flattenAmount(v.ask_volume_24h);
+
+    const spreadAbs = ask - bid;
+    const spreadPct = ask > 0 ? parseFloat(((spreadAbs / ask) * 100).toFixed(4)) : 0;
+
+    const result: MarketSummaryResult = {
+      market_id: t.market_id,
+      last_price: lastPrice.value,
+      last_price_currency: lastPrice.currency,
+      bid,
+      ask,
+      spread_pct: spreadPct,
+      volume_24h: volume24h.value,
+      volume_24h_currency: volume24h.currency,
+      price_change_24h: parseFloat((parseFloat(t.price_variation_24h) * 100).toFixed(4)),
+      price_change_7d: parseFloat((parseFloat(t.price_variation_7d) * 100).toFixed(4)),
+      liquidity_rating: getLiquidityRating(spreadPct),
+    };
+
+    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: McpServer, client: BudaClient, cache: MemoryCache): void {
+  server.tool(
+    toolSchema.name,
+    toolSchema.description,
+    {
+      market_id: z
+        .string()
+        .describe("Market ID (e.g. 'BTC-CLP', 'ETH-COP', 'BTC-PEN')."),
+    },
+    (args) => handleMarketSummary(args, client, cache),
+  );
+}

package/src/tools/markets.ts

@@ -8,8 +8,10 @@ import type { MarketsResponse, MarketResponse } from "../types.js";
 export const toolSchema = {
   name: "get_markets",
   description:
-    "List all available trading pairs on Buda.com, or get details for a specific market. " +
-    "Returns base/quote currencies, fees, and minimum order sizes.",
+    "Lists all available trading pairs on Buda.com, or returns details for a specific market " +
+    "(base/quote currencies, taker/maker fees as decimals, minimum order size in base currency, " +
+    "and fee discount tiers). Omit market_id to get all ~26 markets at once. " +
+    "Example: 'What is the taker fee and minimum order size for BTC-CLP?'",
   inputSchema: {
     type: "object" as const,
     properties: {

package/src/tools/orderbook.ts

@@ -8,8 +8,10 @@ import type { OrderBookResponse } from "../types.js";
 export const toolSchema = {
   name: "get_orderbook",
   description:
-    "Get the current order book (bids and asks) for a Buda.com market. Returns sorted arrays of " +
-    "bids (buy orders) and asks (sell orders), each as [price, amount] pairs.",
+    "Returns the current order book for a Buda.com market as typed objects with float price and amount fields. " +
+    "Bids are sorted highest-price first; asks lowest-price first. " +
+    "Prices are in the quote currency; amounts are in the base currency. " +
+    "Example: 'What are the top 5 buy and sell orders for BTC-CLP right now?'",
   inputSchema: {
     type: "object" as const,
     properties: {
@@ -59,9 +61,18 @@ export function register(server: McpServer, client: BudaClient, cache: MemoryCac
         );
 
         const book = data.order_book;
+        const bids = limit ? book.bids.slice(0, limit) : book.bids;
+        const asks = limit ? book.asks.slice(0, limit) : book.asks;
+
         const result = {
-          bids: limit ? book.bids.slice(0, limit) : book.bids,
-          asks: limit ? book.asks.slice(0, limit) : book.asks,
+          bids: bids.map(([price, amount]) => ({
+            price: parseFloat(price),
+            amount: parseFloat(amount),
+          })),
+          asks: asks.map(([price, amount]) => ({
+            price: parseFloat(price),
+            amount: parseFloat(amount),
+          })),
           bid_count: book.bids.length,
           ask_count: book.asks.length,
         };

package/src/tools/orders.ts

@@ -2,13 +2,17 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { z } from "zod";
 import { BudaClient, BudaApiError } from "../client.js";
 import { validateMarketId } from "../validation.js";
-import type { OrdersResponse } from "../types.js";
+import { flattenAmount } from "../utils.js";
+import type { OrdersResponse, Amount } from "../types.js";
 
 export const toolSchema = {
   name: "get_orders",
   description:
-    "Get orders for a given Buda.com market. Filter by state (pending, active, traded, canceled). " +
-    "Requires BUDA_API_KEY and BUDA_API_SECRET environment variables.",
+    "Returns orders for a given Buda.com market as flat typed objects. All monetary amounts are floats " +
+    "with separate _currency fields (e.g. amount + amount_currency). Filterable by state: pending, " +
+    "active, traded, canceled. Supports pagination via per and page. " +
+    "Requires BUDA_API_KEY and BUDA_API_SECRET. " +
+    "Example: 'Show my open limit orders on BTC-CLP.'",
   inputSchema: {
     type: "object" as const,
     properties: {
@@ -34,6 +38,10 @@ export const toolSchema = {
   },
 };
 
+function flattenAmountField(amount: Amount): { value: number; currency: string } {
+  return flattenAmount(amount);
+}
+
 export function register(server: McpServer, client: BudaClient): void {
   server.tool(
     toolSchema.name,
@@ -83,11 +91,44 @@ export function register(server: McpServer, client: BudaClient): void {
           Object.keys(params).length > 0 ? params : undefined,
         );
 
+        const orders = data.orders.map((o) => {
+          const amount = flattenAmountField(o.amount);
+          const originalAmount = flattenAmountField(o.original_amount);
+          const tradedAmount = flattenAmountField(o.traded_amount);
+          const totalExchanged = flattenAmountField(o.total_exchanged);
+          const paidFee = flattenAmountField(o.paid_fee);
+          const limitPrice = o.limit ? flattenAmountField(o.limit) : null;
+
+          return {
+            id: o.id,
+            type: o.type,
+            state: o.state,
+            created_at: o.created_at,
+            market_id: o.market_id,
+            fee_currency: o.fee_currency,
+            price_type: o.price_type,
+            order_type: o.order_type,
+            client_id: o.client_id,
+            limit_price: limitPrice ? limitPrice.value : null,
+            limit_price_currency: limitPrice ? limitPrice.currency : null,
+            amount: amount.value,
+            amount_currency: amount.currency,
+            original_amount: originalAmount.value,
+            original_amount_currency: originalAmount.currency,
+            traded_amount: tradedAmount.value,
+            traded_amount_currency: tradedAmount.currency,
+            total_exchanged: totalExchanged.value,
+            total_exchanged_currency: totalExchanged.currency,
+            paid_fee: paidFee.value,
+            paid_fee_currency: paidFee.currency,
+          };
+        });
+
         return {
           content: [
             {
               type: "text",
-              text: JSON.stringify({ orders: data.orders, meta: data.meta }, null, 2),
+              text: JSON.stringify({ orders, meta: data.meta }, null, 2),
             },
           ],
         };