@nemesis-oss/binance-sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,4402 @@
+// src/client/HttpClient.ts
+import { createHmac } from "crypto";
+import axios from "axios";
+import Bottleneck from "bottleneck";
+
+// src/errors/BinanceError.ts
+var BinanceError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "BinanceError";
+  }
+};
+
+// src/errors/BinanceAuthError.ts
+var BinanceAuthError = class extends BinanceError {
+  constructor(missing) {
+    super(`API ${missing} required for authenticated requests`);
+    this.name = "BinanceAuthError";
+    this.missing = missing;
+  }
+};
+
+// src/errors/BinanceApiError.ts
+var BinanceApiError = class extends BinanceError {
+  constructor(message, code, status) {
+    super(message);
+    this.name = "BinanceApiError";
+    this.code = code;
+    this.status = status;
+  }
+};
+
+// src/errors/RateLimitError.ts
+var RateLimitError = class extends BinanceApiError {
+  constructor(message, code, status, retryAfterMs) {
+    super(message, code, status);
+    this.name = "RateLimitError";
+    this.retryAfterMs = retryAfterMs;
+  }
+};
+
+// src/errors/NetworkError.ts
+var NetworkError = class extends BinanceError {
+  constructor(message, cause) {
+    super(message);
+    this.name = "NetworkError";
+    this.cause = cause;
+  }
+};
+
+// src/client/HttpClient.ts
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([429, 418, 500, 502, 503, 504]);
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var HttpClient = class {
+  constructor(options) {
+    this.pendingRequests = 0;
+    this.apiKey = options.apiKey;
+    this.apiSecret = options.apiSecret;
+    this.recvWindow = options.recvWindow ?? 5e3;
+    this.timeoutMs = options.timeoutMs ?? 15e3;
+    this.maxRetries = options.maxRetries ?? 3;
+    this.minTimeMs = options.minTimeMs ?? 50;
+    this.retryBaseDelayMs = options.retryBaseDelayMs ?? 1e3;
+    this.retryMaxDelayMs = options.retryMaxDelayMs ?? 3e4;
+    this.retryFactor = options.retryFactor ?? 2;
+    this.axios = axios.create({ baseURL: options.baseURL, timeout: this.timeoutMs });
+    this.limiter = new Bottleneck({ minTime: this.minTimeMs });
+  }
+  async get(path, params, mode = "public") {
+    return this.request("GET", path, params, mode);
+  }
+  async post(path, params, mode = "public") {
+    return this.request("POST", path, params, mode);
+  }
+  async put(path, params, mode = "public") {
+    return this.request("PUT", path, params, mode);
+  }
+  async delete(path, params, mode = "public") {
+    return this.request("DELETE", path, params, mode);
+  }
+  getRateLimiterStatus() {
+    return { minTimeMs: this.minTimeMs, queueLength: this.pendingRequests };
+  }
+  configureRateLimiter(options) {
+    if (options.minTimeMs !== void 0) {
+      this.minTimeMs = options.minTimeMs;
+      this.limiter.updateSettings({ minTime: this.minTimeMs });
+    }
+  }
+  getRetryConfig() {
+    return {
+      maxRetries: this.maxRetries,
+      baseDelayMs: this.retryBaseDelayMs,
+      maxDelayMs: this.retryMaxDelayMs,
+      factor: this.retryFactor
+    };
+  }
+  configureRetry(options) {
+    if (options.maxRetries !== void 0) this.maxRetries = options.maxRetries;
+    if (options.baseDelayMs !== void 0) this.retryBaseDelayMs = options.baseDelayMs;
+    if (options.maxDelayMs !== void 0) this.retryMaxDelayMs = options.maxDelayMs;
+    if (options.factor !== void 0) this.retryFactor = options.factor;
+  }
+  async request(method, path, params, mode) {
+    const url = this.buildUrl(path, params, mode);
+    const config = { method, url, headers: this.buildHeaders(mode) };
+    return this.limiter.schedule(() => this.requestWithRetry(config, 0));
+  }
+  buildHeaders(mode) {
+    const headers = {
+      "Content-Type": "application/x-www-form-urlencoded",
+      "User-Agent": "binance-sdk"
+    };
+    if (mode !== "public") headers["X-MBX-APIKEY"] = this.requireApiKey();
+    return headers;
+  }
+  buildUrl(path, params, mode) {
+    if (mode !== "signed") return this.appendQuery(path, params);
+    const requestData = { ...params, timestamp: Date.now(), recvWindow: this.recvWindow };
+    const queryString = this.buildQueryString(requestData);
+    const signature = this.sign(queryString);
+    return `${path}?${queryString}&signature=${signature}`;
+  }
+  appendQuery(path, params) {
+    const queryString = this.buildQueryString(params);
+    return queryString ? `${path}?${queryString}` : path;
+  }
+  buildQueryString(params) {
+    if (!params) return "";
+    return Object.entries(params).filter(([, val]) => val !== void 0 && val !== null).map(([key, val]) => `${key}=${encodeURIComponent(String(val))}`).join("&");
+  }
+  sign(queryString) {
+    if (!this.apiSecret) throw new BinanceAuthError("apiSecret");
+    return createHmac("sha256", this.apiSecret).update(queryString).digest("hex");
+  }
+  requireApiKey() {
+    if (!this.apiKey) throw new BinanceAuthError("apiKey");
+    return this.apiKey;
+  }
+  async requestWithRetry(config, attempt) {
+    this.pendingRequests += 1;
+    try {
+      const res = await this.axios.request(config);
+      return res.data;
+    } catch (err) {
+      if (!axios.isAxiosError(err)) {
+        throw new NetworkError("Unexpected error calling Binance API", err);
+      }
+      const status = err.response?.status;
+      const body = err.response?.data;
+      if (attempt < this.maxRetries && this.shouldRetry(err)) {
+        await sleep(this.calculateDelay(attempt));
+        return this.requestWithRetry(config, attempt + 1);
+      }
+      if (status === 429 || status === 418) {
+        throw new RateLimitError(body?.msg ?? "Binance rate limit exceeded", body?.code ?? -1, status);
+      }
+      if (status && body) {
+        throw new BinanceApiError(body.msg ?? "Binance API error", body.code ?? -1, status);
+      }
+      throw new NetworkError(err.message, err);
+    } finally {
+      this.pendingRequests -= 1;
+    }
+  }
+  shouldRetry(err) {
+    if (err.response?.status !== void 0) return RETRYABLE_STATUS.has(err.response.status);
+    return true;
+  }
+  calculateDelay(attempt) {
+    const delay = Math.min(this.retryBaseDelayMs * this.retryFactor ** attempt, this.retryMaxDelayMs);
+    const jitter = delay * 0.1 * (Math.random() * 2 - 1);
+    return Math.max(0, delay + jitter);
+  }
+};
+
+// src/client/endpoints.ts
+function resolveEnvironment(options) {
+  const env = options?.demo ? "demo" : options?.testnet ? "testnet" : "live";
+  const restHost = options?.apiBase ?? (env === "demo" ? "https://demo-fapi.binance.com" : env === "testnet" ? "https://testnet.binancefuture.com" : "https://fapi.binance.com");
+  const wsMarketHost = options?.wsBase ?? (env === "demo" ? "wss://demo-fstream.binance.com/stream" : env === "testnet" ? "wss://fstream.binancefuture.com/stream" : "wss://fstream.binance.com/stream");
+  const wsUserHost = options?.wsUserBase ?? (env === "demo" ? "wss://demo-fstream.binance.com/ws" : env === "testnet" ? "wss://fstream.binancefuture.com/ws" : "wss://fstream.binance.com/ws");
+  const wsApiHost = options?.wsApiBase ?? (env === "demo" ? "wss://demo-fapi.binance.com/ws-fapi/v1" : "wss://ws-fapi.binance.com/ws-fapi/v1");
+  const restSpotHost = options?.apiBase ?? (env === "testnet" ? "https://testnet.binance.vision" : "https://api.binance.com");
+  const wsSpotMarketHost = options?.wsBase ?? (env === "testnet" ? "wss://testnet.binance.vision/stream" : "wss://stream.binance.com:9443/stream");
+  const wsSpotUserHost = options?.wsUserBase ?? (env === "testnet" ? "wss://testnet.binance.vision/ws" : "wss://stream.binance.com:9443/ws");
+  return {
+    env,
+    endpoints: {
+      restRoot: restHost,
+      restFapi: `${restHost}/fapi/v1`,
+      restFuturesData: `${restHost}/futures/data`,
+      restSpot: `${restSpotHost}/api/v3`,
+      wsMarket: wsMarketHost,
+      wsUser: wsUserHost,
+      wsApi: wsApiHost,
+      wsSpotMarket: wsSpotMarketHost,
+      wsSpotUser: wsSpotUserHost
+    }
+  };
+}
+
+// src/types/futures.types.ts
+import { z } from "zod";
+var FundingRateSchema = z.object({
+  symbol: z.string(),
+  fundingTime: z.number(),
+  fundingRate: z.string().transform(Number),
+  markPrice: z.string().transform(Number).optional()
+});
+var FundingRateHistorySchema = z.array(FundingRateSchema);
+var PremiumIndexSchema = z.object({
+  symbol: z.string(),
+  markPrice: z.string().transform(Number),
+  indexPrice: z.string().transform(Number),
+  estimatedSettlePrice: z.string().transform(Number),
+  lastFundingRate: z.string().transform(Number),
+  nextFundingTime: z.number(),
+  interestRate: z.string().transform(Number),
+  time: z.number()
+});
+var OpenInterestSchema = z.object({
+  symbol: z.string(),
+  openInterest: z.string().transform(Number),
+  time: z.number()
+});
+var OpenInterestHistEntrySchema = z.object({
+  symbol: z.string(),
+  sumOpenInterest: z.string().transform(Number),
+  sumOpenInterestValue: z.string().transform(Number),
+  timestamp: z.number()
+});
+var OpenInterestHistSchema = z.array(OpenInterestHistEntrySchema);
+var LongShortRatioEntrySchema = z.object({
+  symbol: z.string(),
+  longShortRatio: z.string().transform(Number),
+  longAccount: z.string().transform(Number),
+  shortAccount: z.string().transform(Number),
+  timestamp: z.number()
+});
+var LongShortRatioSchema = z.array(LongShortRatioEntrySchema);
+var TakerLongShortRatioEntrySchema = z.object({
+  buySellRatio: z.string().transform(Number),
+  buyVol: z.string().transform(Number),
+  sellVol: z.string().transform(Number),
+  timestamp: z.number()
+});
+var TakerLongShortRatioSchema = z.array(TakerLongShortRatioEntrySchema);
+
+// src/resources/FuturesData.ts
+var FuturesData = class {
+  constructor(endpoints) {
+    const { restFapi, restFuturesData, ...httpOptions } = endpoints ?? {};
+    this.http = new HttpClient({ baseURL: restFapi ?? "https://fapi.binance.com/fapi/v1", ...httpOptions });
+    this.dataHttp = new HttpClient({
+      baseURL: restFuturesData ?? "https://fapi.binance.com/futures/data",
+      ...httpOptions
+    });
+  }
+  async fundingRateHistory(symbol3, options) {
+    const data = await this.http.get("/fundingRate", {
+      symbol: symbol3,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit ?? 100
+    });
+    return FundingRateHistorySchema.parse(data);
+  }
+  async premiumIndex(symbol3) {
+    return PremiumIndexSchema.parse(await this.http.get("/premiumIndex", { symbol: symbol3 }));
+  }
+  async openInterest(symbol3) {
+    return OpenInterestSchema.parse(await this.http.get("/openInterest", { symbol: symbol3 }));
+  }
+  async openInterestHist(symbol3, period2, limit4 = 30) {
+    const data = await this.dataHttp.get("/openInterestHist", { symbol: symbol3, period: period2, limit: limit4 });
+    return OpenInterestHistSchema.parse(data);
+  }
+  async topLongShortAccountRatio(symbol3, period2, limit4 = 30) {
+    const data = await this.dataHttp.get("/topLongShortAccountRatio", { symbol: symbol3, period: period2, limit: limit4 });
+    return LongShortRatioSchema.parse(data);
+  }
+  async topLongShortPositionRatio(symbol3, period2, limit4 = 30) {
+    const data = await this.dataHttp.get("/topLongShortPositionRatio", { symbol: symbol3, period: period2, limit: limit4 });
+    return LongShortRatioSchema.parse(data);
+  }
+  async globalLongShortAccountRatio(symbol3, period2, limit4 = 30) {
+    const data = await this.dataHttp.get("/globalLongShortAccountRatio", { symbol: symbol3, period: period2, limit: limit4 });
+    return LongShortRatioSchema.parse(data);
+  }
+  async takerLongShortRatio(symbol3, period2, limit4 = 30) {
+    const data = await this.dataHttp.get("/takerlongshortRatio", { symbol: symbol3, period: period2, limit: limit4 });
+    return TakerLongShortRatioSchema.parse(data);
+  }
+  async basis(symbol3, period2, options) {
+    return this.dataHttp.get("/basis", {
+      symbol: symbol3,
+      period: period2,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit
+    });
+  }
+  async fundingInfo() {
+    return this.http.get("/fundingInfo");
+  }
+  async assetIndex(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return this.http.get("/assetIndex", params);
+  }
+  async compositeIndexInfo(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return this.http.get("/indexInfo", params);
+  }
+  async adlQuantile(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return this.http.get("/adlQuantile", params, "signed");
+  }
+  async blvtInfo(tokenName, interval, options) {
+    return this.http.get("/lvtKlines", {
+      tokenName,
+      interval,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit
+    });
+  }
+  async indexPriceConstituents(symbol3) {
+    return this.http.get("/constituents", { symbol: symbol3 });
+  }
+  async symbolConfig(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return this.http.get("/symbolConfig", params, "signed");
+  }
+  async forceOrders(options) {
+    return this.http.get(
+      "/forceOrders",
+      {
+        symbol: options?.symbol,
+        autoCloseType: options?.autoCloseType,
+        startTime: options?.startTime,
+        endTime: options?.endTime,
+        limit: options?.limit
+      },
+      "signed"
+    );
+  }
+  async insuranceFundBalance(options) {
+    return this.dataHttp.get("/insuranceBalance", {
+      symbol: options?.symbol,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit
+    });
+  }
+  async pmExchangeInfo() {
+    return this.http.get("/pmExchangeInfo");
+  }
+  async delistSchedule(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return this.http.get("/delistSchedule", params);
+  }
+  async symbolAdlRisk(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return this.http.get("/symbolAdlRisk", params, "signed");
+  }
+  async deliveryPrice(pair) {
+    return this.dataHttp.get("/delivery-price", { pair });
+  }
+};
+
+// src/types/market.types.ts
+import { z as z2 } from "zod";
+var KlineIntervalSchema = z2.enum([
+  "1m",
+  "3m",
+  "5m",
+  "15m",
+  "30m",
+  "1h",
+  "2h",
+  "4h",
+  "6h",
+  "8h",
+  "12h",
+  "1d",
+  "3d",
+  "1w",
+  "1M"
+]);
+var RawKlineSchema = z2.tuple([
+  z2.number(),
+  z2.string(),
+  z2.string(),
+  z2.string(),
+  z2.string(),
+  z2.string(),
+  z2.number(),
+  z2.string(),
+  z2.number(),
+  z2.string(),
+  z2.string(),
+  z2.string()
+]);
+var KlineSchema = RawKlineSchema.transform(
+  ([openTime, open, high, low, close, volume, closeTime, quoteAssetVolume, trades, takerBuyBaseVolume, takerBuyQuoteVolume]) => ({
+    openTime,
+    open: Number(open),
+    high: Number(high),
+    low: Number(low),
+    close: Number(close),
+    volume: Number(volume),
+    closeTime,
+    quoteAssetVolume: Number(quoteAssetVolume),
+    trades,
+    takerBuyBaseVolume: Number(takerBuyBaseVolume),
+    takerBuyQuoteVolume: Number(takerBuyQuoteVolume)
+  })
+);
+var KlinesResponseSchema = z2.array(KlineSchema);
+var TickerPriceSchema = z2.object({
+  symbol: z2.string(),
+  price: z2.string().transform(Number),
+  time: z2.number().optional()
+});
+var Ticker24hrSchema = z2.object({
+  symbol: z2.string(),
+  priceChange: z2.string().transform(Number),
+  priceChangePercent: z2.string().transform(Number),
+  weightedAvgPrice: z2.string().transform(Number),
+  lastPrice: z2.string().transform(Number),
+  lastQty: z2.string().transform(Number),
+  openPrice: z2.string().transform(Number),
+  highPrice: z2.string().transform(Number),
+  lowPrice: z2.string().transform(Number),
+  volume: z2.string().transform(Number),
+  quoteVolume: z2.string().transform(Number),
+  openTime: z2.number(),
+  closeTime: z2.number(),
+  firstId: z2.number(),
+  lastId: z2.number(),
+  count: z2.number()
+});
+var BookTickerSchema = z2.object({
+  symbol: z2.string(),
+  bidPrice: z2.string().transform(Number),
+  bidQty: z2.string().transform(Number),
+  askPrice: z2.string().transform(Number),
+  askQty: z2.string().transform(Number),
+  time: z2.number().optional()
+});
+var DepthLevelSchema = z2.tuple([z2.string(), z2.string()]).transform(([price, qty]) => ({ price: Number(price), qty: Number(qty) }));
+var DepthSnapshotSchema = z2.object({
+  lastUpdateId: z2.number(),
+  bids: z2.array(DepthLevelSchema),
+  asks: z2.array(DepthLevelSchema)
+});
+var TradeSchema = z2.object({
+  id: z2.number(),
+  price: z2.string().transform(Number),
+  qty: z2.string().transform(Number),
+  quoteQty: z2.string().transform(Number),
+  time: z2.number(),
+  isBuyerMaker: z2.boolean()
+});
+var TradesResponseSchema = z2.array(TradeSchema);
+var AggTradeSchema = z2.object({
+  a: z2.number(),
+  p: z2.string().transform(Number),
+  q: z2.string().transform(Number),
+  f: z2.number(),
+  l: z2.number(),
+  T: z2.number(),
+  m: z2.boolean()
+});
+var AggTradesResponseSchema = z2.array(AggTradeSchema);
+var AvgPriceSchema = z2.object({
+  mins: z2.number(),
+  price: z2.string().transform(Number)
+});
+var ExchangeSymbolSchema = z2.object({
+  symbol: z2.string(),
+  status: z2.string(),
+  baseAsset: z2.string(),
+  quoteAsset: z2.string()
+}).loose();
+var ExchangeInfoSchema = z2.object({
+  timezone: z2.string(),
+  serverTime: z2.number(),
+  symbols: z2.array(ExchangeSymbolSchema)
+}).loose();
+
+// src/resources/MarketDataBase.ts
+var MarketDataBase = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async exchangeInfo() {
+    return ExchangeInfoSchema.parse(await this.http.get("/exchangeInfo"));
+  }
+  async ping() {
+    return this.http.get("/ping");
+  }
+  async serverTime() {
+    return this.http.get("/time");
+  }
+  async historicalTrades(symbol3, options) {
+    const data = await this.http.get("/historicalTrades", {
+      symbol: symbol3,
+      fromId: options?.fromId,
+      limit: options?.limit ?? 500
+    });
+    return TradesResponseSchema.parse(data);
+  }
+  async klines(symbol3, interval, options) {
+    const data = await this.http.get("/klines", {
+      symbol: symbol3,
+      interval,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit ?? 500
+    });
+    return KlinesResponseSchema.parse(data);
+  }
+  async tickerPrice(symbol3) {
+    return TickerPriceSchema.parse(await this.http.get("/ticker/price", { symbol: symbol3 }));
+  }
+  async ticker24hr(symbol3) {
+    return Ticker24hrSchema.parse(await this.http.get("/ticker/24hr", { symbol: symbol3 }));
+  }
+  async bookTicker(symbol3) {
+    return BookTickerSchema.parse(await this.http.get("/ticker/bookTicker", { symbol: symbol3 }));
+  }
+  async depth(symbol3, limit4 = 100) {
+    return DepthSnapshotSchema.parse(await this.http.get("/depth", { symbol: symbol3, limit: limit4 }));
+  }
+  async trades(symbol3, limit4 = 500) {
+    return TradesResponseSchema.parse(await this.http.get("/trades", { symbol: symbol3, limit: limit4 }));
+  }
+  async aggTrades(symbol3, options) {
+    const data = await this.http.get("/aggTrades", {
+      symbol: symbol3,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit ?? 500
+    });
+    return AggTradesResponseSchema.parse(data);
+  }
+};
+
+// src/resources/FuturesMarket.ts
+var FuturesMarket = class extends MarketDataBase {
+  constructor(http, restRoot) {
+    super(http ?? new HttpClient({ baseURL: "https://fapi.binance.com/fapi/v1" }));
+    this.rootHttp = new HttpClient({ baseURL: restRoot ?? "https://fapi.binance.com" });
+  }
+  async continuousKlines(pair, contractType2, interval, options) {
+    const data = await this.http.get("/continuousKlines", {
+      pair,
+      contractType: contractType2,
+      interval,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit ?? 500
+    });
+    return KlinesResponseSchema.parse(data);
+  }
+  async indexPriceKlines(pair, interval, options) {
+    const data = await this.http.get("/indexPriceKlines", {
+      pair,
+      interval,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit ?? 500
+    });
+    return KlinesResponseSchema.parse(data);
+  }
+  async markPriceKlines(symbol3, interval, options) {
+    const data = await this.http.get("/markPriceKlines", {
+      symbol: symbol3,
+      interval,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit ?? 500
+    });
+    return KlinesResponseSchema.parse(data);
+  }
+  async premiumIndexKlines(symbol3, interval, options) {
+    const data = await this.http.get("/premiumIndexKlines", {
+      symbol: symbol3,
+      interval,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit ?? 500
+    });
+    return KlinesResponseSchema.parse(data);
+  }
+  async rpiDepth(symbol3, limit4 = 1e3) {
+    return DepthSnapshotSchema.parse(await this.http.get("/rpiDepth", { symbol: symbol3, limit: limit4 }));
+  }
+  async tradingDayTicker(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return this.http.get("/tradingDayTicker", params);
+  }
+  async tickerPriceV2(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return TickerPriceSchema.parse(await this.rootHttp.get("/fapi/v2/ticker/price", params));
+  }
+  async bookTickerV2(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return BookTickerSchema.parse(await this.rootHttp.get("/fapi/v2/ticker/bookTicker", params));
+  }
+  async instrumentDetails(symbol3) {
+    const info = await ExchangeInfoSchema.parse(await this.http.get("/exchangeInfo"));
+    const details = info.symbols.find((s) => s.symbol === symbol3);
+    if (!details) throw new Error(`Instrument ${symbol3} not found`);
+    return details;
+  }
+};
+
+// src/resources/SpotMarket.ts
+var SpotMarket = class extends MarketDataBase {
+  constructor(http) {
+    super(http ?? new HttpClient({ baseURL: "https://api.binance.com/api/v3" }));
+  }
+  async avgPrice(symbol3) {
+    return AvgPriceSchema.parse(await this.http.get("/avgPrice", { symbol: symbol3 }));
+  }
+  /** Optimized klines endpoint (`/uiKlines`) with the same response shape as `/klines`. */
+  async uiKlines(symbol3, interval, options) {
+    const data = await this.http.get("/uiKlines", {
+      symbol: symbol3,
+      interval,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit ?? 500
+    });
+    return KlinesResponseSchema.parse(data);
+  }
+  /** Rolling window ticker (`/ticker`). Omit `symbol` for all symbols. */
+  async rollingWindowTicker(symbol3, windowSize) {
+    const params = { symbol: symbol3, windowSize };
+    return this.http.get("/ticker", params);
+  }
+  /** Trading-day ticker (`/ticker/tradingDay`). Omit `symbol` for all symbols. */
+  async tradingDayTicker(symbol3, options) {
+    return this.http.get("/ticker/tradingDay", { symbol: symbol3, ...options });
+  }
+};
+
+// src/types/spot.types.ts
+import { z as z3 } from "zod";
+var SpotOrderSchema = z3.object({
+  symbol: z3.string(),
+  orderId: z3.number(),
+  clientOrderId: z3.string(),
+  status: z3.string(),
+  side: z3.string(),
+  type: z3.string(),
+  timeInForce: z3.string().optional(),
+  price: z3.string().transform(Number).optional(),
+  origQty: z3.string().transform(Number).optional(),
+  executedQty: z3.string().transform(Number).optional(),
+  cummulativeQuoteQty: z3.string().transform(Number).optional(),
+  stopPrice: z3.string().transform(Number).optional(),
+  icebergQty: z3.string().transform(Number).optional(),
+  originalQuoteOrderQty: z3.string().transform(Number).optional(),
+  transactTime: z3.number().optional(),
+  workingTime: z3.number().optional(),
+  orderListId: z3.number().optional(),
+  selfTradePreventionMode: z3.string().optional(),
+  fills: z3.array(z3.unknown()).optional()
+}).loose();
+var SpotOrderResponseSchema = SpotOrderSchema;
+var SpotOrdersResponseSchema = z3.array(SpotOrderSchema);
+var SpotOCOOrderAckSchema = z3.object({
+  orderListId: z3.number(),
+  contingencyType: z3.string(),
+  listStatusType: z3.string(),
+  listOrderStatus: z3.string(),
+  listClientOrderId: z3.string(),
+  transactionTime: z3.number(),
+  symbol: z3.string(),
+  orders: z3.array(SpotOrderSchema),
+  orderReports: z3.array(z3.unknown()).optional()
+}).loose();
+var SpotOCOOrderAckResponseSchema = SpotOCOOrderAckSchema;
+var SpotOCOOrdersResponseSchema = z3.array(SpotOCOOrderAckSchema);
+var SpotTradeSchema = z3.object({
+  symbol: z3.string(),
+  id: z3.number(),
+  orderId: z3.number(),
+  orderListId: z3.number().optional(),
+  price: z3.string().transform(Number),
+  qty: z3.string().transform(Number),
+  quoteQty: z3.string().transform(Number),
+  commission: z3.string().transform(Number),
+  commissionAsset: z3.string(),
+  time: z3.number(),
+  isBuyer: z3.boolean(),
+  isMaker: z3.boolean(),
+  isBestMatch: z3.boolean()
+}).loose();
+var SpotTradesResponseSchema = z3.array(SpotTradeSchema);
+var SpotBalanceSchema = z3.object({
+  asset: z3.string(),
+  free: z3.string().transform(Number),
+  locked: z3.string().transform(Number)
+});
+var SpotAccountSchema = z3.object({
+  makerCommission: z3.number(),
+  takerCommission: z3.number(),
+  buyerCommission: z3.number(),
+  sellerCommission: z3.number(),
+  canTrade: z3.boolean(),
+  canWithdraw: z3.boolean(),
+  canDeposit: z3.boolean(),
+  updateTime: z3.number().optional(),
+  accountType: z3.string().optional(),
+  balances: z3.array(SpotBalanceSchema),
+  permissions: z3.array(z3.string()).optional()
+}).loose();
+var SpotExecutionReportSchema = z3.object({ e: z3.literal("executionReport") }).loose();
+var SpotOutboundAccountPositionSchema = z3.object({ e: z3.literal("outboundAccountPosition") }).loose();
+var SpotBalanceUpdateSchema = z3.object({ e: z3.literal("balanceUpdate") }).loose();
+var SpotListStatusSchema = z3.object({ e: z3.literal("listStatus") }).loose();
+function parseSpotUserDataEvent(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error("Invalid spot user-data payload");
+  }
+  const eventType = raw.e;
+  if (eventType === "executionReport") return SpotExecutionReportSchema.parse(raw);
+  if (eventType === "outboundAccountPosition") return SpotOutboundAccountPositionSchema.parse(raw);
+  if (eventType === "balanceUpdate") return SpotBalanceUpdateSchema.parse(raw);
+  if (eventType === "listStatus") return SpotListStatusSchema.parse(raw);
+  throw new Error(`Unknown spot user-data event type: ${eventType}`);
+}
+
+// src/resources/SpotTrading.ts
+var SpotTrading = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async createOrder(params) {
+    return SpotOrderSchema.parse(await this.http.post("/order", params, "signed"));
+  }
+  async testOrder(params) {
+    return this.http.post("/order/test", params, "signed");
+  }
+  async getOrder(symbol3, options) {
+    return SpotOrderSchema.parse(
+      await this.http.get("/order", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async cancelOrder(symbol3, options) {
+    return SpotOrderSchema.parse(
+      await this.http.delete("/order", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async cancelOpenOrders(symbol3) {
+    return SpotOrdersResponseSchema.parse(
+      await this.http.delete("/openOrders", { symbol: symbol3 }, "signed")
+    );
+  }
+  async getOpenOrders(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return SpotOrdersResponseSchema.parse(await this.http.get("/openOrders", params, "signed"));
+  }
+  async getAllOrders(symbol3, options) {
+    return SpotOrdersResponseSchema.parse(
+      await this.http.get("/allOrders", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async cancelReplaceOrder(params) {
+    return this.http.post("/order/cancelReplace", params, "signed");
+  }
+  // ---- OCO order lists ----
+  async createOCOOrder(params) {
+    return SpotOCOOrderAckResponseSchema.parse(
+      await this.http.post("/orderList", params, "signed")
+    );
+  }
+  async cancelOCOOrder(symbol3, options) {
+    return SpotOCOOrderAckResponseSchema.parse(
+      await this.http.delete("/orderList", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async getOCOOrder(symbol3, options) {
+    return SpotOCOOrderAckResponseSchema.parse(
+      await this.http.get("/orderList", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async getOpenOCOOrders() {
+    return SpotOCOOrdersResponseSchema.parse(
+      await this.http.get("/openOrderLists", void 0, "signed")
+    );
+  }
+  async getAllOCOOrders(symbol3, options) {
+    return SpotOCOOrdersResponseSchema.parse(
+      await this.http.get("/allOrderLists", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async cancelOpenOCOOrders(symbol3) {
+    return SpotOCOOrdersResponseSchema.parse(
+      await this.http.delete("/openOrderLists", { symbol: symbol3 }, "signed")
+    );
+  }
+};
+var SpotAccount = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async account() {
+    return SpotAccountSchema.parse(await this.http.get("/account", void 0, "signed"));
+  }
+  async myTrades(symbol3, options) {
+    return SpotTradesResponseSchema.parse(
+      await this.http.get("/myTrades", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async myPreventedMatches(symbol3, options) {
+    return this.http.get("/myPreventedMatches", { symbol: symbol3, ...options }, "signed");
+  }
+  async accountCommission(symbol3) {
+    return this.http.get("/account/commission", { symbol: symbol3 }, "signed");
+  }
+  async rateLimitOrder() {
+    return this.http.get("/rateLimit/order", void 0, "signed");
+  }
+};
+
+// src/types/userdata.types.ts
+import { z as z4 } from "zod";
+var ListenKeySchema = z4.object({
+  listenKey: z4.string()
+});
+var UserDataAccountUpdateSchema = z4.object({
+  e: z4.literal("ACCOUNT_UPDATE"),
+  E: z4.number(),
+  T: z4.number(),
+  a: z4.object({
+    m: z4.string().transform(Number),
+    B: z4.array(
+      z4.object({
+        a: z4.string(),
+        wb: z4.string().transform(Number),
+        cw: z4.string().transform(Number),
+        bc: z4.string().transform(Number)
+      })
+    ),
+    P: z4.array(
+      z4.object({
+        s: z4.string(),
+        pa: z4.string().transform(Number),
+        ep: z4.string().transform(Number),
+        cr: z4.string().transform(Number),
+        up: z4.string().transform(Number),
+        mt: z4.string(),
+        iw: z4.string().transform(Number).optional(),
+        ps: z4.string()
+      })
+    )
+  })
+});
+var UserDataOrderTradeUpdateSchema = z4.object({
+  e: z4.literal("ORDER_TRADE_UPDATE"),
+  E: z4.number(),
+  T: z4.number(),
+  o: z4.object({
+    s: z4.string(),
+    c: z4.string(),
+    i: z4.number(),
+    S: z4.string(),
+    o: z4.string(),
+    f: z4.string(),
+    q: z4.string().transform(Number),
+    p: z4.string().transform(Number),
+    ap: z4.string().transform(Number),
+    sp: z4.string().transform(Number),
+    x: z4.string(),
+    X: z4.string(),
+    l: z4.string().transform(Number),
+    z: z4.string().transform(Number),
+    L: z4.string().transform(Number),
+    n: z4.string().transform(Number),
+    N: z4.string(),
+    T: z4.number(),
+    t: z4.number(),
+    b: z4.string().transform(Number),
+    a: z4.string().transform(Number),
+    m: z4.boolean(),
+    R: z4.boolean(),
+    wt: z4.string(),
+    ot: z4.string(),
+    ps: z4.string(),
+    cp: z4.boolean().optional(),
+    AP: z4.string().transform(Number).optional(),
+    cr: z4.string().transform(Number).optional(),
+    rp: z4.string().transform(Number).optional()
+  })
+});
+var UserDataMarginCallSchema = z4.object({
+  e: z4.literal("MARGIN_CALL"),
+  E: z4.number(),
+  cw: z4.string().transform(Number),
+  p: z4.array(
+    z4.object({
+      s: z4.string(),
+      ps: z4.string(),
+      pa: z4.string().transform(Number),
+      mt: z4.string(),
+      iw: z4.string().transform(Number),
+      mp: z4.string().transform(Number),
+      up: z4.string().transform(Number),
+      mm: z4.string().transform(Number)
+    })
+  )
+});
+function parseUserDataEvent(raw) {
+  if (typeof raw !== "object" || raw === null) {
+    throw new Error("Invalid user-data payload");
+  }
+  const eventType = raw.e;
+  if (eventType === "ACCOUNT_UPDATE") return UserDataAccountUpdateSchema.parse(raw);
+  if (eventType === "ORDER_TRADE_UPDATE") return UserDataOrderTradeUpdateSchema.parse(raw);
+  if (eventType === "MARGIN_CALL") return UserDataMarginCallSchema.parse(raw);
+  throw new Error(`Unknown user-data event type: ${eventType}`);
+}
+var WsApiResponseSchema = z4.object({
+  id: z4.string(),
+  status: z4.number(),
+  result: z4.unknown(),
+  error: z4.object({
+    code: z4.number(),
+    msg: z4.string()
+  }).optional()
+});
+
+// src/resources/SpotUserDataStream.ts
+var SpotUserDataStream = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async createListenKey() {
+    return ListenKeySchema.parse(await this.http.post("/userDataStream", void 0, "apiKey"));
+  }
+  async keepAliveListenKey() {
+    return this.http.put("/userDataStream", void 0, "apiKey");
+  }
+  async closeListenKey() {
+    return this.http.delete("/userDataStream", void 0, "apiKey");
+  }
+};
+
+// src/types/account.types.ts
+import { z as z5 } from "zod";
+var BalanceSchema = z5.object({
+  accountAlias: z5.string(),
+  asset: z5.string(),
+  balance: z5.string().transform(Number),
+  crossWalletBalance: z5.string().transform(Number),
+  crossUnPnl: z5.string().transform(Number),
+  availableBalance: z5.string().transform(Number),
+  maxWithdrawAmount: z5.string().transform(Number),
+  marginAvailable: z5.boolean(),
+  updateTime: z5.number()
+});
+var BalancesResponseSchema = z5.array(BalanceSchema);
+var PositionRiskSchema = z5.object({
+  symbol: z5.string(),
+  positionAmt: z5.string().transform(Number),
+  entryPrice: z5.string().transform(Number),
+  markPrice: z5.string().transform(Number),
+  unRealizedProfit: z5.string().transform(Number),
+  liquidationPrice: z5.string().transform(Number),
+  leverage: z5.string().transform(Number),
+  marginType: z5.enum(["isolated", "cross"]),
+  positionSide: z5.string(),
+  isolatedWallet: z5.string().transform(Number).optional(),
+  isolatedMargin: z5.string().transform(Number).optional(),
+  notional: z5.string().transform(Number),
+  updateTime: z5.number().optional()
+});
+var PositionRiskResponseSchema = z5.array(PositionRiskSchema);
+var AccountAssetSchema = z5.object({
+  asset: z5.string(),
+  walletBalance: z5.string().transform(Number),
+  unrealizedProfit: z5.string().transform(Number),
+  marginBalance: z5.string().transform(Number),
+  maintMargin: z5.string().transform(Number),
+  initialMargin: z5.string().transform(Number),
+  positionInitialMargin: z5.string().transform(Number),
+  openOrderInitialMargin: z5.string().transform(Number),
+  crossWalletBalance: z5.string().transform(Number),
+  crossUnPnl: z5.string().transform(Number),
+  availableBalance: z5.string().transform(Number),
+  maxWithdrawAmount: z5.string().transform(Number),
+  marginAvailable: z5.boolean().optional(),
+  updateTime: z5.number()
+});
+var AccountPositionSchema = z5.object({
+  symbol: z5.string(),
+  positionAmt: z5.string().transform(Number),
+  initialMargin: z5.string().transform(Number),
+  maintMargin: z5.string().transform(Number),
+  unrealizedProfit: z5.string().transform(Number),
+  positionInitialMargin: z5.string().transform(Number),
+  openOrderInitialMargin: z5.string().transform(Number),
+  leverage: z5.string().transform(Number),
+  isolated: z5.boolean(),
+  entryPrice: z5.string().transform(Number),
+  positionSide: z5.string(),
+  positionNotional: z5.string().transform(Number),
+  isolatedWallet: z5.string().transform(Number).optional(),
+  isolatedMargin: z5.string().transform(Number).optional(),
+  notional: z5.string().transform(Number).optional()
+});
+var AccountSchema = z5.object({
+  feeTier: z5.number(),
+  canTrade: z5.boolean(),
+  canDeposit: z5.boolean(),
+  canWithdraw: z5.boolean(),
+  updateTime: z5.number(),
+  totalInitialMargin: z5.string().transform(Number),
+  totalMaintMargin: z5.string().transform(Number),
+  totalWalletBalance: z5.string().transform(Number),
+  totalUnrealizedProfit: z5.string().transform(Number),
+  totalMarginBalance: z5.string().transform(Number),
+  totalPositionInitialMargin: z5.string().transform(Number),
+  totalOpenOrderInitialMargin: z5.string().transform(Number),
+  totalCrossWalletBalance: z5.string().transform(Number),
+  totalCrossUnPnl: z5.string().transform(Number),
+  availableBalance: z5.string().transform(Number),
+  maxWithdrawAmount: z5.string().transform(Number),
+  assets: z5.array(AccountAssetSchema),
+  positions: z5.array(AccountPositionSchema)
+});
+var IncomeSchema = z5.object({
+  symbol: z5.string().optional(),
+  incomeType: z5.string(),
+  income: z5.string().transform(Number),
+  asset: z5.string(),
+  time: z5.number(),
+  info: z5.string().optional(),
+  tranId: z5.number(),
+  tradeId: z5.string().optional()
+});
+var IncomeHistoryResponseSchema = z5.array(IncomeSchema);
+var UserTradeSchema = z5.object({
+  buyer: z5.boolean(),
+  commission: z5.string().transform(Number),
+  commissionAsset: z5.string(),
+  id: z5.number(),
+  maker: z5.boolean(),
+  orderId: z5.number(),
+  price: z5.string().transform(Number),
+  qty: z5.string().transform(Number),
+  quoteQty: z5.string().transform(Number),
+  realizedPnl: z5.string().transform(Number),
+  side: z5.string(),
+  positionSide: z5.string(),
+  symbol: z5.string(),
+  time: z5.number()
+});
+var UserTradesResponseSchema = z5.array(UserTradeSchema);
+var CommissionRateSchema = z5.object({
+  symbol: z5.string(),
+  makerCommissionRate: z5.string().transform(Number),
+  takerCommissionRate: z5.string().transform(Number)
+});
+var LeverageBracketSchema = z5.object({
+  symbol: z5.string().optional(),
+  bracketNotional: z5.string().transform(Number).optional(),
+  bracket: z5.number().optional(),
+  maxLeverage: z5.number().optional(),
+  maintMarginRatio: z5.string().transform(Number).optional(),
+  cum: z5.string().transform(Number).optional()
+});
+var LeverageBracketResponseSchema = z5.array(
+  z5.object({
+    symbol: z5.string(),
+    brackets: z5.array(LeverageBracketSchema)
+  })
+);
+var PositionModeSchema = z5.object({
+  dualSidePosition: z5.boolean()
+});
+var MultiAssetsMarginSchema = z5.object({
+  multiAssetsMargin: z5.boolean()
+});
+var FeeBurnStatusSchema = z5.object({
+  feeBurn: z5.boolean()
+});
+var PositionMarginHistoryEntrySchema = z5.object({
+  amount: z5.string().transform(Number),
+  asset: z5.string(),
+  symbol: z5.string(),
+  time: z5.number(),
+  type: z5.number(),
+  positionSide: z5.string()
+});
+var PositionMarginHistorySchema = z5.array(PositionMarginHistoryEntrySchema);
+var ApiTradingStatusSchema = z5.object({
+  isLocked: z5.boolean(),
+  plannedRecoverTime: z5.number(),
+  updateTime: z5.number(),
+  triggerCondition: z5.record(z5.string(), z5.number()).optional(),
+  indicators: z5.record(z5.string(), z5.unknown()).optional()
+});
+var RateLimitOrderSchema = z5.object({
+  rateLimitType: z5.string(),
+  interval: z5.string(),
+  intervalNum: z5.number(),
+  limit: z5.number(),
+  count: z5.number()
+});
+var RateLimitOrderResponseSchema = z5.array(RateLimitOrderSchema);
+
+// src/resources/FuturesAccount.ts
+var FuturesAccount = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async balance() {
+    return BalancesResponseSchema.parse(await this.http.get("/fapi/v2/balance", void 0, "signed"));
+  }
+  async account() {
+    return AccountSchema.parse(await this.http.get("/fapi/v2/account", void 0, "signed"));
+  }
+  async positionRisk(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return PositionRiskResponseSchema.parse(await this.http.get("/fapi/v2/positionRisk", params, "signed"));
+  }
+  async balanceV3() {
+    return BalancesResponseSchema.parse(await this.http.get("/fapi/v3/balance", void 0, "signed"));
+  }
+  async accountV3() {
+    return AccountSchema.parse(await this.http.get("/fapi/v3/account", void 0, "signed"));
+  }
+  async positionRiskV3(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return PositionRiskResponseSchema.parse(await this.http.get("/fapi/v3/positionRisk", params, "signed"));
+  }
+  async incomeHistory(options) {
+    const params = {
+      symbol: options?.symbol,
+      incomeType: options?.incomeType,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit
+    };
+    return IncomeHistoryResponseSchema.parse(await this.http.get("/fapi/v1/income", params, "signed"));
+  }
+  async userTrades(options) {
+    const params = {
+      symbol: options?.symbol,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit,
+      fromId: options?.fromId
+    };
+    return UserTradesResponseSchema.parse(await this.http.get("/fapi/v1/userTrades", params, "signed"));
+  }
+  async leverageBrackets(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return LeverageBracketResponseSchema.parse(await this.http.get("/fapi/v1/leverageBracket", params, "signed"));
+  }
+  async commissionRate(symbol3) {
+    return CommissionRateSchema.parse(await this.http.get("/fapi/v1/commissionRate", { symbol: symbol3 }, "signed"));
+  }
+  async multiAssetsMargin() {
+    return MultiAssetsMarginSchema.parse(await this.http.get("/fapi/v1/multiAssetsMargin", void 0, "signed"));
+  }
+  async setMultiAssetsMargin(multiAssetsMargin) {
+    return this.http.post("/fapi/v1/multiAssetsMargin", { multiAssetsMargin }, "signed");
+  }
+  async feeBurnStatus() {
+    return FeeBurnStatusSchema.parse(await this.http.get("/fapi/v1/feeBurn", void 0, "signed"));
+  }
+  async setFeeBurnStatus(feeBurn) {
+    return this.http.post("/fapi/v1/feeBurn", { feeBurn }, "signed");
+  }
+  async positionMode() {
+    return PositionModeSchema.parse(await this.http.get("/fapi/v1/positionSide/dual", void 0, "signed"));
+  }
+  async setPositionMode(dualSidePosition) {
+    return this.http.post("/fapi/v1/positionSide/dual", { dualSidePosition }, "signed");
+  }
+  async apiTradingStatus() {
+    return ApiTradingStatusSchema.parse(await this.http.get("/fapi/v1/apiTradingStatus", void 0, "signed"));
+  }
+  async positionMarginHistory(options) {
+    const params = {
+      symbol: options?.symbol,
+      type: options?.type,
+      startTime: options?.startTime,
+      endTime: options?.endTime,
+      limit: options?.limit
+    };
+    return PositionMarginHistorySchema.parse(await this.http.get("/fapi/v1/positionMargin/history", params, "signed"));
+  }
+  async rateLimitOrder() {
+    return RateLimitOrderResponseSchema.parse(await this.http.get("/fapi/v1/rateLimit/order", void 0, "signed"));
+  }
+  async accountConfig() {
+    return this.http.get("/fapi/v1/accountConfig", void 0, "signed");
+  }
+  async pmAccountInfo(asset) {
+    return this.http.get("/fapi/v1/pmAccountInfo", { asset }, "signed");
+  }
+  async requestIncomeDownload(options) {
+    return this.http.get("/fapi/v1/income/asyn", options, "signed");
+  }
+  async getIncomeDownloadStatus(downloadId) {
+    return this.http.get("/fapi/v1/income/asyn/id", { downloadId }, "signed");
+  }
+  async requestOrderDownload(options) {
+    const params = {
+      symbol: options?.symbol,
+      startTime: options?.startTime,
+      endTime: options?.endTime
+    };
+    return this.http.get("/fapi/v1/order/asyn", params, "signed");
+  }
+  async getOrderDownloadStatus(downloadId) {
+    return this.http.get("/fapi/v1/order/asyn/id", { downloadId }, "signed");
+  }
+  async requestTradeDownload(options) {
+    const params = {
+      symbol: options?.symbol,
+      startTime: options?.startTime,
+      endTime: options?.endTime
+    };
+    return this.http.get("/fapi/v1/trade/asyn", params, "signed");
+  }
+  async getTradeDownloadStatus(downloadId) {
+    return this.http.get("/fapi/v1/trade/asyn/id", { downloadId }, "signed");
+  }
+};
+
+// src/types/trading.types.ts
+import { z as z6 } from "zod";
+var OrderSchema = z6.object({
+  orderId: z6.number(),
+  symbol: z6.string(),
+  status: z6.string(),
+  clientOrderId: z6.string(),
+  price: z6.string().transform(Number),
+  avgPrice: z6.string().transform(Number),
+  origQty: z6.string().transform(Number),
+  executedQty: z6.string().transform(Number),
+  cumQuote: z6.string().transform(Number),
+  type: z6.string(),
+  reduceOnly: z6.boolean(),
+  side: z6.string(),
+  positionSide: z6.string(),
+  stopPrice: z6.string().transform(Number).optional(),
+  closePosition: z6.boolean().optional(),
+  timeInForce: z6.string().optional(),
+  origType: z6.string().optional(),
+  time: z6.number(),
+  updateTime: z6.number(),
+  workingType: z6.string().optional(),
+  priceProtect: z6.boolean().optional()
+});
+var OrderResponseSchema = OrderSchema;
+var OrdersResponseSchema = z6.array(OrderSchema);
+var CreateOrderParamsSchema = z6.object({
+  symbol: z6.string(),
+  side: z6.enum(["BUY", "SELL"]),
+  type: z6.string(),
+  quantity: z6.union([z6.string(), z6.number()]).optional(),
+  price: z6.union([z6.string(), z6.number()]).optional(),
+  timeInForce: z6.enum(["GTC", "IOC", "FOK", "GTX", "GTD"]).optional(),
+  stopPrice: z6.union([z6.string(), z6.number()]).optional(),
+  reduceOnly: z6.boolean().optional(),
+  positionSide: z6.enum(["BOTH", "LONG", "SHORT"]).optional(),
+  newClientOrderId: z6.string().optional(),
+  closePosition: z6.boolean().optional(),
+  newOrderRespType: z6.enum(["ACK", "RESULT"]).optional(),
+  priceProtect: z6.boolean().optional(),
+  workingType: z6.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional(),
+  callbackRate: z6.union([z6.string(), z6.number()]).optional(),
+  activationPrice: z6.union([z6.string(), z6.number()]).optional(),
+  selfTradePreventionMode: z6.enum(["NONE", "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"]).optional(),
+  goodTillDate: z6.number().optional()
+});
+var ModifyOrderParamsSchema = CreateOrderParamsSchema.extend({
+  orderId: z6.number().optional(),
+  origClientOrderId: z6.string().optional(),
+  origType: z6.string().optional()
+});
+var AlgoOrderSchema = z6.object({
+  algoId: z6.number(),
+  symbol: z6.string(),
+  side: z6.string(),
+  positionSide: z6.string(),
+  totalQty: z6.string().transform(Number).optional(),
+  executedQty: z6.string().transform(Number).optional(),
+  executedAmt: z6.string().transform(Number).optional(),
+  avgPrice: z6.string().transform(Number).optional(),
+  clientAlgoId: z6.string().optional(),
+  bookTime: z6.number().optional(),
+  endTime: z6.number().optional(),
+  algoStatus: z6.string().optional(),
+  algoType: z6.string().optional(),
+  urgency: z6.string().optional()
+});
+var AlgoOrderResponseSchema = AlgoOrderSchema;
+var AlgoOrdersResponseSchema = z6.array(AlgoOrderSchema);
+var BatchOrdersItemSchema = z6.object({
+  orderId: z6.number(),
+  symbol: z6.string(),
+  status: z6.string(),
+  clientOrderId: z6.string(),
+  price: z6.string().transform(Number),
+  avgPrice: z6.string().transform(Number),
+  origQty: z6.string().transform(Number),
+  executedQty: z6.string().transform(Number),
+  cumQuote: z6.string().transform(Number),
+  type: z6.string(),
+  reduceOnly: z6.boolean(),
+  side: z6.string(),
+  positionSide: z6.string(),
+  time: z6.number(),
+  updateTime: z6.number()
+});
+var BatchOrdersResponseSchema = z6.array(BatchOrdersItemSchema);
+var OrderModifyHistoryEntrySchema = z6.object({
+  orderId: z6.number(),
+  symbol: z6.string(),
+  status: z6.string(),
+  clientOrderId: z6.string(),
+  price: z6.string().transform(Number),
+  avgPrice: z6.string().transform(Number),
+  origQty: z6.string().transform(Number),
+  executedQty: z6.string().transform(Number),
+  cumQuote: z6.string().transform(Number),
+  type: z6.string(),
+  reduceOnly: z6.boolean(),
+  side: z6.string(),
+  positionSide: z6.string(),
+  origType: z6.string().optional(),
+  stopPrice: z6.string().transform(Number).optional(),
+  updateTime: z6.number()
+});
+var OrderModifyHistorySchema = z6.array(OrderModifyHistoryEntrySchema);
+var LeverageChangeSchema = z6.object({
+  leverage: z6.number(),
+  maxNotionalValue: z6.union([z6.string(), z6.number()]),
+  symbol: z6.string()
+});
+var MarginTypeChangeSchema = z6.object({
+  code: z6.number(),
+  msg: z6.string()
+});
+var PositionMarginChangeSchema = z6.object({
+  amount: z6.number(),
+  code: z6.number(),
+  msg: z6.string(),
+  type: z6.number()
+});
+var CountdownCancelAllSchema = z6.object({
+  symbol: z6.string(),
+  countdownTime: z6.number()
+});
+var NewOrderAckSchema = z6.object({
+  orderId: z6.number(),
+  symbol: z6.string(),
+  status: z6.string(),
+  clientOrderId: z6.string(),
+  price: z6.string(),
+  avgPrice: z6.string(),
+  origQty: z6.string(),
+  executedQty: z6.string(),
+  cumQuote: z6.string(),
+  type: z6.string(),
+  reduceOnly: z6.boolean(),
+  side: z6.string(),
+  positionSide: z6.string(),
+  timeInForce: z6.string().optional(),
+  time: z6.number(),
+  updateTime: z6.number(),
+  workingType: z6.string().optional(),
+  origType: z6.string().optional(),
+  closePosition: z6.boolean().optional()
+});
+
+// src/resources/FuturesTrading.ts
+var FuturesTrading = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async setLeverage(symbol3, leverage) {
+    return LeverageChangeSchema.parse(
+      await this.http.post("/fapi/v1/leverage", { symbol: symbol3, leverage }, "signed")
+    );
+  }
+  async createOrder(params) {
+    return NewOrderAckSchema.parse(await this.http.post("/fapi/v1/order", params, "signed"));
+  }
+  async createTestOrder(params) {
+    return this.http.post("/fapi/v1/order/test", params, "signed");
+  }
+  async getOrder(symbol3, options) {
+    return OrderResponseSchema.parse(
+      await this.http.get("/fapi/v1/order", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async cancelOrder(symbol3, options) {
+    return OrderResponseSchema.parse(
+      await this.http.delete("/fapi/v1/order", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async getCurrentOrder(symbol3, options) {
+    return OrderResponseSchema.parse(
+      await this.http.get("/fapi/v1/openOrder", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async getOpenOrders(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return OrdersResponseSchema.parse(await this.http.get("/fapi/v1/openOrders", params, "signed"));
+  }
+  async getAllOrders(symbol3, options) {
+    return OrdersResponseSchema.parse(
+      await this.http.get("/fapi/v1/allOrders", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async cancelAllOpenOrders(symbol3) {
+    return this.http.delete("/fapi/v1/allOpenOrders", { symbol: symbol3 }, "signed");
+  }
+  async modifyOrder(params) {
+    return OrderResponseSchema.parse(await this.http.put("/fapi/v1/order", params, "signed"));
+  }
+  async createAlgoOrder(params) {
+    return AlgoOrderResponseSchema.parse(await this.http.post("/fapi/v1/algoOrder", params, "signed"));
+  }
+  async cancelAlgoOrder(symbol3, options) {
+    return this.http.delete("/fapi/v1/algoOrder", { symbol: symbol3, ...options }, "signed");
+  }
+  async cancelAllOpenAlgoOrders(symbol3) {
+    return this.http.delete("/fapi/v1/algoOpenOrders", { symbol: symbol3 }, "signed");
+  }
+  async getAlgoOrder(symbol3, options) {
+    return AlgoOrderResponseSchema.parse(
+      await this.http.get("/fapi/v1/algoOrder", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async getOpenAlgoOrders(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : {};
+    return AlgoOrdersResponseSchema.parse(await this.http.get("/fapi/v1/openAlgoOrders", params, "signed"));
+  }
+  async getAllAlgoOrders(symbol3, options) {
+    return AlgoOrdersResponseSchema.parse(
+      await this.http.get("/fapi/v1/allAlgoOrders", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async createBatchOrders(batchOrders) {
+    return BatchOrdersResponseSchema.parse(
+      await this.http.post("/fapi/v1/batchOrders", { batchOrders: JSON.stringify(batchOrders) }, "signed")
+    );
+  }
+  async modifyBatchOrders(batchOrders) {
+    return BatchOrdersResponseSchema.parse(
+      await this.http.put("/fapi/v1/batchOrders", { batchOrders: JSON.stringify(batchOrders) }, "signed")
+    );
+  }
+  async cancelBatchOrders(symbol3, options) {
+    const params = { symbol: symbol3 };
+    if (options?.orderIdList?.length) params.orderIdList = JSON.stringify(options.orderIdList);
+    if (options?.origClientOrderIdList?.length) {
+      params.origClientOrderIdList = JSON.stringify(options.origClientOrderIdList);
+    }
+    return BatchOrdersResponseSchema.parse(await this.http.delete("/fapi/v1/batchOrders", params, "signed"));
+  }
+  async getOrderModifyHistory(symbol3, options) {
+    return OrderModifyHistorySchema.parse(
+      await this.http.get("/fapi/v1/orderAmendment", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async setMarginType(symbol3, marginType) {
+    return MarginTypeChangeSchema.parse(
+      await this.http.post("/fapi/v1/marginType", { symbol: symbol3, marginType }, "signed")
+    );
+  }
+  async modifyPositionMargin(symbol3, amount, type) {
+    return PositionMarginChangeSchema.parse(
+      await this.http.post("/fapi/v1/positionMargin", { symbol: symbol3, amount, type }, "signed")
+    );
+  }
+  async setCountdownCancelAll(symbol3, countdownTime) {
+    return CountdownCancelAllSchema.parse(
+      await this.http.post("/fapi/v1/countdownCancelAll", { symbol: symbol3, countdownTime }, "signed")
+    );
+  }
+  async convertExchangeInfo(options) {
+    return this.http.get("/fapi/v1/convert/exchangeInfo", options);
+  }
+  async convertGetQuote(params) {
+    return this.http.post("/fapi/v1/convert/getQuote", params, "signed");
+  }
+  async convertAcceptQuote(quoteId) {
+    return this.http.post("/fapi/v1/convert/acceptQuote", { quoteId }, "signed");
+  }
+  async convertOrderStatus(options) {
+    return this.http.get("/fapi/v1/convert/orderStatus", options, "signed");
+  }
+};
+
+// src/types/filters.types.ts
+function filtersOf(symbol3) {
+  const raw = symbol3.filters;
+  return Array.isArray(raw) ? raw : [];
+}
+function filterOf(symbol3, filterType) {
+  return filtersOf(symbol3).find((f) => f.filterType === filterType);
+}
+function num(value, fallback) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+function stepDecimals(step) {
+  const text = typeof step === "number" ? step.toFixed(12) : String(step).trim();
+  const dot = text.indexOf(".");
+  if (dot === -1) return 0;
+  return text.slice(dot + 1).replace(/0+$/, "").length;
+}
+function formatToDecimals(value, decimals) {
+  return value.toFixed(decimals);
+}
+function floorToStep(value, step, decimals = stepDecimals(step)) {
+  if (!(step > 0)) return value;
+  const steps = Math.floor(value / step + 1e-9);
+  return Number((steps * step).toFixed(decimals));
+}
+function roundToStep(value, step, decimals = stepDecimals(step)) {
+  if (!(step > 0)) return value;
+  const steps = Math.round(value / step);
+  return Number((steps * step).toFixed(decimals));
+}
+function symbolRulesFrom(symbol3) {
+  const raw = symbol3;
+  const price = filterOf(symbol3, "PRICE_FILTER");
+  const lot = filterOf(symbol3, "LOT_SIZE");
+  const marketLot = filterOf(symbol3, "MARKET_LOT_SIZE");
+  const notional = filterOf(symbol3, "MIN_NOTIONAL");
+  const tickSizeRaw = price?.tickSize ?? 10 ** -num(raw.pricePrecision, 2);
+  const stepSizeRaw = lot?.stepSize ?? 10 ** -num(raw.quantityPrecision, 3);
+  const marketStepRaw = marketLot?.stepSize ?? stepSizeRaw;
+  return {
+    symbol: symbol3.symbol,
+    status: symbol3.status,
+    baseAsset: symbol3.baseAsset,
+    quoteAsset: symbol3.quoteAsset,
+    tickSize: num(tickSizeRaw, 0.01),
+    tickDecimals: stepDecimals(tickSizeRaw),
+    stepSize: num(stepSizeRaw, 1e-3),
+    stepDecimals: stepDecimals(stepSizeRaw),
+    minQty: num(lot?.minQty, 0),
+    maxQty: num(lot?.maxQty, Number.POSITIVE_INFINITY),
+    marketStepSize: num(marketStepRaw, 1e-3),
+    marketStepDecimals: stepDecimals(marketStepRaw),
+    marketMinQty: num(marketLot?.minQty, num(lot?.minQty, 0)),
+    marketMaxQty: num(marketLot?.maxQty, num(lot?.maxQty, Number.POSITIVE_INFINITY)),
+    minNotional: num(notional?.notional, 0)
+  };
+}
+
+// src/resources/FuturesOps.ts
+var RULES_TTL_MS = 6e4;
+var FuturesOps = class {
+  constructor(market, data, account, trading) {
+    this.market = market;
+    this.data = data;
+    this.account = account;
+    this.trading = trading;
+    this.rulesCache = /* @__PURE__ */ new Map();
+  }
+  /** Typed tick/step/notional rules for a symbol, cached briefly (exchangeInfo is a large payload). */
+  async symbolRules(symbol3, options) {
+    const key = symbol3.toUpperCase();
+    const cached = this.rulesCache.get(key);
+    if (!options?.refresh && cached && Date.now() - cached.at < RULES_TTL_MS) return cached.rules;
+    const details = await this.market.instrumentDetails(key);
+    const rules = symbolRulesFrom(details);
+    this.rulesCache.set(key, { rules, at: Date.now() });
+    return rules;
+  }
+  /** Round a price to the symbol's tick and a quantity to its step, ready to send. */
+  async quantize(symbol3, values) {
+    const rules = await this.symbolRules(symbol3);
+    const step = values.marketOrder ? rules.marketStepSize : rules.stepSize;
+    const stepDp = values.marketOrder ? rules.marketStepDecimals : rules.stepDecimals;
+    return {
+      price: values.price === void 0 ? void 0 : formatToDecimals(roundToStep(values.price, rules.tickSize, rules.tickDecimals), rules.tickDecimals),
+      quantity: values.quantity === void 0 ? void 0 : formatToDecimals(floorToStep(values.quantity, step, stepDp), stepDp),
+      rules
+    };
+  }
+  /**
+   * Risk-based position sizing. Converts "risk N quote units between entry and stop"
+   * into a quantity that satisfies the symbol's step size, lot bounds and min notional,
+   * and reports every constraint it could not satisfy instead of silently adjusting risk.
+   */
+  async sizePosition(params) {
+    const symbol3 = params.symbol.toUpperCase();
+    const reasons = [];
+    if (params.riskAmount === void 0 === (params.riskPct === void 0)) {
+      throw new Error("Provide exactly one of riskAmount or riskPct");
+    }
+    const rules = await this.symbolRules(symbol3);
+    const entryPrice = params.entryPrice ?? (await this.data.premiumIndex(symbol3)).markPrice;
+    let availableBalance;
+    let riskAmount = params.riskAmount ?? 0;
+    if (params.riskPct !== void 0) {
+      const balances = await this.account.balanceV3();
+      availableBalance = balances.find((b) => b.asset === rules.quoteAsset)?.availableBalance ?? 0;
+      riskAmount = availableBalance * (params.riskPct / 100);
+    }
+    const riskPerUnit = Math.abs(entryPrice - params.stopPrice);
+    const stopOnCorrectSide = params.side === "BUY" ? params.stopPrice < entryPrice : params.stopPrice > entryPrice;
+    if (!stopOnCorrectSide) {
+      reasons.push(
+        `stopPrice ${params.stopPrice} is on the wrong side of entry ${entryPrice} for a ${params.side}`
+      );
+    }
+    if (riskPerUnit <= 0) reasons.push("stopPrice equals entryPrice, risk per unit is zero");
+    const step = params.marketOrder ? rules.marketStepSize : rules.stepSize;
+    const stepDp = params.marketOrder ? rules.marketStepDecimals : rules.stepDecimals;
+    const minQty = params.marketOrder ? rules.marketMinQty : rules.minQty;
+    const maxQty = params.marketOrder ? rules.marketMaxQty : rules.maxQty;
+    const rawQuantity = riskPerUnit > 0 ? riskAmount / riskPerUnit : 0;
+    let quantity = floorToStep(rawQuantity, step, stepDp);
+    if (quantity > maxQty) {
+      reasons.push(`quantity ${quantity} exceeds maxQty ${maxQty}, clamped`);
+      quantity = floorToStep(maxQty, step, stepDp);
+    }
+    if (quantity < minQty) {
+      reasons.push(`quantity ${quantity} is below minQty ${minQty} for this symbol`);
+    }
+    const notional = quantity * entryPrice;
+    if (rules.minNotional > 0 && notional < rules.minNotional) {
+      reasons.push(
+        `notional ${notional.toFixed(2)} is below the ${rules.minNotional} minimum; raising risk or widening the stop is required (this tool will not increase risk for you)`
+      );
+    }
+    if (rules.status !== "TRADING") reasons.push(`symbol status is ${rules.status}, not TRADING`);
+    const leverage = params.leverage ?? 1;
+    const requiredMargin = notional / leverage;
+    if (availableBalance !== void 0 && requiredMargin > availableBalance) {
+      reasons.push(
+        `required margin ${requiredMargin.toFixed(2)} exceeds available balance ${availableBalance.toFixed(2)}`
+      );
+    }
+    return {
+      ok: reasons.length === 0 && quantity > 0,
+      reasons,
+      symbol: symbol3,
+      side: params.side,
+      entryPrice,
+      stopPrice: params.stopPrice,
+      riskPerUnit,
+      riskAmount,
+      rawQuantity,
+      quantity,
+      quantityStr: formatToDecimals(quantity, stepDp),
+      notional,
+      minNotional: rules.minNotional,
+      leverage,
+      requiredMargin,
+      availableBalance,
+      rules
+    };
+  }
+  /**
+   * Flatten an open position with a reduce-only market order.
+   *
+   * Picks the closing side from the sign of `positionAmt` and, critically, chooses
+   * between `reduceOnly` and `positionSide`: Binance rejects `reduceOnly` in hedge
+   * mode, and rejects a LONG/SHORT `positionSide` in one-way mode.
+   */
+  async closePosition(params) {
+    const symbol3 = params.symbol.toUpperCase();
+    const portion = params.portion ?? 1;
+    if (!(portion > 0 && portion <= 1)) throw new Error("portion must be within (0, 1]");
+    const positions = await this.account.positionRiskV3(symbol3);
+    const open = positions.filter(
+      (p) => p.positionAmt !== 0 && (params.positionSide === void 0 || p.positionSide === params.positionSide)
+    );
+    if (open.length === 0) return { closed: false, reason: `no open position on ${symbol3}` };
+    if (open.length > 1) {
+      return {
+        closed: false,
+        reason: `${open.length} positions open on ${symbol3} (hedge mode); pass positionSide to pick one`
+      };
+    }
+    const position = open[0];
+    const rules = await this.symbolRules(symbol3);
+    const quantity = floorToStep(
+      Math.abs(position.positionAmt) * portion,
+      rules.marketStepSize,
+      rules.marketStepDecimals
+    );
+    if (quantity <= 0) {
+      return { closed: false, reason: "closing quantity rounds to zero at this symbol step size", position };
+    }
+    const hedgeMode = position.positionSide !== "BOTH";
+    const request = {
+      symbol: symbol3,
+      side: position.positionAmt > 0 ? "SELL" : "BUY",
+      type: "MARKET",
+      quantity: formatToDecimals(quantity, rules.marketStepDecimals),
+      ...hedgeMode ? { positionSide: position.positionSide } : { reduceOnly: true }
+    };
+    if (params.dryRun) return { closed: false, reason: "dryRun", position, request };
+    const order = await this.trading.createOrder(request);
+    return { closed: true, position, order, request };
+  }
+  /**
+   * One-call market picture: 24h stats, mark/index and funding, open interest and
+   * positioning. Uses allSettled so a single unavailable feed degrades one field
+   * instead of failing the whole snapshot.
+   */
+  async marketSnapshot(symbol3, options) {
+    const s = symbol3.toUpperCase();
+    const period2 = options?.period ?? "1h";
+    const [ticker, premium, openInterest, longShort] = await Promise.allSettled([
+      this.market.ticker24hr(s),
+      this.data.premiumIndex(s),
+      this.data.openInterest(s),
+      this.data.globalLongShortAccountRatio(s, period2, 1)
+    ]);
+    const settled = (r) => r.status === "fulfilled" ? r.value : { error: String(r.reason) };
+    return {
+      symbol: s,
+      asOf: Date.now(),
+      ticker24hr: settled(ticker),
+      markPrice: settled(premium),
+      openInterest: settled(openInterest),
+      longShortAccountRatio: settled(longShort)
+    };
+  }
+  /** Balances, open positions and working orders in one call, with the noise filtered out. */
+  async accountOverview() {
+    const [balances, positions, openOrders] = await Promise.allSettled([
+      this.account.balanceV3(),
+      this.account.positionRiskV3(),
+      this.trading.getOpenOrders()
+    ]);
+    const fundedBalances = balances.status === "fulfilled" ? balances.value.filter((b) => b.balance !== 0) : [];
+    const openPositions = positions.status === "fulfilled" ? positions.value.filter((p) => p.positionAmt !== 0) : [];
+    return {
+      asOf: Date.now(),
+      balances: balances.status === "fulfilled" ? fundedBalances : { error: String(balances.reason) },
+      positions: positions.status === "fulfilled" ? openPositions : { error: String(positions.reason) },
+      openOrders: openOrders.status === "fulfilled" ? openOrders.value : { error: String(openOrders.reason) },
+      totals: positions.status === "fulfilled" ? {
+        openPositionCount: openPositions.length,
+        unrealizedPnl: openPositions.reduce((sum, p) => sum + p.unRealizedProfit, 0),
+        grossNotional: openPositions.reduce((sum, p) => sum + Math.abs(p.notional), 0)
+      } : void 0
+    };
+  }
+  /**
+   * Entry order plus its protective stop-loss and optional take-profit, with every
+   * price quantized to the symbol tick.
+   *
+   * The protective legs are placed after the entry is accepted. If a protective leg
+   * fails, the failure is reported per-leg rather than unwound: the entry may already
+   * have filled, so cancelling it is not a safe automatic recovery.
+   */
+  async placeBracketOrder(params) {
+    const symbol3 = params.symbol.toUpperCase();
+    const rules = await this.symbolRules(symbol3);
+    const tick = (p) => formatToDecimals(roundToStep(p, rules.tickSize, rules.tickDecimals), rules.tickDecimals);
+    const quantity = formatToDecimals(
+      floorToStep(Number(params.quantity), rules.stepSize, rules.stepDecimals),
+      rules.stepDecimals
+    );
+    if (Number(quantity) <= 0) throw new Error("quantity rounds to zero at this symbol step size");
+    const exitSide = params.side === "BUY" ? "SELL" : "BUY";
+    const hedgeMode = params.positionSide !== void 0 && params.positionSide !== "BOTH";
+    const sideFields = hedgeMode ? { positionSide: params.positionSide } : { reduceOnly: true };
+    const workingType = params.workingType ?? "MARK_PRICE";
+    const entry = await this.trading.createOrder({
+      symbol: symbol3,
+      side: params.side,
+      type: params.entryPrice === void 0 ? "MARKET" : "LIMIT",
+      quantity,
+      ...params.entryPrice === void 0 ? {} : { price: tick(params.entryPrice), timeInForce: "GTC" },
+      ...hedgeMode ? { positionSide: params.positionSide } : {}
+    });
+    const protective = await Promise.allSettled([
+      this.trading.createOrder({
+        symbol: symbol3,
+        side: exitSide,
+        type: "STOP_MARKET",
+        quantity,
+        stopPrice: tick(params.stopLossPrice),
+        workingType,
+        ...sideFields
+      }),
+      ...params.takeProfitPrice === void 0 ? [] : [
+        this.trading.createOrder({
+          symbol: symbol3,
+          side: exitSide,
+          type: "TAKE_PROFIT_MARKET",
+          quantity,
+          stopPrice: tick(params.takeProfitPrice),
+          workingType,
+          ...sideFields
+        })
+      ]
+    ]);
+    const [stopLoss, takeProfit] = protective;
+    const leg = (r) => r === void 0 ? void 0 : r.status === "fulfilled" ? r.value : { error: String(r.reason) };
+    const failures = protective.filter((r) => r.status === "rejected").length;
+    return {
+      symbol: symbol3,
+      quantity,
+      entry,
+      stopLoss: leg(stopLoss),
+      takeProfit: leg(takeProfit),
+      protectionComplete: failures === 0,
+      ...failures > 0 ? {
+        warning: "Entry was submitted but at least one protective order failed. The position may be unprotected \u2014 review and place the missing leg manually."
+      } : {}
+    };
+  }
+};
+
+// src/resources/UserDataStream.ts
+var UserDataStream = class {
+  constructor(http) {
+    this.http = http;
+  }
+  async createListenKey() {
+    return ListenKeySchema.parse(await this.http.post("/fapi/v1/listenKey", void 0, "apiKey"));
+  }
+  async keepAliveListenKey() {
+    return this.http.put("/fapi/v1/listenKey", void 0, "apiKey");
+  }
+  async closeListenKey() {
+    return this.http.delete("/fapi/v1/listenKey", void 0, "apiKey");
+  }
+};
+
+// src/ws/BaseWS.ts
+import { EventEmitter } from "events";
+import WebSocket from "ws";
+
+// src/types/ws.types.ts
+import { z as z7 } from "zod";
+var WsKlinePayloadSchema = z7.object({
+  e: z7.literal("kline"),
+  E: z7.number(),
+  s: z7.string(),
+  k: z7.object({
+    t: z7.number(),
+    T: z7.number(),
+    s: z7.string(),
+    i: z7.string(),
+    o: z7.string().transform(Number),
+    c: z7.string().transform(Number),
+    h: z7.string().transform(Number),
+    l: z7.string().transform(Number),
+    v: z7.string().transform(Number),
+    n: z7.number(),
+    x: z7.boolean(),
+    q: z7.string().transform(Number),
+    V: z7.string().transform(Number),
+    Q: z7.string().transform(Number)
+  })
+});
+var WsAggTradePayloadSchema = z7.object({
+  e: z7.literal("aggTrade"),
+  E: z7.number(),
+  s: z7.string(),
+  a: z7.number(),
+  p: z7.string().transform(Number),
+  q: z7.string().transform(Number),
+  f: z7.number(),
+  l: z7.number(),
+  T: z7.number(),
+  m: z7.boolean()
+});
+var WsTradePayloadSchema = z7.object({
+  e: z7.literal("trade"),
+  E: z7.number(),
+  s: z7.string(),
+  t: z7.number(),
+  p: z7.string().transform(Number),
+  q: z7.string().transform(Number),
+  T: z7.number(),
+  m: z7.boolean()
+});
+var WsDepthUpdatePayloadSchema = z7.object({
+  e: z7.literal("depthUpdate"),
+  E: z7.number(),
+  s: z7.string(),
+  U: z7.number(),
+  u: z7.number(),
+  T: z7.number().optional(),
+  pu: z7.number().optional(),
+  b: z7.array(z7.tuple([z7.string(), z7.string()])),
+  a: z7.array(z7.tuple([z7.string(), z7.string()]))
+});
+var WsTicker24hrPayloadSchema = z7.object({
+  e: z7.literal("24hrTicker"),
+  E: z7.number(),
+  s: z7.string(),
+  p: z7.string().transform(Number),
+  P: z7.string().transform(Number),
+  c: z7.string().transform(Number),
+  o: z7.string().transform(Number),
+  h: z7.string().transform(Number),
+  l: z7.string().transform(Number),
+  v: z7.string().transform(Number),
+  q: z7.string().transform(Number)
+});
+var WsBookTickerPayloadSchema = z7.object({
+  u: z7.number(),
+  s: z7.string(),
+  b: z7.string().transform(Number),
+  B: z7.string().transform(Number),
+  a: z7.string().transform(Number),
+  A: z7.string().transform(Number)
+});
+var WsMarkPricePayloadSchema = z7.object({
+  e: z7.literal("markPriceUpdate"),
+  E: z7.number(),
+  s: z7.string(),
+  p: z7.string().transform(Number),
+  i: z7.string().transform(Number),
+  P: z7.string().transform(Number),
+  r: z7.string().transform(Number),
+  T: z7.number()
+});
+var WsMiniTickerPayloadSchema = z7.object({
+  e: z7.literal("24hrMiniTicker"),
+  E: z7.number(),
+  s: z7.string(),
+  c: z7.string().transform(Number),
+  o: z7.string().transform(Number),
+  h: z7.string().transform(Number),
+  l: z7.string().transform(Number),
+  v: z7.string().transform(Number),
+  q: z7.string().transform(Number)
+});
+var WsForceOrderPayloadSchema = z7.object({
+  e: z7.literal("forceOrder"),
+  E: z7.number(),
+  o: z7.object({
+    s: z7.string(),
+    S: z7.string(),
+    o: z7.string(),
+    f: z7.string(),
+    q: z7.string().transform(Number),
+    p: z7.string().transform(Number),
+    ap: z7.string().transform(Number),
+    X: z7.string(),
+    l: z7.string().transform(Number),
+    z: z7.string().transform(Number),
+    T: z7.number()
+  })
+});
+var WsCompositeIndexPayloadSchema = z7.object({
+  e: z7.literal("compositeIndex"),
+  E: z7.number(),
+  s: z7.string(),
+  p: z7.string().transform(Number),
+  c: z7.array(
+    z7.object({
+      b: z7.string(),
+      q: z7.string(),
+      w: z7.string().transform(Number),
+      p: z7.string().transform(Number)
+    })
+  )
+});
+var WsAssetIndexPayloadSchema = z7.object({
+  e: z7.literal("assetIndex"),
+  E: z7.number(),
+  s: z7.string(),
+  i: z7.string().transform(Number),
+  b: z7.string().transform(Number),
+  a: z7.string().transform(Number)
+});
+var WsRollingWindowTickerPayloadSchema = z7.object({
+  e: z7.enum(["1hTicker", "4hTicker", "1dTicker", "7dTicker", "30dTicker"]),
+  E: z7.number(),
+  s: z7.string(),
+  p: z7.string().transform(Number),
+  P: z7.string().transform(Number),
+  o: z7.string().transform(Number),
+  h: z7.string().transform(Number),
+  l: z7.string().transform(Number),
+  c: z7.string().transform(Number),
+  v: z7.string().transform(Number),
+  q: z7.string().transform(Number),
+  O: z7.number(),
+  C: z7.number()
+});
+var WsSpotAvgPricePayloadSchema = z7.object({
+  e: z7.literal("avgPrice"),
+  E: z7.number(),
+  s: z7.string(),
+  i: z7.string(),
+  w: z7.string().transform(Number),
+  T: z7.number()
+});
+function parseWsPayload(streamName, raw) {
+  if (streamName.includes("@kline_")) return WsKlinePayloadSchema.parse(raw);
+  if (streamName.includes("@continuousKline_") || streamName.includes("@indexPriceKline_") || streamName.includes("@markPriceKline_")) {
+    return WsKlinePayloadSchema.parse(raw);
+  }
+  if (streamName.includes("@aggTrade")) return WsAggTradePayloadSchema.parse(raw);
+  if (streamName.includes("@trade")) return WsTradePayloadSchema.parse(raw);
+  if (streamName.includes("@depth")) return WsDepthUpdatePayloadSchema.parse(raw);
+  if (streamName.includes("@bookTicker")) return WsBookTickerPayloadSchema.parse(raw);
+  if (streamName.includes("@markPrice")) return WsMarkPricePayloadSchema.parse(raw);
+  if (streamName.includes("@miniTicker")) return WsMiniTickerPayloadSchema.parse(raw);
+  if (streamName.includes("@forceOrder")) return WsForceOrderPayloadSchema.parse(raw);
+  if (streamName.includes("@compositeIndex")) return WsCompositeIndexPayloadSchema.parse(raw);
+  if (streamName.includes("@assetIndex")) return WsAssetIndexPayloadSchema.parse(raw);
+  if (streamName.includes("@avgPrice")) return WsSpotAvgPricePayloadSchema.parse(raw);
+  if (streamName.includes("@ticker_")) return WsRollingWindowTickerPayloadSchema.parse(raw);
+  if (streamName.includes("@ticker")) return WsTicker24hrPayloadSchema.parse(raw);
+  throw new Error(`Unknown WS stream type: ${streamName}`);
+}
+
+// src/ws/BaseWS.ts
+var BaseWS = class extends EventEmitter {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.ws = null;
+    this.streams = /* @__PURE__ */ new Set();
+    this.reconnectAttempt = 0;
+    this.closedByUser = false;
+  }
+  subscribe(streams) {
+    streams.forEach((s) => this.streams.add(s));
+    if (this.isOpen()) {
+      this.send({ method: "SUBSCRIBE", params: streams, id: Date.now() });
+    } else {
+      this.connect();
+    }
+  }
+  unsubscribe(streams) {
+    streams.forEach((s) => this.streams.delete(s));
+    if (this.isOpen()) {
+      this.send({ method: "UNSUBSCRIBE", params: streams, id: Date.now() });
+    }
+  }
+  close() {
+    this.closedByUser = true;
+    this.ws?.close();
+  }
+  reconnect() {
+    if (this.ws?.readyState === WebSocket.OPEN) this.ws.close();
+    this.reconnectAttempt = 0;
+    if (!this.closedByUser) this.connect();
+  }
+  resetReconnectAttempts() {
+    this.reconnectAttempt = 0;
+  }
+  isOpen() {
+    return this.ws?.readyState === WebSocket.OPEN;
+  }
+  send(payload) {
+    this.ws?.send(JSON.stringify(payload));
+  }
+  connect() {
+    this.closedByUser = false;
+    const url = `${this.options.baseStreamUrl}?streams=${[...this.streams].join("/")}`;
+    this.ws = new WebSocket(url);
+    this.ws.on("open", () => {
+      this.reconnectAttempt = 0;
+      this.emit("open");
+    });
+    this.ws.on("message", (raw) => {
+      this.handleMessage(raw.toString());
+    });
+    this.ws.on("close", () => {
+      this.emit("close");
+      if (!this.closedByUser) this.scheduleReconnect();
+    });
+    this.ws.on("error", (err) => {
+      if (this.closedByUser) return;
+      this.emit("error", err);
+    });
+  }
+  handleMessage(raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (!parsed.stream || parsed.data === void 0) return;
+    try {
+      const payload = parseWsPayload(parsed.stream, parsed.data);
+      this.emit("message", parsed.stream, payload);
+      this.emit(parsed.stream, payload);
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  scheduleReconnect() {
+    const base = this.options.reconnectDelayMs ?? 1e3;
+    const max = this.options.maxReconnectDelayMs ?? 3e4;
+    const delay = Math.min(base * 2 ** this.reconnectAttempt, max);
+    this.reconnectAttempt += 1;
+    setTimeout(() => {
+      if (!this.closedByUser) this.connect();
+    }, delay);
+  }
+};
+
+// src/ws/FuturesMarketWS.ts
+var FuturesMarketWS = class extends BaseWS {
+  constructor(baseStreamUrl = "wss://fstream.binance.com/stream") {
+    super({ baseStreamUrl });
+  }
+  kline(symbol3, interval) {
+    return `${symbol3.toLowerCase()}@kline_${interval}`;
+  }
+  continuousKline(symbol3, contractType2, interval) {
+    return `${symbol3.toLowerCase()}@continuousKline_${contractType2}_${interval}`;
+  }
+  indexPriceKline(symbol3, interval) {
+    return `${symbol3.toLowerCase()}@indexPriceKline_${interval}`;
+  }
+  markPriceKline(symbol3, interval) {
+    return `${symbol3.toLowerCase()}@markPriceKline_${interval}`;
+  }
+  aggTrade(symbol3) {
+    return `${symbol3.toLowerCase()}@aggTrade`;
+  }
+  trade(symbol3) {
+    return `${symbol3.toLowerCase()}@trade`;
+  }
+  depth(symbol3, level = 20) {
+    return `${symbol3.toLowerCase()}@depth${level}`;
+  }
+  depthDiff(symbol3) {
+    return `${symbol3.toLowerCase()}@depth`;
+  }
+  depthDiffSpeed(symbol3, updateSpeed) {
+    return `${symbol3.toLowerCase()}@depth@${updateSpeed}`;
+  }
+  ticker(symbol3) {
+    return `${symbol3.toLowerCase()}@ticker`;
+  }
+  rollingWindowTicker(symbol3, window = "1h") {
+    return `${symbol3.toLowerCase()}@ticker_${window}`;
+  }
+  allRollingWindowTickers(window = "1h") {
+    return `!ticker_${window}@arr`;
+  }
+  allMarketTickers() {
+    return "!ticker@arr";
+  }
+  allBookTickers() {
+    return "!bookTicker";
+  }
+  miniTicker(symbol3) {
+    return `${symbol3.toLowerCase()}@miniTicker`;
+  }
+  allMiniTickers() {
+    return "!miniTicker@arr";
+  }
+  markPrice(symbol3, updateSpeed = "3s") {
+    return `${symbol3.toLowerCase()}@markPrice@${updateSpeed}`;
+  }
+  allMarkPrices() {
+    return "!markPrice@arr";
+  }
+  bookTicker(symbol3) {
+    return `${symbol3.toLowerCase()}@bookTicker`;
+  }
+  liquidationOrder(symbol3) {
+    return `${symbol3.toLowerCase()}@forceOrder`;
+  }
+  allLiquidationOrders() {
+    return "!forceOrder@arr";
+  }
+  compositeIndex(symbol3) {
+    return `${symbol3.toLowerCase()}@compositeIndex`;
+  }
+  assetIndex(symbol3) {
+    return `${symbol3.toLowerCase()}@assetIndex`;
+  }
+  allAssetIndices() {
+    return "!assetIndex@arr";
+  }
+};
+
+// src/ws/SpotMarketWS.ts
+var SpotMarketWS = class extends BaseWS {
+  constructor(baseStreamUrl = "wss://stream.binance.com:9443/stream") {
+    super({ baseStreamUrl });
+  }
+  kline(symbol3, interval) {
+    return `${symbol3.toLowerCase()}@kline_${interval}`;
+  }
+  aggTrade(symbol3) {
+    return `${symbol3.toLowerCase()}@aggTrade`;
+  }
+  trade(symbol3) {
+    return `${symbol3.toLowerCase()}@trade`;
+  }
+  depth(symbol3, level = 20) {
+    return `${symbol3.toLowerCase()}@depth${level}`;
+  }
+  depthDiff(symbol3) {
+    return `${symbol3.toLowerCase()}@depth`;
+  }
+  depthDiffSpeed(symbol3, updateSpeed) {
+    return `${symbol3.toLowerCase()}@depth@${updateSpeed}`;
+  }
+  avgPrice(symbol3) {
+    return `${symbol3.toLowerCase()}@avgPrice`;
+  }
+  ticker(symbol3) {
+    return `${symbol3.toLowerCase()}@ticker`;
+  }
+  rollingWindowTicker(symbol3, window = "1h") {
+    return `${symbol3.toLowerCase()}@ticker_${window}`;
+  }
+  allRollingWindowTickers(window = "1h") {
+    return `!ticker_${window}@arr`;
+  }
+  miniTicker(symbol3) {
+    return `${symbol3.toLowerCase()}@miniTicker`;
+  }
+  allMarketTickers() {
+    return "!ticker@arr";
+  }
+  allMiniTickers() {
+    return "!miniTicker@arr";
+  }
+  bookTicker(symbol3) {
+    return `${symbol3.toLowerCase()}@bookTicker`;
+  }
+  allBookTickers() {
+    return "!bookTicker";
+  }
+};
+
+// src/ws/SpotUserWS.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import WebSocket2 from "ws";
+var SpotUserWS = class extends EventEmitter2 {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.ws = null;
+    this.reconnectAttempt = 0;
+    this.closedByUser = false;
+  }
+  connect() {
+    const listenKey = this.options.getListenKey();
+    if (!listenKey) {
+      this.emit("error", new Error("No spot listenKey available for user data stream"));
+      return;
+    }
+    this.closedByUser = false;
+    const url = `${this.options.baseUserUrl}/${listenKey}`;
+    this.ws = new WebSocket2(url);
+    this.ws.on("open", () => {
+      this.reconnectAttempt = 0;
+      this.emit("open");
+    });
+    this.ws.on("message", (raw) => {
+      this.handleMessage(raw.toString());
+    });
+    this.ws.on("close", () => {
+      this.emit("close");
+      if (!this.closedByUser) this.scheduleReconnect();
+    });
+    this.ws.on("error", (err) => {
+      this.emit("error", err);
+    });
+  }
+  close() {
+    this.closedByUser = true;
+    this.ws?.close();
+  }
+  reconnect() {
+    if (this.ws?.readyState === WebSocket2.OPEN) this.ws.close();
+    this.reconnectAttempt = 0;
+    if (!this.closedByUser) this.connect();
+  }
+  resetReconnectAttempts() {
+    this.reconnectAttempt = 0;
+  }
+  handleMessage(raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    try {
+      const event = parseSpotUserDataEvent(parsed);
+      this.emit(event.e, event);
+      this.emit("userData", event);
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  scheduleReconnect() {
+    const base = this.options.reconnectDelayMs ?? 1e3;
+    const max = this.options.maxReconnectDelayMs ?? 3e4;
+    const delay = Math.min(base * 2 ** this.reconnectAttempt, max);
+    this.reconnectAttempt += 1;
+    setTimeout(() => {
+      if (!this.closedByUser) this.connect();
+    }, delay);
+  }
+};
+
+// src/ws/FuturesUserWS.ts
+import { EventEmitter as EventEmitter3 } from "events";
+import WebSocket3 from "ws";
+var FuturesUserWS = class extends EventEmitter3 {
+  constructor(options) {
+    super();
+    this.options = options;
+    this.ws = null;
+    this.reconnectAttempt = 0;
+    this.closedByUser = false;
+  }
+  connect() {
+    const listenKey = this.options.getListenKey();
+    if (!listenKey) {
+      this.emit("error", new Error("No listenKey available for user data stream"));
+      return;
+    }
+    this.closedByUser = false;
+    const url = `${this.options.baseUserUrl}/${listenKey}`;
+    this.ws = new WebSocket3(url);
+    this.ws.on("open", () => {
+      this.reconnectAttempt = 0;
+      this.emit("open");
+    });
+    this.ws.on("message", (raw) => {
+      this.handleMessage(raw.toString());
+    });
+    this.ws.on("close", () => {
+      this.emit("close");
+      if (!this.closedByUser) this.scheduleReconnect();
+    });
+    this.ws.on("error", (err) => {
+      this.emit("error", err);
+    });
+  }
+  close() {
+    this.closedByUser = true;
+    this.ws?.close();
+  }
+  reconnect() {
+    if (this.ws?.readyState === WebSocket3.OPEN) this.ws.close();
+    this.reconnectAttempt = 0;
+    if (!this.closedByUser) this.connect();
+  }
+  resetReconnectAttempts() {
+    this.reconnectAttempt = 0;
+  }
+  handleMessage(raw) {
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    try {
+      const event = parseUserDataEvent(parsed);
+      this.emit(event.e, event);
+      this.emit("userData", event);
+    } catch (err) {
+      this.emit("error", err);
+    }
+  }
+  scheduleReconnect() {
+    const base = this.options.reconnectDelayMs ?? 1e3;
+    const max = this.options.maxReconnectDelayMs ?? 3e4;
+    const delay = Math.min(base * 2 ** this.reconnectAttempt, max);
+    this.reconnectAttempt += 1;
+    setTimeout(() => {
+      if (!this.closedByUser) this.connect();
+    }, delay);
+  }
+};
+
+// src/ws/WsApi.ts
+import { createHmac as createHmac2, randomUUID } from "crypto";
+import WebSocket4 from "ws";
+function buildQueryString(data) {
+  return Object.entries(data).filter(([, val]) => val !== void 0 && val !== null).map(([key, val]) => `${key}=${encodeURIComponent(String(val))}`).join("&");
+}
+var WsApi = class {
+  constructor(options) {
+    this.options = options;
+  }
+  async request(method, params = {}, options) {
+    const { apiKey, apiSecret } = this.options;
+    const signed = options?.signed ?? true;
+    const { id = randomUUID(), ...methodParams } = params;
+    const requestParams = { ...methodParams };
+    if (signed) {
+      if (!apiKey || !apiSecret) {
+        throw new Error("API key and secret required for signed WebSocket API requests");
+      }
+      requestParams.apiKey = apiKey;
+      requestParams.timestamp = Date.now();
+      requestParams.recvWindow = this.options.recvWindow ?? 5e3;
+      const queryString = buildQueryString(requestParams);
+      requestParams.signature = createHmac2("sha256", apiSecret).update(queryString).digest("hex");
+    }
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket4(this.options.baseUrl);
+      const timeout = setTimeout(() => {
+        ws.close();
+        reject(new NetworkError(`WebSocket API request timed out: ${method}`));
+      }, this.options.timeoutMs ?? 15e3);
+      ws.on("open", () => ws.send(JSON.stringify({ id, method, params: requestParams })));
+      ws.on("message", (raw) => {
+        clearTimeout(timeout);
+        ws.close();
+        try {
+          const parsed = JSON.parse(raw.toString());
+          if (parsed.status >= 400) {
+            reject(new Error(parsed.error?.msg ?? `WebSocket API error: ${method}`));
+          } else {
+            resolve(parsed);
+          }
+        } catch (err) {
+          reject(new NetworkError("Invalid WebSocket API JSON payload", err));
+        }
+      });
+      ws.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(new NetworkError(err.message, err));
+      });
+    });
+  }
+  placeOrder(params) {
+    return this.request("order.place", params);
+  }
+  cancelOrder(params) {
+    return this.request("order.cancel", params);
+  }
+  modifyOrder(params) {
+    return this.request("order.modify", params);
+  }
+  placeAlgoOrder(params) {
+    return this.request("algoOrder.place", params);
+  }
+  cancelAlgoOrder(params) {
+    return this.request("algoOrder.cancel", params);
+  }
+  orderStatus(params) {
+    return this.request("order.status", params);
+  }
+  placeOrderList(params) {
+    return this.request("orderList.place", params);
+  }
+  cancelOrderList(params) {
+    return this.request("orderList.cancel", params);
+  }
+  orderListStatus(params) {
+    return this.request("orderList.status", params);
+  }
+  accountStatus() {
+    return this.request("account.status", {});
+  }
+  accountPosition(params = {}) {
+    return this.request("account.position", params);
+  }
+  userDataStreamStart() {
+    return this.request("userDataStream.start", {});
+  }
+  userDataStreamPing(listenKey) {
+    return this.request("userDataStream.ping", { listenKey });
+  }
+  userDataStreamStop(listenKey) {
+    return this.request("userDataStream.stop", { listenKey });
+  }
+  // ---- Public market data (no signature required) ----
+  time() {
+    return this.request("time", {}, { signed: false });
+  }
+  exchangeInfo(params = {}) {
+    return this.request("exchangeInfo", params, { signed: false });
+  }
+  klines(params) {
+    return this.request("klines", params, { signed: false });
+  }
+  aggTrades(params) {
+    return this.request("aggTrades", params, { signed: false });
+  }
+  trades(params) {
+    return this.request("trades", params, { signed: false });
+  }
+  depth(params) {
+    return this.request("depth", params, { signed: false });
+  }
+  avgPrice(params) {
+    return this.request("avgPrice", params, { signed: false });
+  }
+  tickerPrice(params = {}) {
+    return this.request("ticker.price", params, { signed: false });
+  }
+  tickerBookTicker(params = {}) {
+    return this.request("ticker.bookTicker", params, { signed: false });
+  }
+  ticker24hr(params = {}) {
+    return this.request("ticker.24hr", params, { signed: false });
+  }
+};
+
+// src/client/BinanceClient.ts
+var BinanceClient = class {
+  constructor(options = {}) {
+    this.listenKeyValue = null;
+    this.keepAliveInterval = null;
+    this.spotListenKeyValue = null;
+    this.spotKeepAliveInterval = null;
+    const { endpoints } = resolveEnvironment(options);
+    const httpOptions = {
+      apiKey: options.apiKey,
+      apiSecret: options.apiSecret,
+      recvWindow: options.recvWindow ?? 5e3,
+      timeoutMs: options.timeoutMs ?? 15e3,
+      maxRetries: options.maxRetries ?? 3,
+      retryBaseDelayMs: options.retryBaseDelayMs,
+      retryMaxDelayMs: options.retryMaxDelayMs
+    };
+    this.authHttp = new HttpClient({ baseURL: endpoints.restRoot, ...httpOptions });
+    const spotHttp = new HttpClient({ baseURL: endpoints.restSpot, ...httpOptions });
+    this.spot = {
+      market: new SpotMarket(spotHttp),
+      account: new SpotAccount(spotHttp),
+      trading: new SpotTrading(spotHttp),
+      userStream: new SpotUserDataStream(spotHttp),
+      ws: new SpotMarketWS(endpoints.wsSpotMarket),
+      wsUser: new SpotUserWS({
+        baseUserUrl: endpoints.wsSpotUser,
+        getListenKey: () => this.spotListenKeyValue
+      })
+    };
+    const futuresMarket = new FuturesMarket(
+      new HttpClient({ baseURL: endpoints.restFapi, ...httpOptions }),
+      endpoints.restRoot
+    );
+    const futuresData = new FuturesData({
+      restFapi: endpoints.restFapi,
+      restFuturesData: endpoints.restFuturesData,
+      ...httpOptions
+    });
+    const futuresAccount = new FuturesAccount(this.authHttp);
+    const futuresTrading = new FuturesTrading(this.authHttp);
+    this.futures = {
+      market: futuresMarket,
+      data: futuresData,
+      account: futuresAccount,
+      trading: futuresTrading,
+      ops: new FuturesOps(futuresMarket, futuresData, futuresAccount, futuresTrading),
+      userStream: new UserDataStream(this.authHttp),
+      ws: new FuturesMarketWS(endpoints.wsMarket),
+      wsUser: new FuturesUserWS({
+        baseUserUrl: endpoints.wsUser,
+        getListenKey: () => this.listenKeyValue
+      }),
+      wsApi: new WsApi({
+        baseUrl: endpoints.wsApi,
+        apiKey: options.apiKey,
+        apiSecret: options.apiSecret,
+        recvWindow: options.recvWindow
+      })
+    };
+  }
+  static nowSeconds() {
+    return Math.floor(Date.now() / 1e3);
+  }
+  static buildPair(base, target) {
+    return `${base}${target}`.toUpperCase();
+  }
+  static parsePair(pair) {
+    const match = pair.match(/^([A-Z0-9]+)(USDT|USDC|BUSD|BTC|ETH|BNB)$/);
+    if (!match) return null;
+    return { base: match[1], target: match[2] };
+  }
+  static calculateLiquidationPrice(entryPrice, leverage, side3, mm = 5e-3) {
+    const dir = side3 === "buy" ? 1 : -1;
+    return dir === 1 ? entryPrice * (1 - 1 / leverage + mm) : entryPrice * (1 + 1 / leverage - mm);
+  }
+  async startUserStream() {
+    const { listenKey } = await this.futures.userStream.createListenKey();
+    this.listenKeyValue = listenKey;
+    this.keepAliveInterval = setInterval(() => {
+      this.futures.userStream.keepAliveListenKey().catch(() => {
+      });
+    }, 30 * 60 * 1e3);
+    this.futures.wsUser.connect();
+    return listenKey;
+  }
+  closeUserStream() {
+    if (this.keepAliveInterval) clearInterval(this.keepAliveInterval);
+    this.keepAliveInterval = null;
+    this.futures.wsUser.close();
+    this.futures.userStream.closeListenKey().catch(() => {
+    });
+    this.listenKeyValue = null;
+  }
+  async startSpotUserStream() {
+    const { listenKey } = await this.spot.userStream.createListenKey();
+    this.spotListenKeyValue = listenKey;
+    this.spotKeepAliveInterval = setInterval(() => {
+      this.spot.userStream.keepAliveListenKey().catch(() => {
+      });
+    }, 30 * 60 * 1e3);
+    this.spot.wsUser.connect();
+    return listenKey;
+  }
+  closeSpotUserStream() {
+    if (this.spotKeepAliveInterval) clearInterval(this.spotKeepAliveInterval);
+    this.spotKeepAliveInterval = null;
+    this.spot.wsUser.close();
+    this.spot.userStream.closeListenKey().catch(() => {
+    });
+    this.spotListenKeyValue = null;
+  }
+  closeAllWebSockets() {
+    this.futures.ws.close();
+    this.futures.wsUser.close();
+    this.spot.ws.close();
+    this.spot.wsUser.close();
+    this.closeUserStream();
+    this.closeSpotUserStream();
+  }
+  reconnectWebSocket(target) {
+    if (target === "ws") this.futures.ws.reconnect();
+    else if (target === "wsUser") this.futures.wsUser.reconnect();
+    else if (target === "spot") this.spot.ws.reconnect();
+    else this.spot.wsUser.reconnect();
+  }
+  resetReconnectAttempts() {
+    this.futures.ws.resetReconnectAttempts();
+    this.futures.wsUser.resetReconnectAttempts();
+    this.spot.ws.resetReconnectAttempts();
+    this.spot.wsUser.resetReconnectAttempts();
+  }
+};
+
+// src/paper/PaperTradingEngine.ts
+function emptyPosition(symbol3) {
+  return {
+    symbol: symbol3,
+    side: "NONE",
+    entryPrice: 0,
+    quantity: 0,
+    leverage: 1,
+    margin: 0,
+    unrealizedPnl: 0,
+    openedAt: 0
+  };
+}
+var PaperTradingEngine = class {
+  constructor(options = {}) {
+    this.orderIdCounter = 1e6;
+    this.market = options.market ?? new FuturesMarket();
+    const initialBalance = options.initialBalance ?? 1e4;
+    this.account = {
+      balance: initialBalance,
+      availableBalance: initialBalance,
+      totalWalletBalance: initialBalance,
+      realizedPnl: 0,
+      unrealizedPnl: 0,
+      positions: {},
+      orders: []
+    };
+  }
+  /** Current mark price for any tradeable symbol. */
+  async getMarketPrice(symbol3) {
+    return (await this.market.tickerPrice(symbol3.toUpperCase())).price;
+  }
+  positionFor(symbol3) {
+    const existing = this.account.positions[symbol3];
+    if (existing) return existing;
+    const created = emptyPosition(symbol3);
+    this.account.positions[symbol3] = created;
+    return created;
+  }
+  async placeOrder(params) {
+    const symbol3 = params.symbol.toUpperCase();
+    const { side: side3, type, quantity } = params;
+    const leverage = params.leverage ?? 1;
+    if (!(quantity > 0)) throw new Error("Quantity must be positive");
+    if (leverage < 1 || leverage > 125) throw new Error("Leverage must be 1-125");
+    if (type === "LIMIT" && !(params.price > 0)) throw new Error("Price required for LIMIT orders");
+    const marketPrice = await this.getMarketPrice(symbol3);
+    const fillPrice = type === "MARKET" ? marketPrice : params.price;
+    const position = this.positionFor(symbol3);
+    const opposing = side3 === "SELL" && position.side === "LONG" || side3 === "BUY" && position.side === "SHORT";
+    const openingQty = opposing ? Math.max(0, quantity - position.quantity) : quantity;
+    const requiredMargin = openingQty * fillPrice / leverage;
+    if (requiredMargin > this.account.availableBalance + 1e-9) {
+      throw new Error(
+        `Insufficient balance. Required: ${requiredMargin.toFixed(2)}, Available: ${this.account.availableBalance.toFixed(2)}`
+      );
+    }
+    const realizedPnl = this.applyFill(position, side3, quantity, fillPrice, leverage);
+    this.markToMarket(symbol3, marketPrice);
+    this.recomputeTotals();
+    const order = {
+      orderId: ++this.orderIdCounter,
+      symbol: symbol3,
+      side: side3,
+      type,
+      quantity,
+      price: fillPrice,
+      status: "FILLED",
+      filledQuantity: quantity,
+      avgFillPrice: fillPrice,
+      realizedPnl,
+      createdAt: Date.now()
+    };
+    this.account.orders.push(order);
+    return order;
+  }
+  /**
+   * Apply a fill to a position, returning the realized PnL it booked.
+   * Handles extend, partial reduce, full close, and a flip through zero.
+   */
+  applyFill(position, side3, quantity, fillPrice, leverage) {
+    const incoming = side3 === "BUY" ? "LONG" : "SHORT";
+    if (position.side === "NONE" || position.quantity === 0) {
+      this.openExposure(position, incoming, quantity, fillPrice, leverage);
+      return 0;
+    }
+    if (position.side === incoming) {
+      this.openExposure(position, incoming, quantity, fillPrice, leverage);
+      return 0;
+    }
+    const closeQty = Math.min(quantity, position.quantity);
+    const realized = this.reduceExposure(position, closeQty, fillPrice);
+    const remainder = quantity - closeQty;
+    if (remainder > 0) this.openExposure(position, incoming, remainder, fillPrice, leverage);
+    return realized;
+  }
+  openExposure(position, side3, quantity, fillPrice, leverage) {
+    const previousQty = position.quantity;
+    const totalQty = previousQty + quantity;
+    position.entryPrice = totalQty > 0 ? (position.entryPrice * previousQty + fillPrice * quantity) / totalQty : fillPrice;
+    position.quantity = totalQty;
+    position.side = side3;
+    position.leverage = leverage;
+    if (previousQty === 0) position.openedAt = Date.now();
+    const margin = quantity * fillPrice / leverage;
+    position.margin += margin;
+    this.account.availableBalance -= margin;
+  }
+  /** Reduce a position, releasing margin pro-rata and booking realized PnL. */
+  reduceExposure(position, closeQty, fillPrice) {
+    const direction = position.side === "LONG" ? 1 : -1;
+    const realized = (fillPrice - position.entryPrice) * closeQty * direction;
+    const releasedMargin = position.quantity > 0 ? position.margin * (closeQty / position.quantity) : 0;
+    position.margin -= releasedMargin;
+    position.quantity -= closeQty;
+    this.account.balance += realized;
+    this.account.realizedPnl += realized;
+    this.account.availableBalance += releasedMargin + realized;
+    if (position.quantity <= 1e-12) {
+      position.quantity = 0;
+      position.side = "NONE";
+      position.entryPrice = 0;
+      position.unrealizedPnl = 0;
+      this.account.availableBalance += position.margin;
+      position.margin = 0;
+    }
+    return realized;
+  }
+  markToMarket(symbol3, price) {
+    const position = this.account.positions[symbol3];
+    if (!position || position.side === "NONE" || position.quantity === 0) {
+      if (position) position.unrealizedPnl = 0;
+      return;
+    }
+    const direction = position.side === "LONG" ? 1 : -1;
+    position.unrealizedPnl = (price - position.entryPrice) * position.quantity * direction;
+  }
+  recomputeTotals() {
+    this.account.unrealizedPnl = Object.values(this.account.positions).reduce(
+      (sum, p) => sum + p.unrealizedPnl,
+      0
+    );
+    this.account.totalWalletBalance = this.account.balance + this.account.unrealizedPnl;
+  }
+  /** Refresh unrealized PnL for every open position against live prices. */
+  async updatePositions() {
+    const open = Object.values(this.account.positions).filter((p) => p.side !== "NONE");
+    await Promise.all(
+      open.map(async (position) => {
+        try {
+          this.markToMarket(position.symbol, await this.getMarketPrice(position.symbol));
+        } catch {
+        }
+      })
+    );
+    this.recomputeTotals();
+  }
+  getAccountInfo() {
+    return {
+      ...this.account,
+      positions: this.getAllPositions(),
+      orders: [...this.account.orders]
+    };
+  }
+  getPosition(symbol3) {
+    const position = this.account.positions[symbol3.toUpperCase()];
+    return position ? { ...position } : void 0;
+  }
+  getAllPositions() {
+    return Object.fromEntries(
+      Object.entries(this.account.positions).map(([symbol3, p]) => [symbol3, { ...p }])
+    );
+  }
+  /** Open positions only — the zero-size entries left behind by closed trades are filtered out. */
+  getOpenPositions() {
+    return Object.values(this.account.positions).filter((p) => p.side !== "NONE").map((p) => ({ ...p }));
+  }
+  getOrderHistory(symbol3) {
+    const orders = symbol3 ? this.account.orders.filter((o) => o.symbol === symbol3.toUpperCase()) : this.account.orders;
+    return [...orders];
+  }
+};
+
+// src/tools/account.tools.ts
+import { z as z9 } from "zod";
+
+// src/tools/types.ts
+import { z as z8 } from "zod";
+function normalizeSymbol(value) {
+  return String(value ?? "").trim().toUpperCase();
+}
+function toJsonSchema(inputSchema) {
+  return z8.toJSONSchema(inputSchema, { target: "json" });
+}
+function toOpenAITool(tool) {
+  return {
+    type: "function",
+    function: {
+      name: tool.name,
+      description: tool.description,
+      parameters: toJsonSchema(tool.inputSchema)
+    }
+  };
+}
+function toAnthropicTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    input_schema: toJsonSchema(tool.inputSchema)
+  };
+}
+function toMCPTool(tool) {
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: toJsonSchema(tool.inputSchema)
+  };
+}
+function toToolList(tools, format) {
+  const adapter = format === "openai" ? toOpenAITool : format === "anthropic" ? toAnthropicTool : toMCPTool;
+  return tools.map(adapter);
+}
+function textResult(data) {
+  return JSON.stringify(data, null, 2);
+}
+
+// src/tools/account.tools.ts
+var optionalSymbol = z9.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional();
+var limit = z9.number().int().positive().max(1e3).default(100);
+var startTime = z9.number().int().positive().optional();
+var endTime = z9.number().int().positive().optional();
+function accountTools(client) {
+  const a = client.futures.account;
+  return [
+    {
+      name: "futures_balance",
+      description: "Get futures account balances (v3): asset, wallet balance, unrealized profit, margin balance, available balance (signed).",
+      inputSchema: z9.object({}),
+      handler: async () => textResult(await a.balanceV3())
+    },
+    {
+      name: "futures_account",
+      description: "Get full account information (v3): total wallet/margin balance, unrealized profit, available balance, assets & positions (signed).",
+      inputSchema: z9.object({}),
+      handler: async () => textResult(await a.accountV3())
+    },
+    {
+      name: "futures_balance_v2",
+      description: "Get futures account balance (v2 legacy) per asset (signed).",
+      inputSchema: z9.object({}),
+      handler: async () => textResult(await a.balance())
+    },
+    {
+      name: "futures_account_v2",
+      description: "Get futures account information (v2 legacy) (signed).",
+      inputSchema: z9.object({}),
+      handler: async () => textResult(await a.account())
+    },
+    {
+      name: "futures_position_risk",
+      description: "Get current open positions (v3): symbol, side, size, entry price, mark price, liquidation price, leverage, unrealized PnL, margin (signed).",
+      inputSchema: z9.object({ symbol: optionalSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await a.positionRiskV3(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_income_history",
+      description: "Get futures income history (realized PnL, funding fees, commissions, transfers, insurance clearing). incomeType examples: TRANSFER, REALIZED_PNL, FUNDING_FEE, COMMISSION, INSURANCE_CLEAR, REFERRAL_KICKBACK (signed).",
+      inputSchema: z9.object({ symbol: optionalSymbol, incomeType: z9.string().optional().describe("e.g. TRANSFER, REALIZED_PNL, FUNDING_FEE, COMMISSION"), startTime, endTime, limit: limit.default(100) }),
+      handler: async ({ symbol: symbol3, incomeType, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await a.incomeHistory({ symbol: symbol3 ? normalizeSymbol(symbol3) : void 0, incomeType, startTime: startTime5, endTime: endTime5, limit: Number(limit4) }))
+    },
+    {
+      name: "futures_user_trades",
+      description: "Get account trade list (filled trades) for a symbol with optional time range (signed).",
+      inputSchema: z9.object({ symbol: z9.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), startTime, endTime, limit: limit.default(100), fromId: z9.number().int().positive().optional() }),
+      handler: async ({ symbol: symbol3, startTime: startTime5, endTime: endTime5, limit: limit4, fromId }) => textResult(await a.userTrades({ symbol: normalizeSymbol(symbol3), startTime: startTime5, endTime: endTime5, limit: Number(limit4), fromId }))
+    },
+    {
+      name: "futures_leverage_brackets",
+      description: "Get notional and leverage brackets for one symbol or all: tier caps, maintenance margin rate, max leverage (signed).",
+      inputSchema: z9.object({ symbol: optionalSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await a.leverageBrackets(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_commission_rate",
+      description: "Get user commission rate (taker & maker fee) for a symbol (signed).",
+      inputSchema: z9.object({ symbol: z9.string().min(1).describe("USD-M pair, e.g. ETHUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await a.commissionRate(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_multi_assets_mode",
+      description: "Get current multi-assets margin mode status (signed).",
+      inputSchema: z9.object({}),
+      handler: async () => textResult(await a.multiAssetsMargin())
+    },
+    {
+      name: "futures_set_multi_assets_mode",
+      description: "Enable or disable multi-assets mode (signed; 7-day cooldown between toggles).",
+      inputSchema: z9.object({ enabled: z9.boolean().describe("true to enable, false to disable") }),
+      handler: async ({ enabled }) => textResult(await a.setMultiAssetsMargin(enabled))
+    },
+    {
+      name: "futures_fee_burn_status",
+      description: "Get BNB fee burn status for futures trades (signed).",
+      inputSchema: z9.object({}),
+      handler: async () => textResult(await a.feeBurnStatus())
+    },
+    {
+      name: "futures_set_fee_burn",
+      description: "Toggle BNB fee burn on futures trades (signed).",
+      inputSchema: z9.object({ enabled: z9.boolean().describe("true to enable fee burn") }),
+      handler: async ({ enabled }) => textResult(await a.setFeeBurnStatus(enabled))
+    },
+    {
+      name: "futures_position_mode",
+      description: "Get current position mode: one-way (BOTH) or hedge mode (LONG/SHORT) (signed).",
+      inputSchema: z9.object({}),
+      handler: async () => textResult(await a.positionMode())
+    },
+    {
+      name: "futures_set_position_mode",
+      description: "Change position mode: hedgeMode true = dual side (hedge), false = one-way (signed; 30-day cooldown).",
+      inputSchema: z9.object({ hedgeMode: z9.boolean().describe("true = hedge mode, false = one-way") }),
+      handler: async ({ hedgeMode }) => textResult(await a.setPositionMode(hedgeMode))
+    },
+    {
+      name: "futures_api_trading_status",
+      description: "Get futures trading quantitative rules indicators and disable intervals (signed).",
+      inputSchema: z9.object({}),
+      handler: async () => textResult(await a.apiTradingStatus())
+    },
+    {
+      name: "futures_position_margin_history",
+      description: "Get isolated position margin change history. type: 1 = add margin, 2 = reduce margin (signed).",
+      inputSchema: z9.object({ symbol: z9.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), type: z9.enum(["1", "2"]).describe("1 = add margin, 2 = reduce margin"), startTime, endTime, limit: limit.default(50) }),
+      handler: async ({ symbol: symbol3, type, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await a.positionMarginHistory({ symbol: normalizeSymbol(symbol3), type: Number(type), startTime: startTime5, endTime: endTime5, limit: Number(limit4) }))
+    },
+    {
+      name: "futures_rate_limit_order",
+      description: "Query the current user order rate limit usage (signed).",
+      inputSchema: z9.object({}),
+      handler: async () => textResult(await a.rateLimitOrder())
+    },
+    {
+      name: "futures_request_order_download",
+      description: "Request a futures order-history download (async, 7-day window). Returns a downloadId (signed).",
+      inputSchema: z9.object({ symbol: optionalSymbol, startTime, endTime }),
+      handler: async ({ symbol: symbol3, startTime: startTime5, endTime: endTime5 }) => textResult(await a.requestOrderDownload({ symbol: symbol3 ? normalizeSymbol(symbol3) : void 0, startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_order_download_status",
+      description: "Get the futures order-history download link by downloadId (signed).",
+      inputSchema: z9.object({ downloadId: z9.string().min(1) }),
+      handler: async ({ downloadId }) => textResult(await a.getOrderDownloadStatus(downloadId))
+    },
+    {
+      name: "futures_request_trade_download",
+      description: "Request a futures trade-history download (async, 7-day window). Returns a downloadId (signed).",
+      inputSchema: z9.object({ symbol: optionalSymbol, startTime, endTime }),
+      handler: async ({ symbol: symbol3, startTime: startTime5, endTime: endTime5 }) => textResult(await a.requestTradeDownload({ symbol: symbol3 ? normalizeSymbol(symbol3) : void 0, startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_trade_download_status",
+      description: "Get the futures trade-history download link by downloadId (signed).",
+      inputSchema: z9.object({ downloadId: z9.string().min(1) }),
+      handler: async ({ downloadId }) => textResult(await a.getTradeDownloadStatus(downloadId))
+    },
+    {
+      name: "futures_account_config",
+      description: "Get futures account configuration: fee tier, trading permissions, dual-side position setting (signed).",
+      inputSchema: z9.object({}),
+      handler: async () => textResult(await a.accountConfig())
+    },
+    {
+      name: "futures_portfolio_margin_account_info",
+      description: "Get Portfolio Margin account info for an asset: cross margin balance and liability (signed).",
+      inputSchema: z9.object({ asset: z9.string().min(1).describe("Asset, e.g. USDT") }),
+      handler: async ({ asset }) => textResult(await a.pmAccountInfo(asset))
+    },
+    {
+      name: "futures_request_income_download",
+      description: "Request a futures income/transaction-history download (async). Returns a downloadId (signed).",
+      inputSchema: z9.object({ startTime: startTime.unwrap(), endTime: endTime.unwrap() }),
+      handler: async ({ startTime: startTime5, endTime: endTime5 }) => textResult(await a.requestIncomeDownload({ startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_income_download_status",
+      description: "Get the futures income/transaction-history download link by downloadId (signed).",
+      inputSchema: z9.object({ downloadId: z9.string().min(1) }),
+      handler: async ({ downloadId }) => textResult(await a.getIncomeDownloadStatus(downloadId))
+    }
+  ];
+}
+
+// src/tools/derived.tools.ts
+import { z as z10 } from "zod";
+var symbol = z10.string().min(1).describe("USD-M pair, e.g. BTCUSDT");
+function derivedTools(client) {
+  const ops = client.futures.ops;
+  return [
+    {
+      name: "futures_symbol_rules",
+      description: "Get the tradeable rules for a symbol in one call: tick size, step size, min/max quantity, market-order lot bounds and minimum notional, flattened out of exchangeInfo filters. Call this before sizing or pricing any order.",
+      inputSchema: z10.object({ symbol, refresh: z10.boolean().default(false).describe("Bypass the 60s cache") }),
+      handler: async ({ symbol: s, refresh }) => textResult(await ops.symbolRules(normalizeSymbol(s), { refresh }))
+    },
+    {
+      name: "futures_quantize",
+      description: "Round a price to the symbol's tick size and a quantity to its step size, returning exchange-ready strings. Use this instead of rounding numbers yourself \u2014 Binance rejects off-tick prices (-1111).",
+      inputSchema: z10.object({
+        symbol,
+        price: z10.number().positive().optional(),
+        quantity: z10.number().positive().optional(),
+        marketOrder: z10.boolean().default(false).describe("Use MARKET_LOT_SIZE bounds instead of LOT_SIZE")
+      }),
+      handler: async ({ symbol: s, price, quantity, marketOrder }) => textResult(await ops.quantize(normalizeSymbol(s), { price, quantity, marketOrder }))
+    },
+    {
+      name: "futures_size_position",
+      description: "Convert a risk budget into an exchange-ready order quantity. Given a stop price and either riskAmount (quote currency) or riskPct (percent of available balance), returns the quantity rounded down to the symbol step size, plus the notional, required margin and every constraint that failed (min notional, lot bounds, wrong-side stop). Never increases risk to satisfy a minimum \u2014 it reports instead.",
+      inputSchema: z10.object({
+        symbol,
+        side: z10.enum(["BUY", "SELL"]),
+        stopPrice: z10.number().positive().describe("Protective stop price"),
+        entryPrice: z10.number().positive().optional().describe("Defaults to current mark price"),
+        riskAmount: z10.number().positive().optional().describe("Quote-currency amount to risk, e.g. 50 USDT"),
+        riskPct: z10.number().positive().max(100).optional().describe("Percent of available balance to risk (signed call)"),
+        leverage: z10.number().int().min(1).max(125).optional().describe("Used to report required margin"),
+        marketOrder: z10.boolean().default(false)
+      }),
+      handler: async (args) => textResult(await ops.sizePosition({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "futures_close_position",
+      description: "Flatten an open position with a reduce-only market order. Reads the current position, derives the closing side from its sign, and automatically uses reduceOnly in one-way mode vs positionSide in hedge mode (Binance rejects the wrong one). Set dryRun to preview the order without sending it. Signed, destructive.",
+      inputSchema: z10.object({
+        symbol,
+        positionSide: z10.enum(["BOTH", "LONG", "SHORT"]).optional().describe("Required when hedge mode has both sides open"),
+        portion: z10.number().positive().max(1).default(1).describe("Fraction of the position to close, e.g. 0.5 for half"),
+        dryRun: z10.boolean().default(false)
+      }),
+      handler: async (args) => textResult(await ops.closePosition({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "futures_market_snapshot",
+      description: "One-call market picture for a symbol: 24h stats, mark/index price with funding, open interest and long/short positioning. Replaces four separate primitive calls; individual feeds degrade to an error field rather than failing the whole snapshot.",
+      inputSchema: z10.object({
+        symbol,
+        period: z10.enum(["5m", "15m", "30m", "1h", "2h", "4h", "6h", "12h", "1d"]).default("1h")
+      }),
+      handler: async ({ symbol: s, period: period2 }) => textResult(await ops.marketSnapshot(normalizeSymbol(s), { period: period2 }))
+    },
+    {
+      name: "futures_account_overview",
+      description: "One-call account picture: funded balances, open positions only (zero-size entries filtered out), working orders, and totals for unrealized PnL and gross notional. Signed.",
+      inputSchema: z10.object({}),
+      handler: async () => textResult(await ops.accountOverview())
+    },
+    {
+      name: "futures_place_bracket_order",
+      description: "Place an entry order together with its protective stop-loss and optional take-profit, with all prices quantized to the symbol tick. Returns each leg separately; if a protective leg fails the response is flagged protectionComplete=false and the entry is NOT auto-cancelled (it may already have filled). Signed, destructive.",
+      inputSchema: z10.object({
+        symbol,
+        side: z10.enum(["BUY", "SELL"]),
+        quantity: z10.union([z10.string(), z10.number()]),
+        entryPrice: z10.number().positive().optional().describe("Omit for a MARKET entry"),
+        stopLossPrice: z10.number().positive(),
+        takeProfitPrice: z10.number().positive().optional(),
+        positionSide: z10.enum(["BOTH", "LONG", "SHORT"]).optional(),
+        workingType: z10.enum(["MARK_PRICE", "CONTRACT_PRICE"]).default("MARK_PRICE")
+      }),
+      handler: async (args) => textResult(await ops.placeBracketOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    }
+  ];
+}
+
+// src/tools/market-data.tools.ts
+import { z as z11 } from "zod";
+var u = (s) => s.optional();
+var optSymbol = u(z11.string().min(1)).describe("USD-M pair, e.g. BTCUSDT");
+var limitDefault = z11.number().int().positive().max(1500).default(100);
+var startTime2 = z11.number().int().positive().optional();
+var endTime2 = z11.number().int().positive().optional();
+var period = z11.enum(["5m", "15m", "30m", "1h", "2h", "4h", "6h", "12h", "1d"]).default("1h");
+var contractType = z11.enum(["perpetual", "current_quarter", "next_quarter"]).default("perpetual");
+function marketDataTools(client) {
+  const m = client.futures.market;
+  const d = client.futures.data;
+  const tools = [
+    {
+      name: "futures_ping",
+      description: "Test connectivity to the Binance USD-M futures REST API. Returns empty object {} on success.",
+      inputSchema: z11.object({}),
+      handler: async () => textResult(await m.ping())
+    },
+    {
+      name: "futures_server_time",
+      description: "Get the current Binance USD-M futures server time in milliseconds since epoch.",
+      inputSchema: z11.object({}),
+      handler: async () => textResult(await m.serverTime())
+    },
+    {
+      name: "futures_exchange_info",
+      description: "Get exchange trading rules and symbol metadata: contract type, status, base/quote assets, price/quantity filters, tick size, step size, notional and leverage brackets, delivery dates.",
+      inputSchema: z11.object({}),
+      handler: async () => textResult(await m.exchangeInfo())
+    },
+    {
+      name: "futures_ticker_price",
+      description: "Get latest price for one symbol (v1).",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.tickerPrice(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_ticker_price_v2",
+      description: "Get latest price for one symbol, or for all symbols when symbol is omitted (v2 endpoint). Use all-symbols mode for market overviews.",
+      inputSchema: z11.object({ symbol: optSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.tickerPriceV2(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_ticker_24hr",
+      description: "Get 24-hour rolling price change statistics for a symbol: price change %, high, low, volume, quote volume, open interest.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.ticker24hr(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_book_ticker",
+      description: "Get best bid/ask (top of book) for a single symbol (v1).",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.bookTicker(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_book_ticker_v2",
+      description: "Get best bid/ask (top of book) for one symbol, or all symbols when omitted (v2 endpoint).",
+      inputSchema: z11.object({ symbol: optSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.bookTickerV2(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_order_book",
+      description: "Get order book depth for a symbol. Limits: 5, 10, 20, 50, 100, 500, 1000.",
+      inputSchema: z11.object({
+        symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        limit: z11.enum(["5", "10", "20", "50", "100", "500", "1000"]).default("100")
+      }),
+      handler: async ({ symbol: symbol3, limit: limit4 }) => textResult(await m.depth(normalizeSymbol(symbol3), Number(limit4)))
+    },
+    {
+      name: "futures_recent_trades",
+      description: "Get the most recent executed trades for a symbol (public endpoint).",
+      inputSchema: z11.object({
+        symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        limit: limitDefault.default(500)
+      }),
+      handler: async ({ symbol: symbol3, limit: limit4 }) => textResult(await m.trades(normalizeSymbol(symbol3), Number(limit4)))
+    },
+    {
+      name: "futures_historical_trades",
+      description: "Get older trades for a symbol by fromId (older than recent).",
+      inputSchema: z11.object({
+        symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        limit: limitDefault.default(500),
+        fromId: z11.number().int().positive().optional()
+      }),
+      handler: async ({ symbol: symbol3, limit: limit4, fromId }) => textResult(await m.historicalTrades(normalizeSymbol(symbol3), { limit: Number(limit4), fromId }))
+    },
+    {
+      name: "futures_agg_trades",
+      description: "Get compressed/aggregate trades for a symbol within an optional time window. Each entry aggregates trades with the same price and side.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.aggTrades(normalizeSymbol(symbol3), { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_klines",
+      description: "Get candlestick (OHLCV) data for a symbol. Intervals: 1m,3m,5m,15m,30m,1h,2h,4h,6h,8h,12h,1d,3d,1w,1M. Max 1500 per request.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.klines(normalizeSymbol(symbol3), interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_continuous_klines",
+      description: "Get klines for a continuous contract (perpetual, current_quarter, next_quarter) identified by base pair (e.g. BTCUSDT).",
+      inputSchema: z11.object({
+        symbol: z11.string().min(1).describe("Base pair, e.g. BTCUSDT"),
+        contractType,
+        interval: KlineIntervalSchema,
+        limit: limitDefault.default(500),
+        startTime: startTime2,
+        endTime: endTime2
+      }),
+      handler: async ({ symbol: symbol3, contractType: contractType2, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.continuousKlines(normalizeSymbol(symbol3), contractType2, interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_index_price_klines",
+      description: "Get index price candlesticks for a pair (e.g. BTCUSDT index).",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("Base pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.indexPriceKlines(normalizeSymbol(symbol3), interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_mark_price_klines",
+      description: "Get mark price candlesticks for a symbol.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.markPriceKlines(normalizeSymbol(symbol3), interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_trading_day_ticker",
+      description: "Get the trading-day ticker (v1: rolling window stats by symbol, including open, close, high, low, volume, closeTime).",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.tradingDayTicker(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_mark_price",
+      description: "Get mark price, index price, estimated settle price, last funding rate, next funding time and interest rate for a symbol.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.premiumIndex(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_funding_rate_history",
+      description: "Get historical funding rates for a symbol.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: limitDefault.default(100), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await d.fundingRateHistory(normalizeSymbol(symbol3), { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_funding_info",
+      description: "Get funding rate configuration for all symbols with adjusted funding cap/floor or interval (e.g. under extreme volatility).",
+      inputSchema: z11.object({}),
+      handler: async () => textResult(await d.fundingInfo())
+    },
+    {
+      name: "futures_open_interest",
+      description: "Get the current total open interest for a symbol.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.openInterest(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_open_interest_hist",
+      description: "Get historical open interest statistics per period.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      handler: async ({ symbol: symbol3, period: period2, limit: limit4 }) => textResult(await d.openInterestHist(normalizeSymbol(symbol3), period2, Number(limit4)))
+    },
+    {
+      name: "futures_top_long_short_account_ratio",
+      description: "Get top trader long/short account ratio (number of accounts) for a symbol.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      handler: async ({ symbol: symbol3, period: period2, limit: limit4 }) => textResult(await d.topLongShortAccountRatio(normalizeSymbol(symbol3), period2, Number(limit4)))
+    },
+    {
+      name: "futures_top_long_short_position_ratio",
+      description: "Get top trader long/short position ratio (accounts with net positions) for a symbol.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      handler: async ({ symbol: symbol3, period: period2, limit: limit4 }) => textResult(await d.topLongShortPositionRatio(normalizeSymbol(symbol3), period2, Number(limit4)))
+    },
+    {
+      name: "futures_global_long_short_ratio",
+      description: "Get global long/short account ratio for a symbol (all accounts).",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      handler: async ({ symbol: symbol3, period: period2, limit: limit4 }) => textResult(await d.globalLongShortAccountRatio(normalizeSymbol(symbol3), period2, Number(limit4)))
+    },
+    {
+      name: "futures_taker_long_short_ratio",
+      description: "Get taker buy/sell volume ratio for a symbol.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      handler: async ({ symbol: symbol3, period: period2, limit: limit4 }) => textResult(await d.takerLongShortRatio(normalizeSymbol(symbol3), period2, Number(limit4)))
+    },
+    {
+      name: "futures_basis",
+      description: "Get basis data (spot-futures spread, mark price - index price) for a pair and contract type.",
+      inputSchema: z11.object({
+        symbol: z11.string().min(1).describe("Base pair, e.g. BTCUSDT"),
+        period,
+        limit: limitDefault.default(30),
+        startTime: startTime2,
+        endTime: endTime2
+      }),
+      handler: async ({ symbol: symbol3, period: period2, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await d.basis(normalizeSymbol(symbol3), period2, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_asset_index",
+      description: "Get multi-assets mode asset index (collateral price) for one asset or all assets.",
+      inputSchema: z11.object({ symbol: optSymbol.describe("Asset index symbol, e.g. ADAUSD") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.assetIndex(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_composite_index_info",
+      description: "Get composite index symbol information (e.g. DEFIUSDT) with constituent weights.",
+      inputSchema: z11.object({ symbol: optSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.compositeIndexInfo(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_insurance_balance",
+      description: "Get insurance fund balance snapshots for a symbol.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BNBUSDT"), limit: limitDefault.default(100), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await d.insuranceFundBalance({ symbol: normalizeSymbol(symbol3), limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_index_price_constituents",
+      description: "Get the index price constituents (exchange weights) for a symbol.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.indexPriceConstituents(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_premium_index_klines",
+      description: "Get premium index candlesticks for a symbol (mark price premium over index price).",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      handler: async ({ symbol: symbol3, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.premiumIndexKlines(normalizeSymbol(symbol3), interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "futures_rpi_depth",
+      description: "Get the RPI (Retail Price Improvement) order book depth for a symbol.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: z11.number().int().positive().default(1e3) }),
+      handler: async ({ symbol: symbol3, limit: limit4 }) => textResult(await m.rpiDepth(normalizeSymbol(symbol3), Number(limit4)))
+    },
+    {
+      name: "futures_delivery_price",
+      description: "Get historical quarterly contract settlement/delivery prices for a pair.",
+      inputSchema: z11.object({ symbol: z11.string().min(1).describe("Base pair, e.g. BTCUSDT") }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.deliveryPrice(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_symbol_adl_risk",
+      description: "Get the auto-deleveraging (ADL) risk level for one symbol or all symbols on the account (signed).",
+      inputSchema: z11.object({ symbol: optSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.symbolAdlRisk(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_adl_quantile",
+      description: "Get the position ADL (auto-deleveraging) quantile estimation for one symbol or all symbols (signed).",
+      inputSchema: z11.object({ symbol: optSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await d.adlQuantile(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_force_orders",
+      description: "Get the user's force-liquidation orders (LIQUIDATION) and ADL orders for a symbol or all symbols (signed).",
+      inputSchema: z11.object({
+        symbol: optSymbol,
+        autoCloseType: z11.enum(["LIQUIDATION", "ADL"]).optional(),
+        startTime: startTime2,
+        endTime: endTime2,
+        limit: limitDefault.default(50)
+      }),
+      handler: async ({ symbol: symbol3, autoCloseType, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(
+        await d.forceOrders({
+          symbol: symbol3 ? normalizeSymbol(symbol3) : void 0,
+          autoCloseType,
+          startTime: startTime5,
+          endTime: endTime5,
+          limit: Number(limit4)
+        })
+      )
+    }
+  ];
+  return tools;
+}
+
+// src/tools/paper.tools.ts
+import { z as z12 } from "zod";
+function createPaperContext(client, initialState = {}) {
+  return {
+    client,
+    state: { balance: initialState.balance ?? 1e4, positions: initialState.positions ?? [], history: initialState.history ?? [] }
+  };
+}
+function pnl(position, price) {
+  const direction = position.side === "LONG" ? 1 : -1;
+  return (price - position.entryPrice) * position.quantity * direction;
+}
+function paperTools(ctx) {
+  const s = ctx.state;
+  const t = ctx.client.futures.market;
+  return [
+    {
+      name: "paper_init",
+      description: "Initialize paper-trading state (reset balances, positions, history). No API keys required.",
+      inputSchema: z12.object({ balance: z12.number().positive().default(1e4).describe("Starting USDT balance") }),
+      handler: async ({ balance }) => {
+        s.balance = balance;
+        s.positions = [];
+        s.history = [];
+        return textResult(s);
+      }
+    },
+    {
+      name: "paper_balance",
+      description: "Get current paper-trading balance and open-position equity (uses live market prices if an open position exists). No API keys required.",
+      inputSchema: z12.object({}),
+      handler: async () => textResult(s)
+    },
+    {
+      name: "paper_open_position",
+      description: "Open an in-memory paper position at the live ticker price (or a fixed price). No API keys required.",
+      inputSchema: z12.object({
+        symbol: z12.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        side: z12.enum(["LONG", "SHORT"]),
+        quantity: z12.number().positive(),
+        price: z12.number().positive().optional().describe("If omitted, uses live ticker price")
+      }),
+      handler: async ({ symbol: symbol3, side: side3, quantity, price }) => {
+        const sym = normalizeSymbol(symbol3);
+        const market = price ?? Number((await t.tickerPrice(sym)).price);
+        const position = { id: Date.now().toString(), symbol: sym, side: side3, quantity, entryPrice: market, openedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        s.positions.push(position);
+        s.history.push({ type: "open", ...position });
+        return textResult(position);
+      }
+    },
+    {
+      name: "paper_close_position",
+      description: "Close a paper position by id (or symbol) and realize PnL at the live/last price.",
+      inputSchema: z12.object({
+        id: z12.string().optional().describe("Position id from paper_open_position"),
+        symbol: z12.string().min(1).optional().describe("Close the position for this symbol"),
+        price: z12.number().positive().optional().describe("If omitted, uses live ticker price")
+      }),
+      handler: async ({ id, symbol: symbol3, price }) => {
+        const idx = s.positions.findIndex((p) => id ? p.id === id : normalizeSymbol(p.symbol) === normalizeSymbol(symbol3 ?? ""));
+        if (idx === -1) throw new Error("paper position not found");
+        const position = s.positions[idx];
+        const market = price ?? Number((await t.tickerPrice(position.symbol)).price);
+        const realizedPnl = pnl(position, market);
+        s.balance += realizedPnl;
+        const closed = { type: "close", ...position, exitPrice: market, realizedPnl, closedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        s.positions.splice(idx, 1);
+        s.history.push(closed);
+        return textResult(closed);
+      }
+    },
+    {
+      name: "paper_positions",
+      description: "List open paper positions with live unrealized PnL (marked to market).",
+      inputSchema: z12.object({}),
+      handler: async () => {
+        const out = await Promise.all(
+          s.positions.map(async (p) => {
+            const price = Number((await t.tickerPrice(p.symbol)).price);
+            return { ...p, markPrice: price, unrealizedPnl: pnl(p, price) };
+          })
+        );
+        return textResult(out);
+      }
+    },
+    {
+      name: "paper_history",
+      description: "List paper-trading history of open/close events with realized PnL.",
+      inputSchema: z12.object({}),
+      handler: async () => textResult(s.history)
+    },
+    {
+      name: "paper_summary",
+      description: "Summarize paper-trading state: balance, open positions, trade count.",
+      inputSchema: z12.object({}),
+      handler: async () => textResult({ balance: s.balance, openPositions: s.positions.length, trades: s.history.length })
+    }
+  ];
+}
+
+// src/tools/spot.tools.ts
+import { z as z13 } from "zod";
+var spotSymbol = z13.string().min(1).describe("Spot pair, e.g. BTCUSDT");
+var optionalSymbol2 = z13.string().min(1).describe("Spot pair, e.g. BTCUSDT").optional();
+var limit2 = z13.number().int().positive().max(1e3).default(100);
+var startTime3 = z13.number().int().positive().optional();
+var endTime3 = z13.number().int().positive().optional();
+var side = z13.enum(["BUY", "SELL"]);
+var spotOrderParamsSchema = z13.object({
+  symbol: spotSymbol,
+  side,
+  type: z13.enum(["LIMIT", "MARKET", "LIMIT_MAKER", "STOP_LOSS", "STOP_LOSS_LIMIT", "TAKE_PROFIT", "TAKE_PROFIT_LIMIT"]),
+  quantity: z13.union([z13.string(), z13.number()]).optional().describe("Base-asset quantity; omit if using quoteOrderQty"),
+  quoteOrderQty: z13.union([z13.string(), z13.number()]).optional().describe("Quote-asset quantity (e.g. spend 100 USDT on a MARKET order)"),
+  price: z13.union([z13.string(), z13.number()]).optional().describe("Required for LIMIT / STOP_LOSS_LIMIT / TAKE_PROFIT_LIMIT"),
+  stopPrice: z13.union([z13.string(), z13.number()]).optional().describe("Trigger price for STOP_LOSS / TAKE_PROFIT variants"),
+  timeInForce: z13.enum(["GTC", "IOC", "FOK"]).optional().describe("Required for LIMIT"),
+  newClientOrderId: z13.string().optional(),
+  newOrderRespType: z13.enum(["ACK", "RESULT", "FULL"]).optional(),
+  icebergQty: z13.union([z13.string(), z13.number()]).optional(),
+  selfTradePreventionMode: z13.enum(["NONE", "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"]).optional()
+});
+function spotTools(client) {
+  const m = client.spot.market;
+  const a = client.spot.account;
+  const t = client.spot.trading;
+  const tools = [
+    // ---- Market data (public) ----
+    {
+      name: "spot_ping",
+      description: "Test connectivity to the Binance Spot REST API.",
+      inputSchema: z13.object({}),
+      handler: async () => textResult(await m.ping())
+    },
+    {
+      name: "spot_server_time",
+      description: "Get the current Binance Spot server time in ms since epoch.",
+      inputSchema: z13.object({}),
+      handler: async () => textResult(await m.serverTime())
+    },
+    {
+      name: "spot_exchange_info",
+      description: "Get Spot exchange trading rules and symbol metadata (status, base/quote assets, filters, permissions).",
+      inputSchema: z13.object({}),
+      handler: async () => textResult(await m.exchangeInfo())
+    },
+    {
+      name: "spot_ticker_price",
+      description: "Get the latest price for a Spot symbol.",
+      inputSchema: z13.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.tickerPrice(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "spot_ticker_24hr",
+      description: "Get 24-hour rolling price change statistics for a Spot symbol.",
+      inputSchema: z13.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.ticker24hr(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "spot_book_ticker",
+      description: "Get the best bid/ask (top of book) for a Spot symbol.",
+      inputSchema: z13.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.bookTicker(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "spot_order_book",
+      description: "Get the Spot order book depth for a symbol (limits 5/10/20/50/100/500/1000/5000).",
+      inputSchema: z13.object({
+        symbol: spotSymbol,
+        limit: z13.enum(["5", "10", "20", "50", "100", "500", "1000", "5000"]).default("100")
+      }),
+      handler: async ({ symbol: symbol3, limit: limit4 }) => textResult(await m.depth(normalizeSymbol(symbol3), Number(limit4)))
+    },
+    {
+      name: "spot_recent_trades",
+      description: "Get the most recent executed trades for a Spot symbol.",
+      inputSchema: z13.object({ symbol: spotSymbol, limit: limit2.default(500) }),
+      handler: async ({ symbol: symbol3, limit: limit4 }) => textResult(await m.trades(normalizeSymbol(symbol3), Number(limit4)))
+    },
+    {
+      name: "spot_historical_trades",
+      description: "Get older Spot trades for a symbol by fromId.",
+      inputSchema: z13.object({ symbol: spotSymbol, limit: limit2.default(500), fromId: z13.number().int().positive().optional() }),
+      handler: async ({ symbol: symbol3, limit: limit4, fromId }) => textResult(await m.historicalTrades(normalizeSymbol(symbol3), { limit: Number(limit4), fromId }))
+    },
+    {
+      name: "spot_agg_trades",
+      description: "Get compressed/aggregate Spot trades for a symbol within an optional time window.",
+      inputSchema: z13.object({ symbol: spotSymbol, limit: limit2.default(500), startTime: startTime3, endTime: endTime3 }),
+      handler: async ({ symbol: symbol3, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.aggTrades(normalizeSymbol(symbol3), { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "spot_klines",
+      description: "Get Spot candlesticks (OHLCV). Intervals 1m\u20261M; max 1000 per request.",
+      inputSchema: z13.object({ symbol: spotSymbol, interval: KlineIntervalSchema, limit: limit2.default(500), startTime: startTime3, endTime: endTime3 }),
+      handler: async ({ symbol: symbol3, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.klines(normalizeSymbol(symbol3), interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "spot_ui_klines",
+      description: "Get Spot candlesticks via the optimized uiKlines endpoint (same shape as spot_klines).",
+      inputSchema: z13.object({ symbol: spotSymbol, interval: KlineIntervalSchema, limit: limit2.default(500), startTime: startTime3, endTime: endTime3 }),
+      handler: async ({ symbol: symbol3, interval, limit: limit4, startTime: startTime5, endTime: endTime5 }) => textResult(await m.uiKlines(normalizeSymbol(symbol3), interval, { limit: Number(limit4), startTime: startTime5, endTime: endTime5 }))
+    },
+    {
+      name: "spot_avg_price",
+      description: "Get the current average price (5-minute rolling average) for a Spot symbol.",
+      inputSchema: z13.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await m.avgPrice(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "spot_rolling_window_ticker",
+      description: "Get rolling-window price change statistics (1d/7d/30d). Omit symbol for all symbols.",
+      inputSchema: z13.object({
+        symbol: optionalSymbol2,
+        windowSize: z13.enum(["1d", "7d", "30d"]).optional()
+      }),
+      handler: async ({ symbol: symbol3, windowSize }) => textResult(await m.rollingWindowTicker(symbol3 ? normalizeSymbol(symbol3) : void 0, windowSize))
+    },
+    {
+      name: "spot_trading_day_ticker",
+      description: "Get the Spot trading-day ticker (open/close/high/low/volume by UTC day). Omit symbol for all symbols.",
+      inputSchema: z13.object({ symbol: optionalSymbol2, timeZone: z13.string().optional(), type: z13.enum(["FULL", "MINI"]).optional() }),
+      handler: async ({ symbol: symbol3, timeZone, type }) => textResult(await m.tradingDayTicker(symbol3 ? normalizeSymbol(symbol3) : void 0, { timeZone, type }))
+    },
+    // ---- Account (signed) ----
+    {
+      name: "spot_account",
+      description: "Get the Spot account: balances (free/locked), commissions, permissions (signed).",
+      inputSchema: z13.object({}),
+      handler: async () => textResult(await a.account())
+    },
+    {
+      name: "spot_my_trades",
+      description: "Get the Spot account trade list (filled trades) for a symbol with optional time range (signed).",
+      inputSchema: z13.object({ symbol: spotSymbol, orderId: z13.number().int().positive().optional(), startTime: startTime3, endTime: endTime3, fromId: z13.number().int().positive().optional(), limit: limit2.default(500) }),
+      handler: async ({ symbol: symbol3, orderId, startTime: startTime5, endTime: endTime5, fromId, limit: limit4 }) => textResult(await a.myTrades(normalizeSymbol(symbol3), { orderId, startTime: startTime5, endTime: endTime5, fromId, limit: Number(limit4) }))
+    },
+    {
+      name: "spot_my_prevented_matches",
+      description: "Get Spot orders that were expired by the self-trade-prevention (STP) mechanism (signed).",
+      inputSchema: z13.object({ symbol: spotSymbol, preventedMatchId: z13.number().int().positive().optional(), orderId: z13.number().int().positive().optional(), limit: limit2.default(500) }),
+      handler: async ({ symbol: symbol3, preventedMatchId, orderId, limit: limit4 }) => textResult(await a.myPreventedMatches(normalizeSymbol(symbol3), { preventedMatchId, orderId, limit: Number(limit4) }))
+    },
+    {
+      name: "spot_account_commission",
+      description: "Get the Spot account commission rates for a symbol (signed).",
+      inputSchema: z13.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await a.accountCommission(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "spot_rate_limit_order",
+      description: "Query the current Spot order rate limit usage (signed).",
+      inputSchema: z13.object({}),
+      handler: async () => textResult(await a.rateLimitOrder())
+    },
+    // ---- Trading (signed) ----
+    {
+      name: "spot_new_order",
+      description: "Place a new Spot order. Types: LIMIT, MARKET, LIMIT_MAKER, STOP_LOSS, STOP_LOSS_LIMIT, TAKE_PROFIT, TAKE_PROFIT_LIMIT. For MARKET orders use quantity OR quoteOrderQty. Signed.",
+      inputSchema: spotOrderParamsSchema,
+      handler: async (args) => textResult(await t.createOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "spot_test_order",
+      description: "Validate a Spot order without submitting it. Signed.",
+      inputSchema: spotOrderParamsSchema,
+      handler: async (args) => textResult(await t.testOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "spot_get_order",
+      description: "Query a specific Spot order by orderId or client order id. Signed.",
+      inputSchema: z13.object({ symbol: spotSymbol, orderId: z13.number().int().positive().optional(), origClientOrderId: z13.string().optional() }),
+      handler: async ({ symbol: symbol3, orderId, origClientOrderId }) => textResult(await t.getOrder(normalizeSymbol(symbol3), { orderId, origClientOrderId }))
+    },
+    {
+      name: "spot_cancel_order",
+      description: "Cancel a specific open Spot order by orderId or client order id. Signed.",
+      inputSchema: z13.object({ symbol: spotSymbol, orderId: z13.number().int().positive().optional(), origClientOrderId: z13.string().optional(), newClientOrderId: z13.string().optional() }),
+      handler: async ({ symbol: symbol3, orderId, origClientOrderId, newClientOrderId }) => textResult(await t.cancelOrder(normalizeSymbol(symbol3), { orderId, origClientOrderId, newClientOrderId }))
+    },
+    {
+      name: "spot_open_orders",
+      description: "Get all current open Spot orders, for one symbol or all symbols. Signed.",
+      inputSchema: z13.object({ symbol: optionalSymbol2 }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.getOpenOrders(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "spot_all_orders",
+      description: "Get historical Spot orders for a symbol with optional time range. Signed.",
+      inputSchema: z13.object({ symbol: spotSymbol, orderId: z13.number().int().positive().optional(), startTime: startTime3, endTime: endTime3, limit: limit2 }),
+      handler: async ({ symbol: symbol3, orderId, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await t.getAllOrders(normalizeSymbol(symbol3), { orderId, startTime: startTime5, endTime: endTime5, limit: limit4 }))
+    },
+    {
+      name: "spot_cancel_open_orders",
+      description: "Cancel all open Spot orders for a symbol. Signed.",
+      inputSchema: z13.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.cancelOpenOrders(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "spot_cancel_replace_order",
+      description: "Cancel an existing Spot order and place a new one on the same symbol (cancel-replace). Signed.",
+      inputSchema: z13.object({
+        symbol: spotSymbol,
+        side,
+        type: z13.enum(["LIMIT", "MARKET", "STOP_LOSS", "STOP_LOSS_LIMIT", "TAKE_PROFIT", "TAKE_PROFIT_LIMIT"]),
+        cancelReplaceMode: z13.enum(["STOP_ON_FAILURE", "ALLOW_FAILURE"]).default("STOP_ON_FAILURE"),
+        cancelOrderId: z13.number().int().positive().optional(),
+        cancelOrigClientOrderId: z13.string().optional(),
+        cancelNewClientOrderId: z13.string().optional(),
+        quantity: z13.union([z13.string(), z13.number()]).optional(),
+        price: z13.union([z13.string(), z13.number()]).optional(),
+        timeInForce: z13.enum(["GTC", "IOC", "FOK"]).optional(),
+        newClientOrderId: z13.string().optional()
+      }),
+      handler: async (args) => textResult(await t.cancelReplaceOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "spot_new_oco_order",
+      description: "Place a new Spot OCO (one-cancels-other) order: a stop-loss limit + a limit-maker take-profit. Signed.",
+      inputSchema: z13.object({
+        symbol: spotSymbol,
+        side,
+        quantity: z13.union([z13.string(), z13.number()]).describe("Total base-asset quantity for both legs"),
+        price: z13.union([z13.string(), z13.number()]).describe("Limit (take-profit) price"),
+        stopPrice: z13.union([z13.string(), z13.number()]).describe("Stop-loss trigger price"),
+        stopLimitPrice: z13.union([z13.string(), z13.number()]).optional().describe("Stop-loss limit price (defaults to stopPrice)"),
+        stopLimitTimeInForce: z13.enum(["GTC", "IOC", "FOK"]).optional(),
+        listClientOrderId: z13.string().optional(),
+        limitClientOrderId: z13.string().optional(),
+        stopClientOrderId: z13.string().optional()
+      }),
+      handler: async (args) => textResult(await t.createOCOOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "spot_cancel_oco_order",
+      description: "Cancel an entire Spot OCO order list by orderListId or listClientOrderId. Signed.",
+      inputSchema: z13.object({ symbol: spotSymbol, orderListId: z13.number().int().positive().optional(), listClientOrderId: z13.string().optional(), newClientOrderId: z13.string().optional() }),
+      handler: async ({ symbol: symbol3, orderListId, listClientOrderId, newClientOrderId }) => textResult(await t.cancelOCOOrder(normalizeSymbol(symbol3), { orderListId, listClientOrderId, newClientOrderId }))
+    },
+    {
+      name: "spot_get_oco_order",
+      description: "Query a Spot OCO order list by orderListId or listClientOrderId. Signed.",
+      inputSchema: z13.object({ symbol: spotSymbol, orderListId: z13.number().int().positive().optional(), origClientOrderId: z13.string().optional() }),
+      handler: async ({ symbol: symbol3, orderListId, origClientOrderId }) => textResult(await t.getOCOOrder(normalizeSymbol(symbol3), { orderListId, origClientOrderId }))
+    },
+    {
+      name: "spot_open_oco_orders",
+      description: "Get all current open Spot OCO order lists. Signed.",
+      inputSchema: z13.object({}),
+      handler: async () => textResult(await t.getOpenOCOOrders())
+    },
+    {
+      name: "spot_all_oco_orders",
+      description: "Get historical Spot OCO order lists for a symbol with optional time range. Signed.",
+      inputSchema: z13.object({ symbol: spotSymbol, fromId: z13.number().int().positive().optional(), startTime: startTime3, endTime: endTime3, limit: limit2 }),
+      handler: async ({ symbol: symbol3, fromId, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await t.getAllOCOOrders(normalizeSymbol(symbol3), { fromId, startTime: startTime5, endTime: endTime5, limit: limit4 }))
+    },
+    {
+      name: "spot_cancel_open_oco_orders",
+      description: "Cancel all open Spot OCO order lists for a symbol. Signed.",
+      inputSchema: z13.object({ symbol: spotSymbol }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.cancelOpenOCOOrders(normalizeSymbol(symbol3)))
+    },
+    // ---- User data stream (signed) ----
+    {
+      name: "spot_ws_start_user_stream",
+      description: "Start the Spot user data stream: creates a listenKey, connects the private WebSocket, and begins keep-alive. Emits executionReport, outboundAccountPosition, balanceUpdate, listStatus.",
+      inputSchema: z13.object({}),
+      handler: async () => textResult({ listenKey: await client.startSpotUserStream() })
+    },
+    {
+      name: "spot_ws_stop_user_stream",
+      description: "Stop the Spot user data stream: closes the private WebSocket and invalidates the listenKey.",
+      inputSchema: z13.object({}),
+      handler: async () => {
+        client.closeSpotUserStream();
+        return textResult({ stopped: true });
+      }
+    }
+  ];
+  return tools;
+}
+
+// src/tools/trading.tools.ts
+import { z as z14 } from "zod";
+var symbol2 = z14.string().min(1).describe("USD-M pair, e.g. BTCUSDT");
+var optionalSymbol3 = z14.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional();
+var limit3 = z14.number().int().positive().max(1e3).default(100);
+var startTime4 = z14.number().int().positive().optional();
+var endTime4 = z14.number().int().positive().optional();
+var side2 = z14.enum(["BUY", "SELL"]);
+var positionSide = z14.enum(["BOTH", "LONG", "SHORT"]).optional();
+var orderParamsSchema = z14.object({
+  symbol: symbol2,
+  side: side2,
+  type: z14.enum(["LIMIT", "MARKET", "STOP", "STOP_MARKET", "TAKE_PROFIT", "TAKE_PROFIT_MARKET", "TRAILING_STOP_MARKET"]),
+  quantity: z14.union([z14.string(), z14.number()]).describe("Order quantity in base asset"),
+  price: z14.union([z14.string(), z14.number()]).optional().describe("Required for LIMIT and STOP/TAKE_PROFIT (limit-triggered) types"),
+  timeInForce: z14.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+  stopPrice: z14.union([z14.string(), z14.number()]).optional().describe("Trigger price for STOP/STOP_MARKET/TAKE_PROFIT/TAKE_PROFIT_MARKET"),
+  reduceOnly: z14.boolean().optional().describe("true = only reduces the position, never opens"),
+  positionSide,
+  newClientOrderId: z14.string().optional(),
+  closePosition: z14.boolean().optional().describe("Close the full position on trigger (mutually exclusive with quantity)"),
+  newOrderRespType: z14.enum(["ACK", "RESULT"]).optional(),
+  priceProtect: z14.boolean().optional(),
+  workingType: z14.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional().describe("Trigger price basis; default CONTRACT_PRICE"),
+  callbackRate: z14.union([z14.string(), z14.number()]).optional().describe("Percent callback for TRAILING_STOP_MARKET, e.g. 0.5"),
+  activationPrice: z14.union([z14.string(), z14.number()]).optional().describe("Activation price for TRAILING_STOP_MARKET"),
+  selfTradePreventionMode: z14.enum(["NONE", "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"]).optional(),
+  goodTillDate: z14.number().int().optional().describe("Timestamp when a GTD order expires")
+});
+function tradingTools(client) {
+  const t = client.futures.trading;
+  return [
+    {
+      name: "futures_new_order",
+      description: "Place a new futures order. Types: LIMIT, MARKET, STOP, STOP_MARKET, TAKE_PROFIT, TAKE_PROFIT_MARKET, TRAILING_STOP_MARKET. Use STOP_MARKET as the take-profit/stop-loss trigger and LIMIT for the actual fill. Signed.",
+      inputSchema: orderParamsSchema,
+      handler: async (args) => textResult(await t.createOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "futures_test_order",
+      description: "Validate a new order without submitting it. Returns 200 on success; use to validate fields and margin before real orders. Signed.",
+      inputSchema: orderParamsSchema,
+      handler: async (args) => textResult(await t.createTestOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "futures_get_order",
+      description: "Query a specific order by orderId or client order id. Signed.",
+      inputSchema: z14.object({ symbol: symbol2, orderId: z14.number().int().positive().optional(), origClientOrderId: z14.string().optional() }),
+      handler: async ({ symbol: symbol3, orderId, origClientOrderId }) => textResult(await t.getOrder(normalizeSymbol(symbol3), { orderId, origClientOrderId }))
+    },
+    {
+      name: "futures_cancel_order",
+      description: "Cancel a specific open order by orderId or client order id. Signed.",
+      inputSchema: z14.object({ symbol: symbol2, orderId: z14.number().int().positive().optional(), origClientOrderId: z14.string().optional() }),
+      handler: async ({ symbol: symbol3, orderId, origClientOrderId }) => textResult(await t.cancelOrder(normalizeSymbol(symbol3), { orderId, origClientOrderId }))
+    },
+    {
+      name: "futures_get_open_order",
+      description: "Query a current open order (must exist in the open order book). Signed.",
+      inputSchema: z14.object({ symbol: symbol2, orderId: z14.number().int().positive().optional(), origClientOrderId: z14.string().optional() }),
+      handler: async ({ symbol: symbol3, orderId, origClientOrderId }) => textResult(await t.getCurrentOrder(normalizeSymbol(symbol3), { orderId, origClientOrderId }))
+    },
+    {
+      name: "futures_open_orders",
+      description: "Get all current open orders, for one symbol or all symbols. Signed.",
+      inputSchema: z14.object({ symbol: optionalSymbol3 }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.getOpenOrders(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_all_orders",
+      description: "Get historical orders for a symbol with optional time range (last 7 days by default). Signed.",
+      inputSchema: z14.object({ symbol: symbol2, orderId: z14.number().int().positive().optional(), startTime: startTime4, endTime: endTime4, limit: limit3 }),
+      handler: async ({ symbol: symbol3, orderId, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await t.getAllOrders(normalizeSymbol(symbol3), { orderId, startTime: startTime5, endTime: endTime5, limit: limit4 }))
+    },
+    {
+      name: "futures_cancel_all_orders",
+      description: "Cancel all open orders for a symbol. Signed.",
+      inputSchema: z14.object({ symbol: symbol2 }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.cancelAllOpenOrders(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_modify_order",
+      description: "Modify an open order (price/quantity/stopPrice). Cannot modify when position side is BOTH and closePosition is true. Signed.",
+      inputSchema: z14.object({
+        symbol: symbol2,
+        side: side2,
+        quantity: z14.union([z14.string(), z14.number()]),
+        price: z14.union([z14.string(), z14.number()]).optional(),
+        orderId: z14.number().int().positive().optional(),
+        origClientOrderId: z14.string().optional(),
+        stopPrice: z14.union([z14.string(), z14.number()]).optional(),
+        timeInForce: z14.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+        positionSide,
+        newClientOrderId: z14.string().optional()
+      }),
+      handler: async (args) => textResult(await t.modifyOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "futures_order_modify_history",
+      description: "Get order modification history for a symbol. Signed.",
+      inputSchema: z14.object({ symbol: symbol2, startTime: startTime4, endTime: endTime4, limit: limit3 }),
+      handler: async ({ symbol: symbol3, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await t.getOrderModifyHistory(normalizeSymbol(symbol3), { startTime: startTime5, endTime: endTime5, limit: limit4 }))
+    },
+    {
+      name: "futures_batch_orders",
+      description: "Place up to 5 orders in one request (array of order objects, max 30 per minute per symbol). Signed.",
+      inputSchema: z14.object({ orders: z14.array(orderParamsSchema).min(1).max(5) }),
+      handler: async (args) => {
+        const mapped = args.orders.map((o) => ({ ...o, symbol: normalizeSymbol(o.symbol) }));
+        return textResult(await t.createBatchOrders(mapped));
+      }
+    },
+    {
+      name: "futures_cancel_batch_orders",
+      description: "Cancel multiple orders at once (up to 10 by orderId list or client order id list). Signed.",
+      inputSchema: z14.object({
+        symbol: symbol2,
+        orderIdList: z14.array(z14.number().int().positive()).max(10).optional(),
+        origClientOrderIdList: z14.array(z14.string()).max(10).optional()
+      }),
+      handler: async ({ symbol: symbol3, orderIdList, origClientOrderIdList }) => textResult(await t.cancelBatchOrders(normalizeSymbol(symbol3), { orderIdList, origClientOrderIdList }))
+    },
+    {
+      name: "futures_set_leverage",
+      description: "Change initial leverage for a symbol (1-125, within bracket). Signed.",
+      inputSchema: z14.object({ symbol: symbol2, leverage: z14.number().int().min(1).max(125) }),
+      handler: async ({ symbol: symbol3, leverage }) => textResult(await t.setLeverage(normalizeSymbol(symbol3), leverage))
+    },
+    {
+      name: "futures_set_margin_type",
+      description: "Change margin type for a symbol: isolated or cross. Only allowed when no open position for the symbol. Signed.",
+      inputSchema: z14.object({ symbol: symbol2, marginType: z14.enum(["isolated", "cross"]) }),
+      handler: async ({ symbol: symbol3, marginType }) => textResult(await t.setMarginType(normalizeSymbol(symbol3), marginType))
+    },
+    {
+      name: "futures_modify_position_margin",
+      description: "Add or reduce isolated position margin. marginType: 1 = add margin, 2 = reduce margin. Signed.",
+      inputSchema: z14.object({ symbol: symbol2, amount: z14.number().positive(), marginType: z14.enum(["1", "2"]).describe("1 = add margin, 2 = reduce margin") }),
+      handler: async ({ symbol: symbol3, amount, marginType }) => textResult(await t.modifyPositionMargin(normalizeSymbol(symbol3), amount, Number(marginType)))
+    },
+    {
+      name: "futures_countdown_cancel_all",
+      description: "Auto-cancel all open orders for a symbol after countdownTime ms (0 = cancel the countdown). Emergency circuit breaker. Signed.",
+      inputSchema: z14.object({ symbol: symbol2, countdownTime: z14.number().int().min(100).max(6e4) }),
+      handler: async ({ symbol: symbol3, countdownTime }) => textResult(await t.setCountdownCancelAll(normalizeSymbol(symbol3), countdownTime))
+    },
+    {
+      name: "futures_new_algo_order",
+      description: "Place a conditional algo order (CONDITIONAL or VP). CONDITIONAL supports STOP_MARKET/TAKE_PROFIT_MARKET types with triggerPrice; VP is a volume-participation order with urgency and quantity. Signed.",
+      inputSchema: z14.object({
+        algoType: z14.enum(["CONDITIONAL", "VP"]),
+        symbol: symbol2,
+        side: side2,
+        positionSide,
+        type: z14.enum(["STOP_MARKET", "TAKE_PROFIT_MARKET", "LIMIT"]).describe("For CONDITIONAL: STOP_MARKET/TAKE_PROFIT_MARKET. For VP: LIMIT"),
+        quantity: z14.union([z14.string(), z14.number()]),
+        triggerPrice: z14.union([z14.string(), z14.number()]).optional().describe("Required for CONDITIONAL"),
+        price: z14.union([z14.string(), z14.number()]).optional(),
+        timeInForce: z14.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+        workingType: z14.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional(),
+        priceProtect: z14.boolean().optional(),
+        reduceOnly: z14.boolean().optional(),
+        closePosition: z14.boolean().optional(),
+        urgency: z14.enum(["LOW", "MEDIUM", "HIGH"]).optional().describe("Required for VP"),
+        clientAlgoId: z14.string().optional()
+      }),
+      handler: async (args) => textResult(await t.createAlgoOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
+    },
+    {
+      name: "futures_cancel_algo_order",
+      description: "Cancel an open algo order by algoId or clientAlgoId. Signed.",
+      inputSchema: z14.object({ symbol: symbol2, algoId: z14.number().int().positive().optional(), clientAlgoId: z14.string().optional() }),
+      handler: async ({ symbol: symbol3, algoId, clientAlgoId }) => textResult(await t.cancelAlgoOrder(normalizeSymbol(symbol3), { algoId, clientAlgoId }))
+    },
+    {
+      name: "futures_cancel_all_algo_orders",
+      description: "Cancel all open algo orders for a symbol. Signed.",
+      inputSchema: z14.object({ symbol: symbol2 }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.cancelAllOpenAlgoOrders(normalizeSymbol(symbol3)))
+    },
+    {
+      name: "futures_get_algo_order",
+      description: "Query an algo order by algoId or clientAlgoId. Signed.",
+      inputSchema: z14.object({ symbol: symbol2, algoId: z14.number().int().positive().optional(), clientAlgoId: z14.string().optional() }),
+      handler: async ({ symbol: symbol3, algoId, clientAlgoId }) => textResult(await t.getAlgoOrder(normalizeSymbol(symbol3), { algoId, clientAlgoId }))
+    },
+    {
+      name: "futures_open_algo_orders",
+      description: "Get all current open algo orders, optionally filtered by symbol. Signed.",
+      inputSchema: z14.object({ symbol: optionalSymbol3 }),
+      handler: async ({ symbol: symbol3 }) => textResult(await t.getOpenAlgoOrders(symbol3 ? normalizeSymbol(symbol3) : void 0))
+    },
+    {
+      name: "futures_all_algo_orders",
+      description: "Get historical algo orders for a symbol with optional time range. Signed.",
+      inputSchema: z14.object({ symbol: symbol2, startTime: startTime4, endTime: endTime4, limit: limit3 }),
+      handler: async ({ symbol: symbol3, startTime: startTime5, endTime: endTime5, limit: limit4 }) => textResult(await t.getAllAlgoOrders(normalizeSymbol(symbol3), { startTime: startTime5, endTime: endTime5, limit: limit4 }))
+    },
+    {
+      name: "futures_convert_exchange_info",
+      description: "List asset pairs eligible for futures Convert, optionally filtered by fromAsset/toAsset.",
+      inputSchema: z14.object({ fromAsset: z14.string().optional(), toAsset: z14.string().optional() }),
+      handler: async ({ fromAsset, toAsset }) => textResult(await t.convertExchangeInfo({ fromAsset, toAsset }))
+    },
+    {
+      name: "futures_convert_get_quote",
+      description: "Request a Convert quote between two assets (quote expires quickly; accept with futures_convert_accept_quote). Signed.",
+      inputSchema: z14.object({
+        fromAsset: z14.string().min(1),
+        toAsset: z14.string().min(1),
+        fromAmount: z14.number().positive().optional(),
+        toAmount: z14.number().positive().optional(),
+        validTime: z14.enum(["10s", "30s", "1m", "2m"]).optional()
+      }),
+      handler: async (args) => textResult(await t.convertGetQuote(args))
+    },
+    {
+      name: "futures_convert_accept_quote",
+      description: "Accept a previously requested Convert quote by quoteId. Signed.",
+      inputSchema: z14.object({ quoteId: z14.string().min(1) }),
+      handler: async ({ quoteId }) => textResult(await t.convertAcceptQuote(quoteId))
+    },
+    {
+      name: "futures_convert_order_status",
+      description: "Query the status of a Convert order by orderId or quoteId. Signed.",
+      inputSchema: z14.object({ orderId: z14.string().optional(), quoteId: z14.string().optional() }),
+      handler: async ({ orderId, quoteId }) => textResult(await t.convertOrderStatus({ orderId, quoteId }))
+    }
+  ];
+}
+
+// src/tools/ws.tools.ts
+import { z as z15 } from "zod";
+var buffers = /* @__PURE__ */ new Map();
+var MAX_BUFFER = 500;
+function bufferFor(client) {
+  let buffer = buffers.get(client);
+  if (!buffer) {
+    buffer = { subscriptions: /* @__PURE__ */ new Set(), events: [] };
+    buffers.set(client, buffer);
+    client.futures.ws.on("message", (stream, payload) => {
+      buffer.events.push({ stream, payload, ts: Date.now() });
+      if (buffer.events.length > MAX_BUFFER) buffer.events.splice(0, buffer.events.length - MAX_BUFFER);
+    });
+  }
+  return buffer;
+}
+function getBufferedWsEvents(client, limit4 = 50) {
+  return bufferFor(client).events.slice(-limit4);
+}
+function clearBufferedWsEvents(client) {
+  bufferFor(client).events = [];
+}
+function wsTools(client) {
+  const buffer = bufferFor(client);
+  return [
+    {
+      name: "futures_ws_subscribe",
+      description: "Subscribe to real-time market data streams. Topic format: <symbol>@<stream>, e.g. btcusdt@aggTrade, btcusdt@kline_1m, btcusdt@depth20, btcusdt@markPrice@1s, btcusdt@bookTicker, btcusdt@ticker, btcusdt@miniTicker, btcusdt@forceOrder, or all-market topics !ticker@arr, !bookTicker, !markPrice@arr, !forceOrder@arr, !miniTicker@arr. Multiple topics can be passed at once.",
+      inputSchema: z15.object({
+        topics: z15.array(z15.string().min(1)).min(1).describe('Stream topics, e.g. ["btcusdt@aggTrade", "btcusdt@kline_1m"]')
+      }),
+      handler: async ({ topics }) => {
+        const normalized = topics.map((t) => t.trim().toLowerCase());
+        client.futures.ws.subscribe(normalized);
+        normalized.forEach((t) => buffer.subscriptions.add(t));
+        return textResult({ subscribed: normalized, active: [...buffer.subscriptions] });
+      }
+    },
+    {
+      name: "futures_ws_unsubscribe",
+      description: "Unsubscribe from previously subscribed market data streams.",
+      inputSchema: z15.object({ topics: z15.array(z15.string().min(1)).min(1) }),
+      handler: async ({ topics }) => {
+        const normalized = topics.map((t) => t.trim().toLowerCase());
+        client.futures.ws.unsubscribe(normalized);
+        normalized.forEach((t) => buffer.subscriptions.delete(t));
+        return textResult({ unsubscribed: normalized, active: [...buffer.subscriptions] });
+      }
+    },
+    {
+      name: "futures_ws_subscriptions",
+      description: "List the currently subscribed WebSocket market streams for this client.",
+      inputSchema: z15.object({}),
+      handler: async () => textResult({ active: [...buffer.subscriptions] })
+    },
+    {
+      name: "futures_ws_events",
+      description: "Read the buffered real-time payloads received since the last read for the subscribed streams (aggregate trades, klines, depth deltas, mark price, book tickers, tickers, force orders). Payloads are parsed; depth deltas must be applied to a snapshot from futures_order_book.",
+      inputSchema: z15.object({ limit: z15.number().int().min(1).max(200).default(50) }),
+      handler: async ({ limit: limit4 }) => textResult(getBufferedWsEvents(client, limit4))
+    },
+    {
+      name: "futures_ws_clear_events",
+      description: "Clear the buffered WebSocket events so the next read only returns new payloads.",
+      inputSchema: z15.object({}),
+      handler: async () => {
+        clearBufferedWsEvents(client);
+        return textResult({ cleared: true });
+      }
+    },
+    {
+      name: "futures_ws_start_user_stream",
+      description: "Start the user data stream: creates a listenKey, connects the private WebSocket, and begins a 30-minute keep-alive. Emits private events (ACCOUNT_UPDATE, ORDER_TRADE_UPDATE, MARGIN_CALL, ACCOUNT_CONFIG_UPDATE, listenKeyExpired) that the application can consume from the client.",
+      inputSchema: z15.object({}),
+      handler: async () => textResult({ listenKey: await client.startUserStream() })
+    },
+    {
+      name: "futures_ws_stop_user_stream",
+      description: "Stop the user data stream: closes the private WebSocket and invalidates the listenKey.",
+      inputSchema: z15.object({}),
+      handler: async () => {
+        client.closeUserStream();
+        return textResult({ stopped: true });
+      }
+    },
+    {
+      name: "futures_ws_api_order_status",
+      description: "Query an order via the signed WebSocket API (order.status) \u2014 lower-latency alternative to futures_get_order.",
+      inputSchema: z15.object({
+        symbol: z15.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        orderId: z15.number().int().positive().optional(),
+        origClientOrderId: z15.string().optional()
+      }),
+      handler: async ({ symbol: symbol3, orderId, origClientOrderId }) => textResult(await client.futures.wsApi.orderStatus({ symbol: normalizeSymbol(symbol3), orderId, origClientOrderId }))
+    },
+    {
+      name: "futures_ws_api_account_status",
+      description: "Get account info via the signed WebSocket API (account.status).",
+      inputSchema: z15.object({}),
+      handler: async () => textResult(await client.futures.wsApi.accountStatus())
+    },
+    {
+      name: "futures_ws_api_account_position",
+      description: "Get current positions via the signed WebSocket API (account.position).",
+      inputSchema: z15.object({ symbol: z15.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional() }),
+      handler: async ({ symbol: symbol3 }) => textResult(await client.futures.wsApi.accountPosition(symbol3 ? { symbol: normalizeSymbol(symbol3) } : {}))
+    },
+    {
+      name: "futures_ws_api_user_data_stream_start",
+      description: "Create a listenKey via the signed WebSocket API (userDataStream.start) \u2014 no REST call required.",
+      inputSchema: z15.object({}),
+      handler: async () => textResult(await client.futures.wsApi.userDataStreamStart())
+    },
+    {
+      name: "futures_ws_api_user_data_stream_stop",
+      description: "Invalidate a listenKey via the signed WebSocket API (userDataStream.stop).",
+      inputSchema: z15.object({ listenKey: z15.string().min(1) }),
+      handler: async ({ listenKey }) => textResult(await client.futures.wsApi.userDataStreamStop(listenKey))
+    },
+    {
+      name: "futures_ws_api_ticker_price",
+      description: "Get latest price via the unsigned WebSocket API (ticker.price); omit symbol for all symbols.",
+      inputSchema: z15.object({ symbol: z15.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional() }),
+      handler: async ({ symbol: symbol3 }) => textResult(await client.futures.wsApi.tickerPrice(symbol3 ? { symbol: normalizeSymbol(symbol3) } : {}))
+    },
+    {
+      name: "futures_ws_api_order_book",
+      description: "Get order-book depth via the unsigned WebSocket API (depth).",
+      inputSchema: z15.object({
+        symbol: z15.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        limit: z15.enum(["5", "10", "20", "50", "100", "500", "1000"]).optional()
+      }),
+      handler: async ({ symbol: symbol3, limit: limit4 }) => textResult(await client.futures.wsApi.depth({ symbol: normalizeSymbol(symbol3), limit: limit4 }))
+    }
+  ];
+}
+
+// src/tools/index.ts
+function createFuturesToolkit(client) {
+  const market = marketDataTools(client);
+  const account = accountTools(client);
+  const trading = tradingTools(client);
+  const spot = spotTools(client);
+  const ws = wsTools(client);
+  const derived = derivedTools(client);
+  const paperContext = createPaperContext(client);
+  const paper = paperTools(paperContext);
+  return {
+    client,
+    tools: [...market, ...account, ...trading, ...spot, ...ws, ...derived, ...paper],
+    market,
+    account,
+    trading,
+    spot,
+    ws,
+    derived,
+    paper,
+    paperContext
+  };
+}
+function toolkitToFormats(toolkit) {
+  return {
+    openai: toToolList(toolkit.tools, "openai"),
+    anthropic: toToolList(toolkit.tools, "anthropic"),
+    mcp: toToolList(toolkit.tools, "mcp")
+  };
+}
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+function createBinanceMcpServer(client) {
+  const server = new McpServer({ name: "binance-sdk", version: "3.0.0" });
+  const toolkit = createFuturesToolkit(client);
+  toolkit.tools.forEach((tool) => {
+    server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, async (args) => ({
+      content: [{ type: "text", text: String(await tool.handler(args, { env: "live", isSigned: true })) }]
+    }));
+  });
+  registerResources(server, client);
+  return server;
+}
+function registerResources(server, client) {
+  const json = (uri, data) => ({
+    contents: [{ uri, mimeType: "application/json", text: JSON.stringify(data, null, 2) }]
+  });
+  server.registerResource(
+    "futures-symbols",
+    "binance://futures/symbols",
+    {
+      title: "Futures Trading Symbols",
+      description: "Every tradeable USD-M futures symbol with its contract type and status",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const info = await client.futures.market.exchangeInfo();
+      return json(uri.href, info.symbols);
+    }
+  );
+  server.registerResource(
+    "futures-premium-index",
+    "binance://futures/premium-index",
+    {
+      title: "Premium Index",
+      description: "Mark price, index price and funding rate across all USD-M pairs",
+      mimeType: "application/json"
+    },
+    async (uri) => json(uri.href, await client.futures.data.assetIndex())
+  );
+  server.registerResource(
+    "spot-symbols",
+    "binance://spot/symbols",
+    {
+      title: "Spot Trading Symbols",
+      description: "Every tradeable Spot symbol with its status, base/quote assets and permissions",
+      mimeType: "application/json"
+    },
+    async (uri) => {
+      const info = await client.spot.market.exchangeInfo();
+      return json(uri.href, info.symbols);
+    }
+  );
+}
+
+// src/index.ts
+var VERSION = "2.1.0";
+export {
+  AccountAssetSchema,
+  AccountPositionSchema,
+  AccountSchema,
+  AggTradeSchema,
+  AggTradesResponseSchema,
+  AlgoOrderResponseSchema,
+  AlgoOrderSchema,
+  AlgoOrdersResponseSchema,
+  ApiTradingStatusSchema,
+  AvgPriceSchema,
+  BalanceSchema,
+  BalancesResponseSchema,
+  BaseWS,
+  BatchOrdersItemSchema,
+  BatchOrdersResponseSchema,
+  BinanceApiError,
+  BinanceAuthError,
+  BinanceClient,
+  BinanceError,
+  BookTickerSchema,
+  CommissionRateSchema,
+  CountdownCancelAllSchema,
+  CreateOrderParamsSchema,
+  DepthSnapshotSchema,
+  ExchangeInfoSchema,
+  ExchangeSymbolSchema,
+  FeeBurnStatusSchema,
+  FundingRateHistorySchema,
+  FundingRateSchema,
+  FuturesAccount,
+  FuturesData,
+  FuturesMarket,
+  FuturesMarketWS,
+  FuturesOps,
+  FuturesTrading,
+  FuturesUserWS,
+  HttpClient,
+  IncomeHistoryResponseSchema,
+  IncomeSchema,
+  KlineIntervalSchema,
+  KlineSchema,
+  KlinesResponseSchema,
+  LeverageBracketResponseSchema,
+  LeverageBracketSchema,
+  LeverageChangeSchema,
+  ListenKeySchema,
+  LongShortRatioEntrySchema,
+  LongShortRatioSchema,
+  MarginTypeChangeSchema,
+  MarketDataBase,
+  ModifyOrderParamsSchema,
+  MultiAssetsMarginSchema,
+  NetworkError,
+  NewOrderAckSchema,
+  OpenInterestHistEntrySchema,
+  OpenInterestHistSchema,
+  OpenInterestSchema,
+  OrderModifyHistoryEntrySchema,
+  OrderModifyHistorySchema,
+  OrderResponseSchema,
+  OrderSchema,
+  OrdersResponseSchema,
+  PaperTradingEngine,
+  PositionMarginChangeSchema,
+  PositionMarginHistoryEntrySchema,
+  PositionMarginHistorySchema,
+  PositionModeSchema,
+  PositionRiskResponseSchema,
+  PositionRiskSchema,
+  PremiumIndexSchema,
+  RateLimitError,
+  RateLimitOrderResponseSchema,
+  RateLimitOrderSchema,
+  SpotAccount,
+  SpotAccountSchema,
+  SpotBalanceSchema,
+  SpotBalanceUpdateSchema,
+  SpotExecutionReportSchema,
+  SpotListStatusSchema,
+  SpotMarket,
+  SpotMarketWS,
+  SpotOCOOrderAckResponseSchema,
+  SpotOCOOrderAckSchema,
+  SpotOCOOrdersResponseSchema,
+  SpotOrderResponseSchema,
+  SpotOrderSchema,
+  SpotOrdersResponseSchema,
+  SpotOutboundAccountPositionSchema,
+  SpotTradeSchema,
+  SpotTradesResponseSchema,
+  SpotTrading,
+  SpotUserDataStream,
+  SpotUserWS,
+  TakerLongShortRatioEntrySchema,
+  TakerLongShortRatioSchema,
+  Ticker24hrSchema,
+  TickerPriceSchema,
+  TradeSchema,
+  TradesResponseSchema,
+  UserDataAccountUpdateSchema,
+  UserDataMarginCallSchema,
+  UserDataOrderTradeUpdateSchema,
+  UserDataStream,
+  UserTradeSchema,
+  UserTradesResponseSchema,
+  VERSION,
+  WsAggTradePayloadSchema,
+  WsApi,
+  WsApiResponseSchema,
+  WsAssetIndexPayloadSchema,
+  WsBookTickerPayloadSchema,
+  WsCompositeIndexPayloadSchema,
+  WsDepthUpdatePayloadSchema,
+  WsForceOrderPayloadSchema,
+  WsKlinePayloadSchema,
+  WsMarkPricePayloadSchema,
+  WsMiniTickerPayloadSchema,
+  WsRollingWindowTickerPayloadSchema,
+  WsSpotAvgPricePayloadSchema,
+  WsTicker24hrPayloadSchema,
+  WsTradePayloadSchema,
+  accountTools,
+  createBinanceMcpServer,
+  createFuturesToolkit,
+  createPaperContext,
+  derivedTools,
+  floorToStep,
+  formatToDecimals,
+  getBufferedWsEvents,
+  marketDataTools,
+  paperTools,
+  parseSpotUserDataEvent,
+  parseUserDataEvent,
+  parseWsPayload,
+  resolveEnvironment,
+  roundToStep,
+  spotTools,
+  stepDecimals,
+  symbolRulesFrom,
+  textResult,
+  toAnthropicTool,
+  toJsonSchema,
+  toMCPTool,
+  toOpenAITool,
+  toToolList,
+  toolkitToFormats,
+  tradingTools,
+  wsTools
+};
+//# sourceMappingURL=index.js.map