@guiie/buda-mcp 1.4.2 → 1.5.0

package/test/unit.ts

@@ -17,6 +17,24 @@ import { handleCalculatePositionSize } from "../src/tools/calculate_position_siz
 import { handleMarketSentiment } from "../src/tools/market_sentiment.js";
 import { handleTechnicalIndicators } from "../src/tools/technical_indicators.js";
 import { handleScheduleCancelAll, handleRenewCancelTimer, handleDisarmCancelTimer } from "../src/tools/dead_mans_switch.js";
+import { validateCurrency } from "../src/validation.js";
+import { handleGetAccountInfo } from "../src/tools/account.js";
+import { handleGetBalance } from "../src/tools/balance.js";
+import { handleGetOrder, handleGetOrderByClientId } from "../src/tools/order_lookup.js";
+import { handleGetNetworkFees } from "../src/tools/fees.js";
+import { handleGetDepositHistory } from "../src/tools/deposits.js";
+import { handleGetWithdrawalHistory } from "../src/tools/withdrawals.js";
+import { handleListReceiveAddresses, handleGetReceiveAddress, handleCreateReceiveAddress } from "../src/tools/receive_addresses.js";
+import { handleListRemittances, handleGetRemittance, handleQuoteRemittance, handleAcceptRemittanceQuote } from "../src/tools/remittances.js";
+import { handleGetRealQuotation } from "../src/tools/quotation.js";
+import { handleListRemittanceRecipients, handleGetRemittanceRecipient } from "../src/tools/remittance_recipients.js";
+import { handleGetAvailableBanks } from "../src/tools/banks.js";
+import { handleCancelAllOrders } from "../src/tools/cancel_all_orders.js";
+import { handleCancelOrderByClientId } from "../src/tools/cancel_order_by_client_id.js";
+import { handlePlaceBatchOrders } from "../src/tools/batch_orders.js";
+import { handleCreateWithdrawal } from "../src/tools/withdrawals.js";
+import { handleCreateFiatDeposit } from "../src/tools/deposits.js";
+import { handleLightningWithdrawal, handleCreateLightningInvoice } from "../src/tools/lightning.js";
 
 // ----------------------------------------------------------------
 // Minimal test harness
@@ -1159,6 +1177,1893 @@ await test("disarm after arm: timer is cleared", async () => {
   assert(renewResult.isError === true, "should have no timer left after disarm");
 });
 
+// ----------------------------------------------------------------
+// n. validateCurrency
+// ----------------------------------------------------------------
+
+section("n. validateCurrency");
+
+await test("validateCurrency: accepts BTC", () => {
+  assertEqual(validateCurrency("BTC"), null, "BTC should be valid");
+});
+
+await test("validateCurrency: accepts CLP (fiat)", () => {
+  assertEqual(validateCurrency("CLP"), null, "CLP should be valid");
+});
+
+await test("validateCurrency: accepts USDC (multi-char)", () => {
+  assertEqual(validateCurrency("USDC"), null, "USDC should be valid");
+});
+
+await test("validateCurrency: case-insensitive — accepts lowercase btc", () => {
+  assertEqual(validateCurrency("btc"), null, "lowercase btc should be valid");
+});
+
+await test("validateCurrency: rejects empty string", () => {
+  assert(validateCurrency("") !== null, "should reject empty string");
+});
+
+await test("validateCurrency: rejects special characters", () => {
+  assert(validateCurrency("BT$") !== null, "should reject $");
+  assert(validateCurrency("BTC!") !== null, "should reject !");
+});
+
+await test("validateCurrency: rejects string longer than 10 chars", () => {
+  assert(validateCurrency("ABCDEFGHIJK") !== null, "should reject 11-char string");
+});
+
+await test("validateCurrency: rejects single character", () => {
+  assert(validateCurrency("B") !== null, "should reject 1-char string");
+});
+
+// ----------------------------------------------------------------
+// o. P1 auth tools — INVALID_CURRENCY guard
+// ----------------------------------------------------------------
+
+section("o. P1 auth tools — INVALID_CURRENCY guard");
+
+await test("handleGetBalance: invalid currency '!!' returns INVALID_CURRENCY", async () => {
+  const fakeClient = {} as BudaClient;
+  const result = await handleGetBalance({ currency: "!!" }, fakeClient);
+  assert(result.isError === true, "should be error");
+  const parsed = JSON.parse(result.content[0].text) as { code: string };
+  assertEqual(parsed.code, "INVALID_CURRENCY", "code should be INVALID_CURRENCY");
+});
+
+await test("handleGetBalance: invalid currency empty string returns INVALID_CURRENCY", async () => {
+  const fakeClient = {} as BudaClient;
+  const result = await handleGetBalance({ currency: "" }, fakeClient);
+  assert(result.isError === true, "should be error");
+});
+
+await test("handleGetNetworkFees: invalid currency returns INVALID_CURRENCY", async () => {
+  const fakeClient = {} as BudaClient;
+  const result = await handleGetNetworkFees({ currency: "$$", type: "withdrawal" }, fakeClient);
+  assert(result.isError === true, "should be error");
+  const parsed = JSON.parse(result.content[0].text) as { code: string };
+  assertEqual(parsed.code, "INVALID_CURRENCY", "code should be INVALID_CURRENCY");
+});
+
+await test("handleGetDepositHistory: invalid currency returns INVALID_CURRENCY", async () => {
+  const fakeClient = {} as BudaClient;
+  const result = await handleGetDepositHistory({ currency: "BAD!!" }, fakeClient);
+  assert(result.isError === true, "should be error");
+  const parsed = JSON.parse(result.content[0].text) as { code: string };
+  assertEqual(parsed.code, "INVALID_CURRENCY", "code should be INVALID_CURRENCY");
+});
+
+await test("handleGetWithdrawalHistory: invalid currency returns INVALID_CURRENCY", async () => {
+  const fakeClient = {} as BudaClient;
+  const result = await handleGetWithdrawalHistory({ currency: "B" }, fakeClient);
+  assert(result.isError === true, "should be error");
+  const parsed = JSON.parse(result.content[0].text) as { code: string };
+  assertEqual(parsed.code, "INVALID_CURRENCY", "code should be INVALID_CURRENCY");
+});
+
+await test("handleListReceiveAddresses: invalid currency returns INVALID_CURRENCY", async () => {
+  const fakeClient = {} as BudaClient;
+  const result = await handleListReceiveAddresses({ currency: "!!" }, fakeClient);
+  assert(result.isError === true, "should be error");
+  const parsed = JSON.parse(result.content[0].text) as { code: string };
+  assertEqual(parsed.code, "INVALID_CURRENCY", "code should be INVALID_CURRENCY");
+});
+
+await test("handleGetReceiveAddress: invalid currency returns INVALID_CURRENCY", async () => {
+  const fakeClient = {} as BudaClient;
+  const result = await handleGetReceiveAddress({ currency: "!!", id: 1 }, fakeClient);
+  assert(result.isError === true, "should be error");
+  const parsed = JSON.parse(result.content[0].text) as { code: string };
+  assertEqual(parsed.code, "INVALID_CURRENCY", "code should be INVALID_CURRENCY");
+});
+
+await test("handleGetAvailableBanks: invalid currency returns INVALID_CURRENCY", async () => {
+  const fakeClient = {} as BudaClient;
+  const fakeCache = new MemoryCache();
+  const result = await handleGetAvailableBanks({ currency: "!!" }, fakeClient, fakeCache);
+  assert(result.isError === true, "should be error");
+  const parsed = JSON.parse(result.content[0].text) as { code: string };
+  assertEqual(parsed.code, "INVALID_CURRENCY", "code should be INVALID_CURRENCY");
+});
+
+// ----------------------------------------------------------------
+// p. P1 tools — happy path (mocked API)
+// ----------------------------------------------------------------
+
+section("p. P1 tools — happy path (mocked API)");
+
+await test("handleGetAccountInfo: returns flattened profile", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        me: {
+          id: 42,
+          email: "user@example.com",
+          name: "Test User",
+          monthly_transacted: ["5000000", "CLP"],
+          pubsub_key: "pk_test",
+        },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetAccountInfo(client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      id: number;
+      email: string;
+      monthly_transacted: number;
+      monthly_transacted_currency: string;
+    };
+    assertEqual(parsed.id, 42, "id should be 42");
+    assertEqual(parsed.email, "user@example.com", "email should match");
+    assertEqual(parsed.monthly_transacted, 5000000, "monthly_transacted should be a float");
+    assertEqual(parsed.monthly_transacted_currency, "CLP", "currency should be CLP");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetBalance: returns flattened balance", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        balance: {
+          id: "BTC",
+          amount: ["0.5", "BTC"],
+          available_amount: ["0.4", "BTC"],
+          frozen_amount: ["0.1", "BTC"],
+          pending_withdraw_amount: ["0.0", "BTC"],
+        },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetBalance({ currency: "BTC" }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      id: string;
+      amount: number;
+      available_amount: number;
+      frozen_amount: number;
+    };
+    assertEqual(parsed.id, "BTC", "id should be BTC");
+    assertEqual(parsed.amount, 0.5, "amount should be 0.5");
+    assertEqual(parsed.available_amount, 0.4, "available_amount should be 0.4");
+    assertEqual(parsed.frozen_amount, 0.1, "frozen_amount should be 0.1");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetOrder: returns normalized order", async () => {
+  const savedFetch = globalThis.fetch;
+  const mockOrder = {
+    order: {
+      id: 123456,
+      type: "Bid",
+      state: "active",
+      created_at: "2024-01-01T00:00:00Z",
+      market_id: "BTC-CLP",
+      fee_currency: "CLP",
+      price_type: "limit",
+      order_type: "limit_order",
+      client_id: null,
+      limit: ["65000000", "CLP"],
+      amount: ["0.001", "BTC"],
+      original_amount: ["0.001", "BTC"],
+      traded_amount: ["0", "BTC"],
+      total_exchanged: ["0", "CLP"],
+      paid_fee: ["0", "CLP"],
+    },
+  };
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify(mockOrder), { status: 200, headers: { "Content-Type": "application/json" } });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetOrder({ order_id: 123456 }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      id: number;
+      type: string;
+      state: string;
+      limit_price: number;
+      amount: number;
+    };
+    assertEqual(parsed.id, 123456, "id should match");
+    assertEqual(parsed.type, "Bid", "type should be Bid");
+    assertEqual(parsed.state, "active", "state should be active");
+    assertEqual(parsed.limit_price, 65000000, "limit_price should be a float");
+    assertEqual(parsed.amount, 0.001, "amount should be 0.001");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetOrder: 404 returns isError with code 404", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify({ message: "Not found" }), { status: 404 });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetOrder({ order_id: 999999 }, client);
+    assert(result.isError === true, "should be error");
+    const parsed = JSON.parse(result.content[0].text) as { code: number };
+    assertEqual(parsed.code, 404, "code should be 404");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetOrderByClientId: returns normalized order", async () => {
+  const savedFetch = globalThis.fetch;
+  const mockOrder = {
+    order: {
+      id: 77777,
+      type: "Ask",
+      state: "traded",
+      created_at: "2024-06-01T00:00:00Z",
+      market_id: "ETH-BTC",
+      fee_currency: "BTC",
+      price_type: "limit",
+      order_type: "limit_order",
+      client_id: "my-bot-42",
+      limit: ["0.05", "BTC"],
+      amount: ["1", "ETH"],
+      original_amount: ["1", "ETH"],
+      traded_amount: ["1", "ETH"],
+      total_exchanged: ["0.05", "BTC"],
+      paid_fee: ["0.0004", "BTC"],
+    },
+  };
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify(mockOrder), { status: 200, headers: { "Content-Type": "application/json" } });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetOrderByClientId({ client_id: "my-bot-42" }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as { id: number; client_id: string };
+    assertEqual(parsed.id, 77777, "id should match");
+    assertEqual(parsed.client_id, "my-bot-42", "client_id should match");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetDepositHistory: returns flattened deposits with meta", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        deposits: [
+          {
+            id: 1,
+            state: "confirmed",
+            currency: "BTC",
+            amount: ["0.1", "BTC"],
+            fee: ["0.0001", "BTC"],
+            created_at: "2024-01-01T00:00:00Z",
+            updated_at: "2024-01-01T01:00:00Z",
+            transfer_account_id: null,
+            transaction_hash: "abc123",
+          },
+        ],
+        meta: { current_page: 1, total_count: 1, total_pages: 1 },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetDepositHistory({ currency: "BTC" }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      deposits: Array<{ id: number; amount: number; fee: number; state: string }>;
+      meta: { total_count: number };
+    };
+    assertEqual(parsed.deposits.length, 1, "should have 1 deposit");
+    assertEqual(parsed.deposits[0].id, 1, "id should be 1");
+    assertEqual(parsed.deposits[0].amount, 0.1, "amount should be 0.1");
+    assertEqual(parsed.deposits[0].fee, 0.0001, "fee should be a float");
+    assertEqual(parsed.meta.total_count, 1, "total_count should be 1");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetDepositHistory: empty list is not an error", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({ deposits: [], meta: { current_page: 1, total_count: 0, total_pages: 0 } }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetDepositHistory({ currency: "BTC" }, client);
+    assert(!result.isError, "empty list should not be error");
+    const parsed = JSON.parse(result.content[0].text) as { deposits: unknown[] };
+    assertEqual(parsed.deposits.length, 0, "deposits should be empty array");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetWithdrawalHistory: returns flattened withdrawals", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        withdrawals: [
+          {
+            id: 5,
+            state: "confirmed",
+            currency: "CLP",
+            amount: ["100000", "CLP"],
+            fee: ["500", "CLP"],
+            address: null,
+            tx_hash: null,
+            bank_account_id: 99,
+            created_at: "2024-02-01T00:00:00Z",
+            updated_at: "2024-02-01T01:00:00Z",
+          },
+        ],
+        meta: { current_page: 1, total_count: 1, total_pages: 1 },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetWithdrawalHistory({ currency: "CLP" }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      withdrawals: Array<{ id: number; amount: number; bank_account_id: number }>;
+    };
+    assertEqual(parsed.withdrawals[0].id, 5, "id should be 5");
+    assertEqual(parsed.withdrawals[0].amount, 100000, "amount should be 100000");
+    assertEqual(parsed.withdrawals[0].bank_account_id, 99, "bank_account_id should be 99");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleListReceiveAddresses: returns address list", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        receive_addresses: [
+          { id: 10, address: "bc1qtest", currency: "BTC", created_at: "2024-01-01T00:00:00Z", label: null },
+        ],
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleListReceiveAddresses({ currency: "BTC" }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      receive_addresses: Array<{ id: number; address: string }>;
+    };
+    assertEqual(parsed.receive_addresses.length, 1, "should have 1 address");
+    assertEqual(parsed.receive_addresses[0].id, 10, "id should be 10");
+    assertEqual(parsed.receive_addresses[0].address, "bc1qtest", "address should match");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetReceiveAddress: returns single address", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        receive_address: { id: 10, address: "bc1qtest", currency: "BTC", created_at: "2024-01-01T00:00:00Z", label: "cold storage" },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetReceiveAddress({ currency: "BTC", id: 10 }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as { id: number; label: string };
+    assertEqual(parsed.id, 10, "id should be 10");
+    assertEqual(parsed.label, "cold storage", "label should match");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleListRemittances: returns remittance list with flattened amounts", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        remittances: [
+          {
+            id: 77,
+            state: "quoted",
+            currency: "CLP",
+            amount: ["100000", "CLP"],
+            recipient_id: 5,
+            created_at: "2024-03-01T00:00:00Z",
+            expires_at: "2024-03-01T01:00:00Z",
+          },
+        ],
+        meta: { current_page: 1, total_count: 1, total_pages: 1 },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleListRemittances({}, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      remittances: Array<{ id: number; amount: number; recipient_id: number }>;
+    };
+    assertEqual(parsed.remittances[0].id, 77, "id should be 77");
+    assertEqual(parsed.remittances[0].amount, 100000, "amount should be a float");
+    assertEqual(parsed.remittances[0].recipient_id, 5, "recipient_id should be 5");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetRemittance: returns single remittance", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        remittance: {
+          id: 88,
+          state: "confirmed",
+          currency: "COP",
+          amount: ["500000", "COP"],
+          recipient_id: 3,
+          created_at: "2024-04-01T00:00:00Z",
+          expires_at: null,
+        },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetRemittance({ id: 88 }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as { id: number; state: string; expires_at: null };
+    assertEqual(parsed.id, 88, "id should be 88");
+    assertEqual(parsed.state, "confirmed", "state should be confirmed");
+    assertEqual(parsed.expires_at, null, "expires_at should be null");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleListRemittanceRecipients: returns recipient list", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        remittance_recipients: [
+          { id: 1, name: "Alice", bank: "banco_estado", account_number: "123456", currency: "CLP", country: "CL" },
+        ],
+        meta: { current_page: 1, total_count: 1, total_pages: 1 },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleListRemittanceRecipients({}, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      remittance_recipients: Array<{ id: number; name: string; bank: string }>;
+    };
+    assertEqual(parsed.remittance_recipients[0].id, 1, "id should be 1");
+    assertEqual(parsed.remittance_recipients[0].name, "Alice", "name should match");
+    assertEqual(parsed.remittance_recipients[0].bank, "banco_estado", "bank should match");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetRemittanceRecipient: returns single recipient", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        remittance_recipient: {
+          id: 7, name: "Bob", bank: "bancolombia", account_number: "987654", currency: "COP", country: null,
+        },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetRemittanceRecipient({ id: 7 }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as { id: number; country: null };
+    assertEqual(parsed.id, 7, "id should be 7");
+    assertEqual(parsed.country, null, "country should be null");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetAvailableBanks: returns bank list for fiat currency", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        banks: [
+          { id: "banco_estado", name: "Banco Estado", country: "CL" },
+          { id: "bci", name: "BCI", country: "CL" },
+        ],
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleGetAvailableBanks({ currency: "CLP" }, client, cache);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as { currency: string; banks: Array<{ id: string }> };
+    assertEqual(parsed.currency, "CLP", "currency should be CLP");
+    assertEqual(parsed.banks.length, 2, "should have 2 banks");
+    assertEqual(parsed.banks[0].id, "banco_estado", "first bank id should match");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetAvailableBanks: 404 returns empty list (not an error)", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify({ message: "Not found" }), { status: 404 });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleGetAvailableBanks({ currency: "USD" }, client, cache);
+    assert(!result.isError, "404 should NOT be an error — empty list");
+    const parsed = JSON.parse(result.content[0].text) as { banks: unknown[] };
+    assertEqual(parsed.banks.length, 0, "banks should be empty array");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetAvailableBanks: 500 returns isError", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify({ message: "Internal server error" }), { status: 500 });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const cache = new MemoryCache();
+    const result = await handleGetAvailableBanks({ currency: "CLP" }, client, cache);
+    assert(result.isError === true, "500 should be isError");
+    const parsed = JSON.parse(result.content[0].text) as { code: number };
+    assertEqual(parsed.code, 500, "code should be 500");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// Priority 2 — get_real_quotation
+// ----------------------------------------------------------------
+
+section("get_real_quotation");
+
+await test("handleGetRealQuotation: INVALID_MARKET_ID without fetch", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetRealQuotation({ market_id: "INVALID", type: "Bid", amount: 1 }, client);
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "INVALID_MARKET_ID", "code should be INVALID_MARKET_ID");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetRealQuotation: happy path Bid", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        quotation: {
+          id: 42,
+          type: "Bid",
+          market_id: "BTC-CLP",
+          amount: ["0.05", "BTC"],
+          limit: null,
+          base_balance_change: ["-0.05", "BTC"],
+          quote_balance_change: ["4500000", "CLP"],
+          fee_amount: ["22500", "CLP"],
+          order_amount: ["0.05", "BTC"],
+        },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetRealQuotation({ market_id: "BTC-CLP", type: "Bid", amount: 0.05 }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      id: number;
+      type: string;
+      market_id: string;
+      amount: number;
+      amount_currency: string;
+      limit: null;
+      limit_currency: null;
+      fee_amount: number;
+      fee_currency: string;
+    };
+    assertEqual(parsed.id, 42, "id should be 42");
+    assertEqual(parsed.type, "Bid", "type should be Bid");
+    assertEqual(parsed.market_id, "BTC-CLP", "market_id should match");
+    assertEqual(parsed.amount, 0.05, "amount should be 0.05");
+    assertEqual(parsed.amount_currency, "BTC", "amount_currency should be BTC");
+    assertEqual(parsed.limit, null, "limit should be null");
+    assertEqual(parsed.limit_currency, null, "limit_currency should be null");
+    assertEqual(parsed.fee_amount, 22500, "fee_amount should be 22500");
+    assertEqual(parsed.fee_currency, "CLP", "fee_currency should be CLP");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetRealQuotation: happy path Ask with limit", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        quotation: {
+          id: null,
+          type: "Ask",
+          market_id: "ETH-CLP",
+          amount: ["1", "ETH"],
+          limit: ["3000000", "CLP"],
+          base_balance_change: ["1", "ETH"],
+          quote_balance_change: ["-3000000", "CLP"],
+          fee_amount: ["15000", "CLP"],
+          order_amount: ["1", "ETH"],
+        },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetRealQuotation(
+      { market_id: "ETH-CLP", type: "Ask", amount: 1, limit: 3000000 },
+      client,
+    );
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      id: null;
+      limit: number;
+      limit_currency: string;
+    };
+    assertEqual(parsed.id, null, "id should be null");
+    assertEqual(parsed.limit, 3000000, "limit should be 3000000");
+    assertEqual(parsed.limit_currency, "CLP", "limit_currency should be CLP");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleGetRealQuotation: API 422 passthrough", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify({ message: "Unprocessable Entity" }), { status: 422 });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleGetRealQuotation({ market_id: "BTC-CLP", type: "Bid", amount: 0.000001 }, client);
+    assert(result.isError === true, "should be error");
+    const parsed = JSON.parse(result.content[0].text) as { code: number };
+    assertEqual(parsed.code, 422, "code should be 422");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// Priority 2 — create_receive_address
+// ----------------------------------------------------------------
+
+section("create_receive_address");
+
+await test("handleCreateReceiveAddress: INVALID_CURRENCY without fetch", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handleCreateReceiveAddress({ currency: "!!!!" }, client);
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "INVALID_CURRENCY", "code should be INVALID_CURRENCY");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCreateReceiveAddress: happy path", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        receive_address: {
+          id: 99,
+          address: "bc1qnewaddress123",
+          currency: "BTC",
+          created_at: "2024-04-01T00:00:00Z",
+          label: null,
+        },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCreateReceiveAddress({ currency: "BTC" }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      id: number;
+      address: string;
+      currency: string;
+      label: null;
+    };
+    assertEqual(parsed.id, 99, "id should be 99");
+    assertEqual(parsed.address, "bc1qnewaddress123", "address should match");
+    assertEqual(parsed.currency, "BTC", "currency should be BTC");
+    assertEqual(parsed.label, null, "label should be null");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCreateReceiveAddress: fiat currency API error passthrough", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify({ message: "Not found" }), { status: 404 });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCreateReceiveAddress({ currency: "CLP" }, client);
+    assert(result.isError === true, "should be error for fiat");
+    const parsed = JSON.parse(result.content[0].text) as { code: number };
+    assertEqual(parsed.code, 404, "code should be 404");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// Priority 2 — quote_remittance
+// ----------------------------------------------------------------
+
+section("quote_remittance");
+
+await test("handleQuoteRemittance: INVALID_CURRENCY without fetch", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handleQuoteRemittance({ currency: "!!!", amount: 100, recipient_id: 1 }, client);
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "INVALID_CURRENCY", "code should be INVALID_CURRENCY");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleQuoteRemittance: happy path", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        remittance: {
+          id: 55,
+          state: "quoted",
+          currency: "CLP",
+          amount: ["100000", "CLP"],
+          recipient_id: 5,
+          created_at: "2024-04-01T00:00:00Z",
+          expires_at: "2024-04-01T00:30:00Z",
+        },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleQuoteRemittance({ currency: "CLP", amount: 100000, recipient_id: 5 }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      id: number;
+      state: string;
+      expires_at: string;
+    };
+    assertEqual(parsed.id, 55, "id should be 55");
+    assertEqual(parsed.state, "quoted", "state should be quoted");
+    assert(parsed.expires_at !== null, "expires_at should not be null");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleQuoteRemittance: 404 unknown recipient passthrough", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify({ message: "Not found" }), { status: 404 });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleQuoteRemittance({ currency: "CLP", amount: 100000, recipient_id: 9999 }, client);
+    assert(result.isError === true, "should be error");
+    const parsed = JSON.parse(result.content[0].text) as { code: number };
+    assertEqual(parsed.code, 404, "code should be 404");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// Priority 2 — accept_remittance_quote
+// ----------------------------------------------------------------
+
+section("accept_remittance_quote");
+
+await test("handleAcceptRemittanceQuote: missing/wrong token returns CONFIRMATION_REQUIRED without fetch", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handleAcceptRemittanceQuote({ id: 77, confirmation_token: "yes" }, client);
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string; remittance_id: number };
+    assertEqual(parsed.code, "CONFIRMATION_REQUIRED", "code should be CONFIRMATION_REQUIRED");
+    assertEqual(parsed.remittance_id, 77, "remittance_id should be 77");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleAcceptRemittanceQuote: empty string token returns CONFIRMATION_REQUIRED without fetch", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handleAcceptRemittanceQuote({ id: 10, confirmation_token: "" }, client);
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "CONFIRMATION_REQUIRED", "code should be CONFIRMATION_REQUIRED");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleAcceptRemittanceQuote: happy path with CONFIRM token", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        remittance: {
+          id: 77,
+          state: "accepted",
+          currency: "CLP",
+          amount: ["100000", "CLP"],
+          recipient_id: 5,
+          created_at: "2024-04-01T00:00:00Z",
+          expires_at: null,
+        },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleAcceptRemittanceQuote({ id: 77, confirmation_token: "CONFIRM" }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as { id: number; state: string };
+    assertEqual(parsed.id, 77, "id should be 77");
+    assertEqual(parsed.state, "accepted", "state should be accepted");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleAcceptRemittanceQuote: 422 expired quote passthrough", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify({ message: "Unprocessable Entity" }), { status: 422 });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleAcceptRemittanceQuote({ id: 77, confirmation_token: "CONFIRM" }, client);
+    assert(result.isError === true, "should be error");
+    const parsed = JSON.parse(result.content[0].text) as { code: number };
+    assertEqual(parsed.code, 422, "code should be 422");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// Priority 3 — cancel_all_orders
+// ----------------------------------------------------------------
+
+section("cancel_all_orders");
+
+await test("handleCancelAllOrders: missing/wrong token returns CONFIRMATION_REQUIRED without fetch", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handleCancelAllOrders({ market_id: "BTC-CLP", confirmation_token: "NOPE" }, client);
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "CONFIRMATION_REQUIRED", "code should be CONFIRMATION_REQUIRED");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCancelAllOrders: '*' + CONFIRM cancels all markets", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({ canceled_count: 5 }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCancelAllOrders({ market_id: "*", confirmation_token: "CONFIRM" }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as { canceled_count: number; market_id: string };
+    assertEqual(parsed.canceled_count, 5, "canceled_count should be 5");
+    assertEqual(parsed.market_id, "*", "market_id should be *");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCancelAllOrders: specific market + CONFIRM", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({ canceled_count: 2 }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCancelAllOrders({ market_id: "BTC-CLP", confirmation_token: "CONFIRM" }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as { canceled_count: number; market_id: string };
+    assertEqual(parsed.canceled_count, 2, "canceled_count should be 2");
+    assertEqual(parsed.market_id, "BTC-CLP", "market_id should be BTC-CLP");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCancelAllOrders: invalid market format returns INVALID_MARKET_ID even with CONFIRM", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handleCancelAllOrders({ market_id: "INVALID!!!", confirmation_token: "CONFIRM" }, client);
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "INVALID_MARKET_ID", "code should be INVALID_MARKET_ID");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCancelAllOrders: API 404 passthrough", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify({ message: "Not found" }), { status: 404 });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCancelAllOrders({ market_id: "BTC-CLP", confirmation_token: "CONFIRM" }, client);
+    assert(result.isError === true, "should be error");
+    const parsed = JSON.parse(result.content[0].text) as { code: number };
+    assertEqual(parsed.code, 404, "code should be 404");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// Priority 3 — cancel_order_by_client_id
+// ----------------------------------------------------------------
+
+section("cancel_order_by_client_id");
+
+await test("handleCancelOrderByClientId: missing/wrong token returns CONFIRMATION_REQUIRED without fetch", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handleCancelOrderByClientId({ client_id: "my-order-1", confirmation_token: "NOPE" }, client);
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string; client_id: string };
+    assertEqual(parsed.code, "CONFIRMATION_REQUIRED", "code should be CONFIRMATION_REQUIRED");
+    assertEqual(parsed.client_id, "my-order-1", "client_id should be echoed back");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCancelOrderByClientId: happy path returns flat order", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        order: {
+          id: 999,
+          type: "Bid",
+          state: "canceling",
+          created_at: "2024-01-01T00:00:00Z",
+          market_id: "BTC-CLP",
+          fee_currency: "CLP",
+          price_type: "limit",
+          order_type: "limit",
+          client_id: "my-order-1",
+          limit: ["50000000", "CLP"],
+          amount: ["0.001", "BTC"],
+          original_amount: ["0.001", "BTC"],
+          traded_amount: ["0", "BTC"],
+          total_exchanged: ["0", "CLP"],
+          paid_fee: ["0", "CLP"],
+        },
+      }),
+      { status: 200, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCancelOrderByClientId({ client_id: "my-order-1", confirmation_token: "CONFIRM" }, client);
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      id: number;
+      state: string;
+      client_id: string;
+      limit_price: number;
+    };
+    assertEqual(parsed.id, 999, "id should be 999");
+    assertEqual(parsed.state, "canceling", "state should be canceling");
+    assertEqual(parsed.client_id, "my-order-1", "client_id should be my-order-1");
+    assertEqual(parsed.limit_price, 50000000, "limit_price should be flattened");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCancelOrderByClientId: 404 passthrough", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify({ message: "Not found" }), { status: 404 });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCancelOrderByClientId({ client_id: "ghost-order", confirmation_token: "CONFIRM" }, client);
+    assert(result.isError === true, "should be error");
+    const parsed = JSON.parse(result.content[0].text) as { code: number };
+    assertEqual(parsed.code, 404, "code should be 404");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// Priority 3 — place_batch_orders
+// ----------------------------------------------------------------
+
+section("place_batch_orders");
+
+await test("handlePlaceBatchOrders: missing/wrong token returns CONFIRMATION_REQUIRED without fetch", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handlePlaceBatchOrders(
+      {
+        orders: [{ market_id: "BTC-CLP", type: "Bid", price_type: "limit", amount: 0.001, limit_price: 50000000 }],
+        confirmation_token: "NOPE",
+      },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "CONFIRMATION_REQUIRED", "code should be CONFIRMATION_REQUIRED");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handlePlaceBatchOrders: all valid + CONFIRM places all orders", async () => {
+  let callCount = 0;
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    callCount++;
+    return new Response(
+      JSON.stringify({
+        order: {
+          id: callCount * 100,
+          type: "Bid",
+          state: "pending",
+          created_at: "2024-01-01T00:00:00Z",
+          market_id: "BTC-CLP",
+          fee_currency: "CLP",
+          price_type: "limit",
+          order_type: "limit",
+          client_id: null,
+          limit: ["50000000", "CLP"],
+          amount: ["0.001", "BTC"],
+          original_amount: ["0.001", "BTC"],
+          traded_amount: ["0", "BTC"],
+          total_exchanged: ["0", "CLP"],
+          paid_fee: ["0", "CLP"],
+        },
+      }),
+      { status: 201, headers: { "Content-Type": "application/json" } },
+    );
+  };
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handlePlaceBatchOrders(
+      {
+        orders: [
+          { market_id: "BTC-CLP", type: "Bid", price_type: "limit", amount: 0.001, limit_price: 50000000 },
+          { market_id: "ETH-CLP", type: "Ask", price_type: "limit", amount: 0.1, limit_price: 3000000 },
+        ],
+        confirmation_token: "CONFIRM",
+      },
+      client,
+    );
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      total: number;
+      succeeded: number;
+      failed: number;
+      results: Array<{ success: boolean }>;
+    };
+    assertEqual(parsed.total, 2, "total should be 2");
+    assertEqual(parsed.succeeded, 2, "succeeded should be 2");
+    assertEqual(parsed.failed, 0, "failed should be 0");
+    assertEqual(callCount, 2, "should have made 2 API calls");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handlePlaceBatchOrders: one invalid market → pre-validation error, zero API calls", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handlePlaceBatchOrders(
+      {
+        orders: [
+          { market_id: "BTC-CLP", type: "Bid", price_type: "limit", amount: 0.001, limit_price: 50000000 },
+          { market_id: "INVALID!!!", type: "Ask", price_type: "limit", amount: 0.1, limit_price: 3000000 },
+        ],
+        confirmation_token: "CONFIRM",
+      },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string; index: number };
+    assertEqual(parsed.code, "INVALID_MARKET_ID", "code should be INVALID_MARKET_ID");
+    assertEqual(parsed.index, 1, "index should be 1");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handlePlaceBatchOrders: missing limit_price on limit order → pre-validation error", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handlePlaceBatchOrders(
+      {
+        orders: [{ market_id: "BTC-CLP", type: "Bid", price_type: "limit", amount: 0.001 }],
+        confirmation_token: "CONFIRM",
+      },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "VALIDATION_ERROR", "code should be VALIDATION_ERROR");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handlePlaceBatchOrders: one mid-batch API error → partial success report", async () => {
+  let callCount = 0;
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    callCount++;
+    if (callCount === 2) {
+      return new Response(JSON.stringify({ message: "Insufficient balance" }), { status: 422 });
+    }
+    return new Response(
+      JSON.stringify({
+        order: {
+          id: 100,
+          type: "Bid",
+          state: "pending",
+          created_at: "2024-01-01T00:00:00Z",
+          market_id: "BTC-CLP",
+          fee_currency: "CLP",
+          price_type: "limit",
+          order_type: "limit",
+          client_id: null,
+          limit: ["50000000", "CLP"],
+          amount: ["0.001", "BTC"],
+          original_amount: ["0.001", "BTC"],
+          traded_amount: ["0", "BTC"],
+          total_exchanged: ["0", "CLP"],
+          paid_fee: ["0", "CLP"],
+        },
+      }),
+      { status: 201, headers: { "Content-Type": "application/json" } },
+    );
+  };
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handlePlaceBatchOrders(
+      {
+        orders: [
+          { market_id: "BTC-CLP", type: "Bid", price_type: "limit", amount: 0.001, limit_price: 50000000 },
+          { market_id: "ETH-CLP", type: "Ask", price_type: "limit", amount: 0.1, limit_price: 3000000 },
+        ],
+        confirmation_token: "CONFIRM",
+      },
+      client,
+    );
+    assert(!result.isError, "partial success should not set isError");
+    const parsed = JSON.parse(result.content[0].text) as {
+      total: number;
+      succeeded: number;
+      failed: number;
+      warning?: string;
+    };
+    assertEqual(parsed.total, 2, "total should be 2");
+    assertEqual(parsed.succeeded, 1, "succeeded should be 1");
+    assertEqual(parsed.failed, 1, "failed should be 1");
+    assert(parsed.warning !== undefined, "warning should be present for partial failure");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// Priority 3 — place_order extended (3.22)
+// ----------------------------------------------------------------
+
+section("place_order extended (TIF + stop)");
+
+await test("handlePlaceOrder: existing limit order unchanged (no regression)", async () => {
+  const savedFetch = globalThis.fetch;
+  let capturedBody: Record<string, unknown> = {};
+  globalThis.fetch = async (_url: string | URL | Request, init?: RequestInit): Promise<Response> => {
+    capturedBody = JSON.parse(init?.body as string) as Record<string, unknown>;
+    return new Response(
+      JSON.stringify({
+        order: {
+          id: 1,
+          type: "Bid",
+          state: "pending",
+          created_at: "2024-01-01T00:00:00Z",
+          market_id: "BTC-CLP",
+          fee_currency: "CLP",
+          price_type: "limit",
+          order_type: "limit",
+          client_id: null,
+          limit: ["50000000", "CLP"],
+          amount: ["0.001", "BTC"],
+          original_amount: ["0.001", "BTC"],
+          traded_amount: ["0", "BTC"],
+          total_exchanged: ["0", "CLP"],
+          paid_fee: ["0", "CLP"],
+        },
+      }),
+      { status: 201, headers: { "Content-Type": "application/json" } },
+    );
+  };
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handlePlaceOrder(
+      { market_id: "BTC-CLP", type: "Bid", price_type: "limit", amount: 0.001, limit_price: 50000000, confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(!result.isError, "should not be error");
+    const limit = capturedBody.limit as Record<string, unknown>;
+    assertEqual(limit.type as string, "gtc", "default limit type should be gtc");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handlePlaceOrder: IOC flag → limit.type='ioc'", async () => {
+  const savedFetch = globalThis.fetch;
+  let capturedBody: Record<string, unknown> = {};
+  globalThis.fetch = async (_url: string | URL | Request, init?: RequestInit): Promise<Response> => {
+    capturedBody = JSON.parse(init?.body as string) as Record<string, unknown>;
+    return new Response(
+      JSON.stringify({
+        order: {
+          id: 2,
+          type: "Ask",
+          state: "traded",
+          created_at: "2024-01-01T00:00:00Z",
+          market_id: "BTC-CLP",
+          fee_currency: "CLP",
+          price_type: "limit",
+          order_type: "limit",
+          client_id: null,
+          limit: ["50000000", "CLP"],
+          amount: ["0.001", "BTC"],
+          original_amount: ["0.001", "BTC"],
+          traded_amount: ["0.001", "BTC"],
+          total_exchanged: ["50000", "CLP"],
+          paid_fee: ["250", "CLP"],
+        },
+      }),
+      { status: 201, headers: { "Content-Type": "application/json" } },
+    );
+  };
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handlePlaceOrder(
+      { market_id: "BTC-CLP", type: "Ask", price_type: "limit", amount: 0.001, limit_price: 50000000, ioc: true, confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(!result.isError, "should not be error");
+    const limit = capturedBody.limit as Record<string, unknown>;
+    assertEqual(limit.type as string, "ioc", "limit type should be ioc");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handlePlaceOrder: stop_price without stop_type → VALIDATION_ERROR", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handlePlaceOrder(
+      { market_id: "BTC-CLP", type: "Bid", price_type: "limit", amount: 0.001, limit_price: 50000000, stop_price: 45000000, confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "VALIDATION_ERROR", "code should be VALIDATION_ERROR");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handlePlaceOrder: mutually exclusive TIF flags → VALIDATION_ERROR", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handlePlaceOrder(
+      { market_id: "BTC-CLP", type: "Bid", price_type: "limit", amount: 0.001, limit_price: 50000000, ioc: true, fok: true, confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "VALIDATION_ERROR", "code should be VALIDATION_ERROR");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// Priority 3 — create_withdrawal
+// ----------------------------------------------------------------
+
+section("create_withdrawal");
+
+await test("handleCreateWithdrawal: missing/wrong token returns CONFIRMATION_REQUIRED without fetch", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handleCreateWithdrawal(
+      { currency: "BTC", amount: 0.01, address: "bc1q...", confirmation_token: "NOPE" },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "CONFIRMATION_REQUIRED", "code should be CONFIRMATION_REQUIRED");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCreateWithdrawal: both address+bank_account_id → VALIDATION_ERROR", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handleCreateWithdrawal(
+      { currency: "BTC", amount: 0.01, address: "bc1q...", bank_account_id: 123, confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "VALIDATION_ERROR", "code should be VALIDATION_ERROR");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCreateWithdrawal: neither address nor bank_account_id → VALIDATION_ERROR", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handleCreateWithdrawal(
+      { currency: "BTC", amount: 0.01, confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "VALIDATION_ERROR", "code should be VALIDATION_ERROR");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCreateWithdrawal: crypto path + CONFIRM", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        withdrawal: {
+          id: 77,
+          state: "pending",
+          currency: "BTC",
+          amount: ["0.01", "BTC"],
+          fee: ["0.0001", "BTC"],
+          address: "bc1q...",
+          tx_hash: null,
+          bank_account_id: null,
+          created_at: "2024-01-01T00:00:00Z",
+          updated_at: "2024-01-01T00:00:00Z",
+        },
+      }),
+      { status: 201, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCreateWithdrawal(
+      { currency: "BTC", amount: 0.01, address: "bc1q...", confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      id: number;
+      state: string;
+      amount: number;
+      address: string | null;
+    };
+    assertEqual(parsed.id, 77, "id should be 77");
+    assertEqual(parsed.state, "pending", "state should be pending");
+    assertEqual(parsed.amount, 0.01, "amount should be flattened");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCreateWithdrawal: fiat path + CONFIRM", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        withdrawal: {
+          id: 88,
+          state: "pending",
+          currency: "CLP",
+          amount: ["100000", "CLP"],
+          fee: ["0", "CLP"],
+          address: null,
+          tx_hash: null,
+          bank_account_id: 123,
+          created_at: "2024-01-01T00:00:00Z",
+          updated_at: "2024-01-01T00:00:00Z",
+        },
+      }),
+      { status: 201, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCreateWithdrawal(
+      { currency: "CLP", amount: 100000, bank_account_id: 123, confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as { id: number; bank_account_id: number | null };
+    assertEqual(parsed.id, 88, "id should be 88");
+    assertEqual(parsed.bank_account_id, 123, "bank_account_id should be 123");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCreateWithdrawal: 422 insufficient balance passthrough", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify({ message: "Insufficient balance" }), { status: 422 });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCreateWithdrawal(
+      { currency: "BTC", amount: 999, address: "bc1q...", confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    const parsed = JSON.parse(result.content[0].text) as { code: number };
+    assertEqual(parsed.code, 422, "code should be 422");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// Priority 3 — create_fiat_deposit
+// ----------------------------------------------------------------
+
+section("create_fiat_deposit");
+
+await test("handleCreateFiatDeposit: missing/wrong token returns CONFIRMATION_REQUIRED without fetch", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handleCreateFiatDeposit(
+      { currency: "CLP", amount: 100000, confirmation_token: "NOPE" },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "CONFIRMATION_REQUIRED", "code should be CONFIRMATION_REQUIRED");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCreateFiatDeposit: invalid currency → INVALID_CURRENCY before API", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handleCreateFiatDeposit(
+      { currency: "!!!", amount: 100000, confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string };
+    assertEqual(parsed.code, "INVALID_CURRENCY", "code should be INVALID_CURRENCY");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCreateFiatDeposit: happy path + CONFIRM", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        deposit: {
+          id: 55,
+          state: "pending_info",
+          currency: "CLP",
+          amount: ["100000", "CLP"],
+          fee: ["0", "CLP"],
+          created_at: "2024-01-01T00:00:00Z",
+          updated_at: "2024-01-01T00:00:00Z",
+          transfer_account_id: null,
+          transaction_hash: null,
+        },
+      }),
+      { status: 201, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCreateFiatDeposit(
+      { currency: "CLP", amount: 100000, bank: "BancoEstado", confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as { id: number; state: string; amount: number };
+    assertEqual(parsed.id, 55, "id should be 55");
+    assertEqual(parsed.state, "pending_info", "state should be pending_info");
+    assertEqual(parsed.amount, 100000, "amount should be flattened");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCreateFiatDeposit: 422 passthrough", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify({ message: "Unprocessable Entity" }), { status: 422 });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCreateFiatDeposit(
+      { currency: "CLP", amount: 100000, confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    const parsed = JSON.parse(result.content[0].text) as { code: number };
+    assertEqual(parsed.code, 422, "code should be 422");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// Priority 3 — lightning_withdrawal
+// ----------------------------------------------------------------
+
+section("lightning_withdrawal");
+
+await test("handleLightningWithdrawal: missing/wrong token returns CONFIRMATION_REQUIRED without fetch", async () => {
+  const fetchCalled = { value: false };
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> => {
+    fetchCalled.value = true;
+    return new Response("{}", { status: 200 });
+  };
+  try {
+    const client = {} as BudaClient;
+    const result = await handleLightningWithdrawal(
+      { invoice: "lnbc1000u1ptest...", confirmation_token: "NOPE" },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    assert(!fetchCalled.value, "fetch should not have been called");
+    const parsed = JSON.parse(result.content[0].text) as { code: string; preview?: { invoice_preview: string } };
+    assertEqual(parsed.code, "CONFIRMATION_REQUIRED", "code should be CONFIRMATION_REQUIRED");
+    assert(parsed.preview?.invoice_preview !== undefined, "should include invoice_preview");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleLightningWithdrawal: happy path returns flat withdrawal", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        lightning_withdrawal: {
+          id: 42,
+          state: "completed",
+          amount: ["100000", "SAT"],
+          fee: ["1000", "SAT"],
+          payment_hash: "abc123",
+          created_at: "2024-01-01T00:00:00Z",
+        },
+      }),
+      { status: 201, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleLightningWithdrawal(
+      { invoice: "lnbc1000u1ptest...", confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      id: number;
+      state: string;
+      amount: number;
+      payment_hash: string;
+    };
+    assertEqual(parsed.id, 42, "id should be 42");
+    assertEqual(parsed.state, "completed", "state should be completed");
+    assertEqual(parsed.amount, 100000, "amount should be flattened");
+    assertEqual(parsed.payment_hash, "abc123", "payment_hash should be abc123");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleLightningWithdrawal: API error passthrough", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify({ message: "Invoice already paid" }), { status: 422 });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleLightningWithdrawal(
+      { invoice: "lnbc1000u1ptest...", confirmation_token: "CONFIRM" },
+      client,
+    );
+    assert(result.isError === true, "should be error");
+    const parsed = JSON.parse(result.content[0].text) as { code: number };
+    assertEqual(parsed.code, 422, "code should be 422");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+// ----------------------------------------------------------------
+// Priority 3 — create_lightning_invoice
+// ----------------------------------------------------------------
+
+section("create_lightning_invoice");
+
+await test("handleCreateLightningInvoice: happy path returns invoice fields", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(
+      JSON.stringify({
+        lightning_network_invoice: {
+          id: 99,
+          payment_request: "lnbc1000u1pfinal...",
+          amount: ["100000", "SAT"],
+          description: "Test payment",
+          expires_at: "2024-01-01T01:00:00Z",
+          state: "pending",
+          created_at: "2024-01-01T00:00:00Z",
+        },
+      }),
+      { status: 201, headers: { "Content-Type": "application/json" } },
+    );
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCreateLightningInvoice(
+      { amount_satoshis: 100000, description: "Test payment", expiry_seconds: 3600 },
+      client,
+    );
+    assert(!result.isError, "should not be error");
+    const parsed = JSON.parse(result.content[0].text) as {
+      id: number;
+      payment_request: string;
+      amount_satoshis: number;
+      description: string | null;
+      expires_at: string;
+    };
+    assertEqual(parsed.id, 99, "id should be 99");
+    assertEqual(parsed.payment_request, "lnbc1000u1pfinal...", "payment_request should match");
+    assertEqual(parsed.amount_satoshis, 100000, "amount_satoshis should be 100000");
+    assertEqual(parsed.description, "Test payment", "description should match");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
+await test("handleCreateLightningInvoice: API error passthrough", async () => {
+  const savedFetch = globalThis.fetch;
+  globalThis.fetch = async (): Promise<Response> =>
+    new Response(JSON.stringify({ message: "Unprocessable Entity" }), { status: 422 });
+  try {
+    const client = new BudaClient("https://www.buda.com/api/v2");
+    const result = await handleCreateLightningInvoice({ amount_satoshis: 100000 }, client);
+    assert(result.isError === true, "should be error");
+    const parsed = JSON.parse(result.content[0].text) as { code: number };
+    assertEqual(parsed.code, 422, "code should be 422");
+  } finally {
+    globalThis.fetch = savedFetch;
+  }
+});
+
 // ----------------------------------------------------------------
 // Summary
 // ----------------------------------------------------------------