@nemesis-oss/binance-sdk 1.0.0 → 2.0.0

package/dist/mcp/index.cjs

@@ -28,7 +28,6 @@ var import_node_http = __toESM(require("http"), 1);
 var import_stdio = require("@modelcontextprotocol/sdk/server/stdio.js");
 
 // src/client/HttpClient.ts
-var import_node_crypto = require("crypto");
 var import_axios = __toESM(require("axios"), 1);
 var import_bottleneck = __toESM(require("bottleneck"), 1);
 
@@ -51,18 +50,33 @@ var BinanceAuthError = class extends BinanceError {
 
 // src/errors/BinanceApiError.ts
 var BinanceApiError = class extends BinanceError {
-  constructor(message, code, status) {
+  constructor(message, code, status, context) {
     super(message);
     this.name = "BinanceApiError";
     this.code = code;
     this.status = status;
+    this.endpoint = context?.endpoint;
+    this.method = context?.method;
+    this.headers = context?.headers;
+  }
+  /** -1003 (way too many requests) or HTTP 429/418. */
+  isRateLimitError() {
+    return this.code === -1003 || this.status === 429 || this.status === 418;
+  }
+  /** -1021: request timestamp outside recvWindow, usually caused by local clock drift. */
+  isTimestampError() {
+    return this.code === -1021;
+  }
+  /** -2010: account has insufficient balance for the requested action. */
+  isInsufficientBalance() {
+    return this.code === -2010;
   }
 };
 
 // src/errors/RateLimitError.ts
 var RateLimitError = class extends BinanceApiError {
-  constructor(message, code, status, retryAfterMs) {
-    super(message, code, status);
+  constructor(message, code, status, retryAfterMs, context) {
+    super(message, code, status, context);
     this.name = "RateLimitError";
     this.retryAfterMs = retryAfterMs;
   }
@@ -77,16 +91,144 @@ var NetworkError = class extends BinanceError {
   }
 };
 
+// src/errors/PolicyViolationError.ts
+var PolicyViolationError = class extends BinanceError {
+  constructor(rule, message, method, endpoint, details) {
+    super(`Blocked by trading policy (${rule}): ${message} [${method} ${endpoint}]`);
+    this.name = "PolicyViolationError";
+    this.rule = rule;
+    this.method = method;
+    this.endpoint = endpoint;
+    this.details = details;
+  }
+};
+
+// src/errors/DryRunError.ts
+var DryRunError = class extends BinanceError {
+  constructor(method, endpoint, params = {}) {
+    super(`DRY RUN \u2014 request not sent: ${method} ${endpoint} ${JSON.stringify(params)}`);
+    this.name = "DryRunError";
+    this.method = method;
+    this.endpoint = endpoint;
+    this.params = params;
+  }
+  /** Human/LLM-readable description of the suppressed request. */
+  describe() {
+    return `Would have sent ${this.method} ${this.endpoint} with ${JSON.stringify(this.params)}`;
+  }
+};
+
+// src/client/RateLimitTracker.ts
+var WEIGHT_HEADER = /^x-mbx-used-weight-(.+)$/i;
+var ORDER_COUNT_HEADER = /^x-mbx-order-count-(.+)$/i;
+var RateLimitTracker = class {
+  constructor(options = {}) {
+    this.usage = {
+      usedWeight: 0,
+      usedWeightByInterval: {},
+      orderCountByInterval: {},
+      lastUpdated: 0
+    };
+    this.weightLimitPerMinute = options.weightLimitPerMinute ?? 6e3;
+    this.safetyMargin = options.safetyMargin ?? 0.8;
+  }
+  update(headers) {
+    if (!headers) return;
+    const usedWeightByInterval = {};
+    const orderCountByInterval = {};
+    for (const [key, value] of Object.entries(headers)) {
+      const weightMatch = key.match(WEIGHT_HEADER);
+      if (weightMatch?.[1]) {
+        usedWeightByInterval[weightMatch[1]] = Number(value);
+        continue;
+      }
+      const orderMatch = key.match(ORDER_COUNT_HEADER);
+      if (orderMatch?.[1]) {
+        orderCountByInterval[orderMatch[1]] = Number(value);
+      }
+    }
+    if (Object.keys(usedWeightByInterval).length === 0 && Object.keys(orderCountByInterval).length === 0) {
+      return;
+    }
+    this.usage = {
+      usedWeight: Math.max(0, ...Object.values(usedWeightByInterval)),
+      usedWeightByInterval,
+      orderCountByInterval,
+      lastUpdated: Date.now()
+    };
+  }
+  getUsage() {
+    return this.usage;
+  }
+  /**
+   * Milliseconds a caller should wait before its next request, based on the most recently
+   * observed 1-minute weight usage. Returns 0 when usage is stale or under the safety margin.
+   */
+  getThrottleDelayMs() {
+    if (this.safetyMargin >= 1) return 0;
+    const oneMinuteWeight = this.usage.usedWeightByInterval["1m"] ?? this.usage.usedWeight;
+    if (!oneMinuteWeight) return 0;
+    if (Date.now() - this.usage.lastUpdated > 6e4) return 0;
+    const threshold = this.weightLimitPerMinute * this.safetyMargin;
+    if (oneMinuteWeight < threshold) return 0;
+    const msIntoMinute = Date.now() % 6e4;
+    return 6e4 - msIntoMinute;
+  }
+};
+
+// src/client/Signer.ts
+var import_node_crypto = require("crypto");
+var Signer = class {
+  constructor(options) {
+    this.algorithm = options.algorithm ?? (options.privateKey ? "ED25519" : "HMAC");
+    this.apiSecret = options.apiSecret;
+    if (options.privateKey) {
+      this.privateKey = (0, import_node_crypto.createPrivateKey)(options.privateKey);
+    }
+  }
+  canSign() {
+    return this.algorithm === "HMAC" ? Boolean(this.apiSecret) : Boolean(this.privateKey);
+  }
+  sign(payload) {
+    switch (this.algorithm) {
+      case "HMAC": {
+        if (!this.apiSecret) throw new Error("apiSecret is required for HMAC signing");
+        return (0, import_node_crypto.createHmac)("sha256", this.apiSecret).update(payload).digest("hex");
+      }
+      case "ED25519": {
+        if (!this.privateKey) throw new Error("privateKey is required for ED25519 signing");
+        return (0, import_node_crypto.sign)(null, Buffer.from(payload), this.privateKey).toString("base64");
+      }
+      case "RSA": {
+        if (!this.privateKey) throw new Error("privateKey is required for RSA signing");
+        return (0, import_node_crypto.createSign)("RSA-SHA256").update(payload).sign(this.privateKey, "base64");
+      }
+      default: {
+        const exhaustive = this.algorithm;
+        throw new Error(`Unsupported signature algorithm: ${String(exhaustive)}`);
+      }
+    }
+  }
+};
+
 // 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));
 }
+function normalizeHeaders(headers) {
+  const result = {};
+  if (!headers || typeof headers !== "object") return result;
+  for (const [key, value] of Object.entries(headers)) {
+    if (value !== void 0 && value !== null) result[key.toLowerCase()] = String(value);
+  }
+  return result;
+}
 var HttpClient = class {
   constructor(options) {
     this.pendingRequests = 0;
+    this.timeOffsetMs = 0;
     this.apiKey = options.apiKey;
-    this.apiSecret = options.apiSecret;
     this.recvWindow = options.recvWindow ?? 5e3;
     this.timeoutMs = options.timeoutMs ?? 15e3;
     this.maxRetries = options.maxRetries ?? 3;
@@ -94,7 +236,22 @@ var HttpClient = class {
     this.retryBaseDelayMs = options.retryBaseDelayMs ?? 1e3;
     this.retryMaxDelayMs = options.retryMaxDelayMs ?? 3e4;
     this.retryFactor = options.retryFactor ?? 2;
-    this.axios = import_axios.default.create({ baseURL: options.baseURL, timeout: this.timeoutMs });
+    this.signer = new Signer({
+      algorithm: options.signatureAlgorithm,
+      apiSecret: options.apiSecret,
+      privateKey: options.privateKey
+    });
+    this.rateLimitTracker = new RateLimitTracker({
+      weightLimitPerMinute: options.rateLimitWeightPerMinute,
+      safetyMargin: options.rateLimitSafetyMargin
+    });
+    this.policy = options.policy;
+    this.axios = import_axios.default.create({
+      baseURL: options.baseURL,
+      timeout: this.timeoutMs,
+      httpsAgent: options.httpsAgent,
+      proxy: options.proxy
+    });
     this.limiter = new import_bottleneck.default({ minTime: this.minTimeMs });
   }
   async get(path, params, mode = "public") {
@@ -112,6 +269,10 @@ var HttpClient = class {
   getRateLimiterStatus() {
     return { minTimeMs: this.minTimeMs, queueLength: this.pendingRequests };
   }
+  /** Snapshot of the most recently observed `X-MBX-USED-WEIGHT-*` / `X-MBX-ORDER-COUNT-*` response headers. */
+  getRateLimitUsage() {
+    return this.rateLimitTracker.getUsage();
+  }
   configureRateLimiter(options) {
     if (options.minTimeMs !== void 0) {
       this.minTimeMs = options.minTimeMs;
@@ -132,10 +293,28 @@ var HttpClient = class {
     if (options.maxDelayMs !== void 0) this.retryMaxDelayMs = options.maxDelayMs;
     if (options.factor !== void 0) this.retryFactor = options.factor;
   }
+  /**
+   * Fetches server time from `timePath` (e.g. '/time', '/fapi/v1/time', '/dapi/v1/time') and
+   * stores the offset from local time, applied to every signed request's `timestamp` param.
+   * Mitigates `-1021` (timestamp outside recvWindow) errors caused by local clock drift.
+   */
+  async syncTime(timePath = "/time") {
+    const res = await this.axios.request({ method: "GET", url: timePath });
+    this.timeOffsetMs = res.data.serverTime - Date.now();
+    return this.timeOffsetMs;
+  }
+  getTimeOffsetMs() {
+    return this.timeOffsetMs;
+  }
   async request(method, path, params, mode) {
+    this.policy?.check(method, path, params ?? {});
     const url = this.buildUrl(path, params, mode);
     const config = { method, url, headers: this.buildHeaders(mode) };
-    return this.limiter.schedule(() => this.requestWithRetry(config, 0));
+    return this.limiter.schedule(async () => {
+      const throttleMs = this.rateLimitTracker.getThrottleDelayMs();
+      if (throttleMs > 0) await sleep(throttleMs);
+      return this.requestWithRetry(config, 0, method, path);
+    });
   }
   buildHeaders(mode) {
     const headers = {
@@ -147,7 +326,7 @@ var HttpClient = class {
   }
   buildUrl(path, params, mode) {
     if (mode !== "signed") return this.appendQuery(path, params);
-    const requestData = { ...params, timestamp: Date.now(), recvWindow: this.recvWindow };
+    const requestData = { ...params, timestamp: Date.now() + this.timeOffsetMs, recvWindow: this.recvWindow };
     const queryString = this.buildQueryString(requestData);
     const signature = this.sign(queryString);
     return `${path}?${queryString}&signature=${signature}`;
@@ -158,20 +337,25 @@ var HttpClient = class {
   }
   buildQueryString(params) {
     if (!params) return "";
-    return Object.entries(params).filter(([, val]) => val !== void 0 && val !== null).map(([key, val]) => `${key}=${encodeURIComponent(String(val))}`).join("&");
+    return Object.entries(params).filter(([, val]) => val !== void 0 && val !== null).flatMap(
+      ([key, val]) => Array.isArray(val) ? val.map((item) => `${key}=${encodeURIComponent(String(item))}`) : [`${key}=${encodeURIComponent(String(val))}`]
+    ).join("&");
   }
   sign(queryString) {
-    if (!this.apiSecret) throw new BinanceAuthError("apiSecret");
-    return (0, import_node_crypto.createHmac)("sha256", this.apiSecret).update(queryString).digest("hex");
+    if (!this.signer.canSign()) {
+      throw new BinanceAuthError(this.signer.algorithm === "HMAC" ? "apiSecret" : "privateKey");
+    }
+    return this.signer.sign(queryString);
   }
   requireApiKey() {
     if (!this.apiKey) throw new BinanceAuthError("apiKey");
     return this.apiKey;
   }
-  async requestWithRetry(config, attempt) {
+  async requestWithRetry(config, attempt, method, endpoint) {
     this.pendingRequests += 1;
     try {
       const res = await this.axios.request(config);
+      this.rateLimitTracker.update(normalizeHeaders(res.headers));
       return res.data;
     } catch (err) {
       if (!import_axios.default.isAxiosError(err)) {
@@ -179,21 +363,36 @@ var HttpClient = class {
       }
       const status = err.response?.status;
       const body = err.response?.data;
+      const headers = normalizeHeaders(err.response?.headers);
+      this.rateLimitTracker.update(headers);
       if (attempt < this.maxRetries && this.shouldRetry(err)) {
         await sleep(this.calculateDelay(attempt));
-        return this.requestWithRetry(config, attempt + 1);
+        return this.requestWithRetry(config, attempt + 1, method, endpoint);
       }
+      const context = { endpoint, method, headers };
       if (status === 429 || status === 418) {
-        throw new RateLimitError(body?.msg ?? "Binance rate limit exceeded", body?.code ?? -1, status);
+        throw new RateLimitError(
+          body?.msg ?? "Binance rate limit exceeded",
+          body?.code ?? -1,
+          status,
+          this.parseRetryAfterMs(headers),
+          context
+        );
       }
       if (status && body) {
-        throw new BinanceApiError(body.msg ?? "Binance API error", body.code ?? -1, status);
+        throw new BinanceApiError(body.msg ?? "Binance API error", body.code ?? -1, status, context);
       }
       throw new NetworkError(err.message, err);
     } finally {
       this.pendingRequests -= 1;
     }
   }
+  parseRetryAfterMs(headers) {
+    const raw = headers["retry-after"];
+    if (!raw) return void 0;
+    const seconds = Number(raw);
+    return Number.isFinite(seconds) ? seconds * 1e3 : void 0;
+  }
   shouldRetry(err) {
     if (err.response?.status !== void 0) return RETRYABLE_STATUS.has(err.response.status);
     return true;
@@ -205,6 +404,92 @@ var HttpClient = class {
   }
 };
 
+// src/client/TradingPolicy.ts
+var WITHDRAW_FRAGMENTS = ["/capital/withdraw/apply"];
+var TRANSFER_FRAGMENTS = [
+  "/asset/transfer",
+  "/margin/transfer",
+  "/margin/isolated/transfer",
+  "/universaltransfer",
+  "/futures/transfer"
+];
+var MUTATING_METHODS = /* @__PURE__ */ new Set(["POST", "PUT", "DELETE"]);
+function toNumber(value) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  const num2 = Number(value);
+  return Number.isFinite(num2) ? num2 : void 0;
+}
+function includesFragment(path, fragments) {
+  const lower = path.toLowerCase();
+  return fragments.some((fragment) => lower.includes(fragment.toLowerCase()));
+}
+var TradingPolicy = class {
+  constructor(options = {}) {
+    this.options = options;
+    if (options.allowedSymbols?.length) {
+      this.allowedSymbols = new Set(options.allowedSymbols.map((s) => s.toUpperCase()));
+    }
+  }
+  /** Throws {@link PolicyViolationError} or {@link DryRunError} if the request is not permitted. */
+  check(method, path, params = {}) {
+    if (!MUTATING_METHODS.has(method)) return;
+    const deny = (rule, message, details) => {
+      throw new PolicyViolationError(rule, message, method, path, details);
+    };
+    if (this.options.blockedPaths?.length && includesFragment(path, this.options.blockedPaths)) {
+      deny("blockedPath", "endpoint is on the blocked-path list");
+    }
+    if (this.options.readOnly) {
+      deny("readOnly", "client is in read-only mode; mutating requests are refused");
+    }
+    if (includesFragment(path, WITHDRAW_FRAGMENTS) && this.options.allowWithdrawals !== true) {
+      deny("withdrawalsBlocked", "withdrawals are disabled; set safety.allowWithdrawals to permit them");
+    }
+    if (includesFragment(path, TRANSFER_FRAGMENTS) && this.options.allowTransfers === false) {
+      deny("transfersBlocked", "account transfers are disabled by policy");
+    }
+    this.checkSymbol(path, params, deny);
+    this.checkNotional(path, params, deny);
+    if (this.options.dryRun) {
+      throw new DryRunError(method, path, params);
+    }
+  }
+  checkSymbol(path, params, deny) {
+    if (!this.allowedSymbols) return;
+    const symbol3 = params.symbol;
+    if (typeof symbol3 !== "string" || symbol3 === "") return;
+    if (!this.allowedSymbols.has(symbol3.toUpperCase())) {
+      deny("symbolNotAllowed", `symbol ${symbol3} is not in the allowed list`, {
+        symbol: symbol3,
+        allowed: [...this.allowedSymbols]
+      });
+    }
+  }
+  checkNotional(path, params, deny) {
+    const max = this.options.maxNotionalPerOrder;
+    if (max === void 0) return;
+    if (!path.toLowerCase().includes("order")) return;
+    const quantity = toNumber(params.quantity);
+    const quoteOrderQty = toNumber(params.quoteOrderQty);
+    if (quantity === void 0 && quoteOrderQty === void 0) return;
+    const price = toNumber(params.price);
+    const notional = quoteOrderQty ?? (price !== void 0 && quantity !== void 0 ? price * quantity : void 0);
+    if (notional === void 0) {
+      deny(
+        "notionalUndeterminable",
+        `cannot verify notional against the ${max} cap (no price on this order); supply a price or raise/remove maxNotionalPerOrder`,
+        { quantity, maxNotionalPerOrder: max }
+      );
+    }
+    if (notional > max) {
+      deny("maxNotionalPerOrder", `order notional ${notional} exceeds the ${max} cap`, {
+        notional,
+        maxNotionalPerOrder: max
+      });
+    }
+  }
+};
+
 // src/client/endpoints.ts
 function resolveEnvironment(options) {
   const env = options?.demo ? "demo" : options?.testnet ? "testnet" : "live";
@@ -215,6 +500,9 @@ function resolveEnvironment(options) {
   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");
+  const restDapiHost = options?.dapiBase ?? (env === "testnet" || env === "demo" ? "https://testnet.binancefuture.com" : "https://dapi.binance.com");
+  const wsSpotApiHost = options?.wsSpotApiBase ?? (env === "testnet" ? "wss://testnet.binance.vision/ws-api/v3" : "wss://ws-api.binance.com:443/ws-api/v3");
+  const wsDapiHost = options?.wsDapiBase ?? (env === "testnet" || env === "demo" ? "wss://dstream.binancefuture.com" : "wss://dstream.binance.com");
   return {
     env,
     endpoints: {
@@ -222,11 +510,17 @@ function resolveEnvironment(options) {
       restFapi: `${restHost}/fapi/v1`,
       restFuturesData: `${restHost}/futures/data`,
       restSpot: `${restSpotHost}/api/v3`,
+      restApiRoot: restSpotHost,
+      restDapiRoot: restDapiHost,
+      restDapi: `${restDapiHost}/dapi/v1`,
       wsMarket: wsMarketHost,
       wsUser: wsUserHost,
       wsApi: wsApiHost,
       wsSpotMarket: wsSpotMarketHost,
-      wsSpotUser: wsSpotUserHost
+      wsSpotUser: wsSpotUserHost,
+      wsSpotApi: wsSpotApiHost,
+      wsDapiMarket: `${wsDapiHost}/stream`,
+      wsDapiUser: `${wsDapiHost}/ws`
     }
   };
 }
@@ -1875,301 +2169,1404 @@ var UserDataStream = class {
   }
 };
 
-// src/ws/BaseWS.ts
-var import_node_events = require("events");
-var import_ws = __toESM(require("ws"), 1);
-
-// src/types/ws.types.ts
+// src/types/coinm.types.ts
 var import_zod7 = require("zod");
-var WsKlinePayloadSchema = import_zod7.z.object({
-  e: import_zod7.z.literal("kline"),
-  E: import_zod7.z.number(),
-  s: import_zod7.z.string(),
-  k: import_zod7.z.object({
-    t: import_zod7.z.number(),
-    T: import_zod7.z.number(),
-    s: import_zod7.z.string(),
-    i: import_zod7.z.string(),
-    o: import_zod7.z.string().transform(Number),
-    c: import_zod7.z.string().transform(Number),
-    h: import_zod7.z.string().transform(Number),
-    l: import_zod7.z.string().transform(Number),
-    v: import_zod7.z.string().transform(Number),
-    n: import_zod7.z.number(),
-    x: import_zod7.z.boolean(),
-    q: import_zod7.z.string().transform(Number),
-    V: import_zod7.z.string().transform(Number),
-    Q: import_zod7.z.string().transform(Number)
-  })
+var CoinMBalanceSchema = import_zod7.z.object({
+  accountAlias: import_zod7.z.string(),
+  asset: import_zod7.z.string(),
+  balance: import_zod7.z.string().transform(Number),
+  withdrawAvailable: import_zod7.z.string().transform(Number),
+  crossWalletBalance: import_zod7.z.string().transform(Number),
+  crossUnPnl: import_zod7.z.string().transform(Number),
+  availableBalance: import_zod7.z.string().transform(Number),
+  updateTime: import_zod7.z.number()
 });
-var WsAggTradePayloadSchema = import_zod7.z.object({
-  e: import_zod7.z.literal("aggTrade"),
-  E: import_zod7.z.number(),
-  s: import_zod7.z.string(),
-  a: import_zod7.z.number(),
-  p: import_zod7.z.string().transform(Number),
-  q: import_zod7.z.string().transform(Number),
-  f: import_zod7.z.number(),
-  l: import_zod7.z.number(),
-  T: import_zod7.z.number(),
-  m: import_zod7.z.boolean()
-});
-var WsTradePayloadSchema = import_zod7.z.object({
-  e: import_zod7.z.literal("trade"),
-  E: import_zod7.z.number(),
-  s: import_zod7.z.string(),
-  t: import_zod7.z.number(),
-  p: import_zod7.z.string().transform(Number),
-  q: import_zod7.z.string().transform(Number),
-  T: import_zod7.z.number(),
-  m: import_zod7.z.boolean()
-});
-var WsDepthUpdatePayloadSchema = import_zod7.z.object({
-  e: import_zod7.z.literal("depthUpdate"),
-  E: import_zod7.z.number(),
-  s: import_zod7.z.string(),
-  U: import_zod7.z.number(),
-  u: import_zod7.z.number(),
-  T: import_zod7.z.number().optional(),
-  pu: import_zod7.z.number().optional(),
-  b: import_zod7.z.array(import_zod7.z.tuple([import_zod7.z.string(), import_zod7.z.string()])),
-  a: import_zod7.z.array(import_zod7.z.tuple([import_zod7.z.string(), import_zod7.z.string()]))
-});
-var WsTicker24hrPayloadSchema = import_zod7.z.object({
-  e: import_zod7.z.literal("24hrTicker"),
-  E: import_zod7.z.number(),
-  s: import_zod7.z.string(),
-  p: import_zod7.z.string().transform(Number),
-  P: import_zod7.z.string().transform(Number),
-  c: import_zod7.z.string().transform(Number),
-  o: import_zod7.z.string().transform(Number),
-  h: import_zod7.z.string().transform(Number),
-  l: import_zod7.z.string().transform(Number),
-  v: import_zod7.z.string().transform(Number),
-  q: import_zod7.z.string().transform(Number)
-});
-var WsBookTickerPayloadSchema = import_zod7.z.object({
-  u: import_zod7.z.number(),
-  s: import_zod7.z.string(),
-  b: import_zod7.z.string().transform(Number),
-  B: import_zod7.z.string().transform(Number),
-  a: import_zod7.z.string().transform(Number),
-  A: import_zod7.z.string().transform(Number)
-});
-var WsMarkPricePayloadSchema = import_zod7.z.object({
-  e: import_zod7.z.literal("markPriceUpdate"),
-  E: import_zod7.z.number(),
-  s: import_zod7.z.string(),
-  p: import_zod7.z.string().transform(Number),
-  i: import_zod7.z.string().transform(Number),
-  P: import_zod7.z.string().transform(Number),
-  r: import_zod7.z.string().transform(Number),
-  T: import_zod7.z.number()
-});
-var WsMiniTickerPayloadSchema = import_zod7.z.object({
-  e: import_zod7.z.literal("24hrMiniTicker"),
-  E: import_zod7.z.number(),
-  s: import_zod7.z.string(),
-  c: import_zod7.z.string().transform(Number),
-  o: import_zod7.z.string().transform(Number),
-  h: import_zod7.z.string().transform(Number),
-  l: import_zod7.z.string().transform(Number),
-  v: import_zod7.z.string().transform(Number),
-  q: import_zod7.z.string().transform(Number)
-});
-var WsForceOrderPayloadSchema = import_zod7.z.object({
-  e: import_zod7.z.literal("forceOrder"),
-  E: import_zod7.z.number(),
-  o: import_zod7.z.object({
-    s: import_zod7.z.string(),
-    S: import_zod7.z.string(),
-    o: import_zod7.z.string(),
-    f: import_zod7.z.string(),
-    q: import_zod7.z.string().transform(Number),
-    p: import_zod7.z.string().transform(Number),
-    ap: import_zod7.z.string().transform(Number),
-    X: import_zod7.z.string(),
-    l: import_zod7.z.string().transform(Number),
-    z: import_zod7.z.string().transform(Number),
-    T: import_zod7.z.number()
-  })
+var CoinMBalanceResponseSchema = import_zod7.z.array(CoinMBalanceSchema);
+var CoinMPositionRiskSchema = import_zod7.z.object({
+  symbol: import_zod7.z.string(),
+  pair: import_zod7.z.string().optional(),
+  positionAmt: import_zod7.z.string().transform(Number),
+  entryPrice: import_zod7.z.string().transform(Number),
+  markPrice: import_zod7.z.string().transform(Number),
+  unRealizedProfit: import_zod7.z.string().transform(Number),
+  liquidationPrice: import_zod7.z.string().transform(Number),
+  leverage: import_zod7.z.string().transform(Number),
+  maxQty: import_zod7.z.string().transform(Number).optional(),
+  marginType: import_zod7.z.enum(["isolated", "cross"]),
+  isolatedMargin: import_zod7.z.string().transform(Number).optional(),
+  isAutoAddMargin: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.boolean()]).optional(),
+  positionSide: import_zod7.z.string(),
+  notionalValue: import_zod7.z.string().transform(Number).optional(),
+  breakEvenPrice: import_zod7.z.string().transform(Number).optional(),
+  updateTime: import_zod7.z.number().optional()
+}).loose();
+var CoinMPositionRiskResponseSchema = import_zod7.z.array(CoinMPositionRiskSchema);
+var CoinMAccountAssetSchema = import_zod7.z.object({
+  asset: import_zod7.z.string(),
+  walletBalance: import_zod7.z.string().transform(Number),
+  unrealizedProfit: import_zod7.z.string().transform(Number),
+  marginBalance: import_zod7.z.string().transform(Number),
+  maintMargin: import_zod7.z.string().transform(Number),
+  initialMargin: import_zod7.z.string().transform(Number),
+  positionInitialMargin: import_zod7.z.string().transform(Number),
+  openOrderInitialMargin: import_zod7.z.string().transform(Number),
+  maxWithdrawAmount: import_zod7.z.string().transform(Number),
+  crossWalletBalance: import_zod7.z.string().transform(Number),
+  crossUnPnl: import_zod7.z.string().transform(Number),
+  availableBalance: import_zod7.z.string().transform(Number),
+  updateTime: import_zod7.z.number()
+}).loose();
+var CoinMAccountPositionSchema = import_zod7.z.object({
+  symbol: import_zod7.z.string(),
+  positionAmt: import_zod7.z.string().transform(Number),
+  initialMargin: import_zod7.z.string().transform(Number),
+  maintMargin: import_zod7.z.string().transform(Number),
+  unrealizedProfit: import_zod7.z.string().transform(Number),
+  positionInitialMargin: import_zod7.z.string().transform(Number),
+  openOrderInitialMargin: import_zod7.z.string().transform(Number),
+  leverage: import_zod7.z.string().transform(Number),
+  isolated: import_zod7.z.boolean(),
+  positionSide: import_zod7.z.string(),
+  entryPrice: import_zod7.z.string().transform(Number),
+  maxQty: import_zod7.z.string().transform(Number).optional(),
+  updateTime: import_zod7.z.number().optional()
+}).loose();
+var CoinMAccountSchema = import_zod7.z.object({
+  canDeposit: import_zod7.z.boolean(),
+  canTrade: import_zod7.z.boolean(),
+  canWithdraw: import_zod7.z.boolean(),
+  feeTier: import_zod7.z.number(),
+  updateTime: import_zod7.z.number(),
+  assets: import_zod7.z.array(CoinMAccountAssetSchema),
+  positions: import_zod7.z.array(CoinMAccountPositionSchema)
+}).loose();
+var CoinMOrderSchema = import_zod7.z.object({
+  orderId: import_zod7.z.number(),
+  symbol: import_zod7.z.string(),
+  pair: import_zod7.z.string().optional(),
+  status: import_zod7.z.string(),
+  clientOrderId: import_zod7.z.string(),
+  price: import_zod7.z.string().transform(Number),
+  avgPrice: import_zod7.z.string().transform(Number),
+  origQty: import_zod7.z.string().transform(Number),
+  executedQty: import_zod7.z.string().transform(Number),
+  cumBase: import_zod7.z.string().transform(Number).optional(),
+  type: import_zod7.z.string(),
+  reduceOnly: import_zod7.z.boolean(),
+  closePosition: import_zod7.z.boolean().optional(),
+  side: import_zod7.z.string(),
+  positionSide: import_zod7.z.string(),
+  stopPrice: import_zod7.z.string().transform(Number).optional(),
+  workingType: import_zod7.z.string().optional(),
+  priceProtect: import_zod7.z.boolean().optional(),
+  origType: import_zod7.z.string().optional(),
+  timeInForce: import_zod7.z.string().optional(),
+  activatePrice: import_zod7.z.string().transform(Number).optional(),
+  priceRate: import_zod7.z.string().transform(Number).optional(),
+  time: import_zod7.z.number(),
+  updateTime: import_zod7.z.number()
+}).loose();
+var CoinMOrderResponseSchema = CoinMOrderSchema;
+var CoinMOrdersResponseSchema = import_zod7.z.array(CoinMOrderSchema);
+var CoinMCreateOrderParamsSchema = import_zod7.z.object({
+  symbol: import_zod7.z.string(),
+  side: import_zod7.z.enum(["BUY", "SELL"]),
+  positionSide: import_zod7.z.enum(["BOTH", "LONG", "SHORT"]).optional(),
+  type: import_zod7.z.string(),
+  timeInForce: import_zod7.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+  quantity: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional(),
+  reduceOnly: import_zod7.z.boolean().optional(),
+  price: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional(),
+  newClientOrderId: import_zod7.z.string().optional(),
+  stopPrice: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional(),
+  closePosition: import_zod7.z.boolean().optional(),
+  activationPrice: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional(),
+  callbackRate: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional(),
+  workingType: import_zod7.z.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional(),
+  priceProtect: import_zod7.z.boolean().optional(),
+  newOrderRespType: import_zod7.z.enum(["ACK", "RESULT"]).optional()
 });
-var WsCompositeIndexPayloadSchema = import_zod7.z.object({
-  e: import_zod7.z.literal("compositeIndex"),
-  E: import_zod7.z.number(),
-  s: import_zod7.z.string(),
-  p: import_zod7.z.string().transform(Number),
-  c: import_zod7.z.array(
-    import_zod7.z.object({
-      b: import_zod7.z.string(),
-      q: import_zod7.z.string(),
-      w: import_zod7.z.string().transform(Number),
-      p: import_zod7.z.string().transform(Number)
-    })
-  )
+var CoinMLeverageChangeSchema = import_zod7.z.object({
+  leverage: import_zod7.z.number(),
+  maxQty: import_zod7.z.string().transform(Number),
+  symbol: import_zod7.z.string()
 });
-var WsAssetIndexPayloadSchema = import_zod7.z.object({
-  e: import_zod7.z.literal("assetIndex"),
-  E: import_zod7.z.number(),
-  s: import_zod7.z.string(),
-  i: import_zod7.z.string().transform(Number),
-  b: import_zod7.z.string().transform(Number),
-  a: import_zod7.z.string().transform(Number)
-});
-var WsRollingWindowTickerPayloadSchema = import_zod7.z.object({
-  e: import_zod7.z.enum(["1hTicker", "4hTicker", "1dTicker", "7dTicker", "30dTicker"]),
-  E: import_zod7.z.number(),
-  s: import_zod7.z.string(),
-  p: import_zod7.z.string().transform(Number),
-  P: import_zod7.z.string().transform(Number),
-  o: import_zod7.z.string().transform(Number),
-  h: import_zod7.z.string().transform(Number),
-  l: import_zod7.z.string().transform(Number),
-  c: import_zod7.z.string().transform(Number),
-  v: import_zod7.z.string().transform(Number),
-  q: import_zod7.z.string().transform(Number),
-  O: import_zod7.z.number(),
-  C: import_zod7.z.number()
-});
-var WsSpotAvgPricePayloadSchema = import_zod7.z.object({
-  e: import_zod7.z.literal("avgPrice"),
-  E: import_zod7.z.number(),
-  s: import_zod7.z.string(),
-  i: import_zod7.z.string(),
-  w: import_zod7.z.string().transform(Number),
-  T: import_zod7.z.number()
+var CoinMMarginTypeChangeSchema = import_zod7.z.object({ code: import_zod7.z.number(), msg: import_zod7.z.string() });
+var CoinMPositionMarginChangeSchema = import_zod7.z.object({
+  amount: import_zod7.z.number(),
+  code: import_zod7.z.number(),
+  msg: import_zod7.z.string(),
+  type: import_zod7.z.number()
+});
+var CoinMIncomeSchema = import_zod7.z.object({
+  symbol: import_zod7.z.string().optional(),
+  incomeType: import_zod7.z.string(),
+  income: import_zod7.z.string().transform(Number),
+  asset: import_zod7.z.string(),
+  info: import_zod7.z.string().optional(),
+  time: import_zod7.z.number(),
+  tranId: import_zod7.z.number(),
+  tradeId: import_zod7.z.string().optional()
+}).loose();
+var CoinMIncomeHistoryResponseSchema = import_zod7.z.array(CoinMIncomeSchema);
+var CoinMUserTradeSchema = import_zod7.z.object({
+  symbol: import_zod7.z.string(),
+  id: import_zod7.z.number(),
+  orderId: import_zod7.z.number(),
+  pair: import_zod7.z.string().optional(),
+  side: import_zod7.z.string(),
+  price: import_zod7.z.string().transform(Number),
+  qty: import_zod7.z.string().transform(Number),
+  realizedPnl: import_zod7.z.string().transform(Number),
+  marginAsset: import_zod7.z.string().optional(),
+  baseQty: import_zod7.z.string().transform(Number).optional(),
+  commission: import_zod7.z.string().transform(Number),
+  commissionAsset: import_zod7.z.string(),
+  time: import_zod7.z.number(),
+  positionSide: import_zod7.z.string(),
+  buyer: import_zod7.z.boolean(),
+  maker: import_zod7.z.boolean()
+}).loose();
+var CoinMUserTradesResponseSchema = import_zod7.z.array(CoinMUserTradeSchema);
+var CoinMOpenInterestHistEntrySchema = import_zod7.z.object({
+  pair: import_zod7.z.string(),
+  contractType: import_zod7.z.string(),
+  sumOpenInterest: import_zod7.z.string().transform(Number),
+  sumOpenInterestValue: import_zod7.z.string().transform(Number),
+  timestamp: import_zod7.z.number()
+});
+var CoinMOpenInterestHistSchema = import_zod7.z.array(CoinMOpenInterestHistEntrySchema);
+var CoinMPositionModeSchema = import_zod7.z.object({ dualSidePosition: import_zod7.z.boolean() });
+var CoinMLeverageBracketSchema = import_zod7.z.object({
+  bracket: import_zod7.z.number(),
+  initialLeverage: import_zod7.z.number(),
+  qtyCap: import_zod7.z.number(),
+  qtyFloor: import_zod7.z.number(),
+  maintMarginRatio: import_zod7.z.number(),
+  cum: import_zod7.z.number().optional()
+});
+var CoinMLeverageBracketResponseSchema = import_zod7.z.array(
+  import_zod7.z.object({
+    symbol: import_zod7.z.string().optional(),
+    pair: import_zod7.z.string().optional(),
+    brackets: import_zod7.z.array(CoinMLeverageBracketSchema)
+  })
+);
+var CoinMCommissionRateSchema = import_zod7.z.object({
+  symbol: import_zod7.z.string(),
+  makerCommissionRate: import_zod7.z.string().transform(Number),
+  takerCommissionRate: import_zod7.z.string().transform(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 import_node_events.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();
+// src/resources/CoinMMarket.ts
+var CoinMMarket = class extends MarketDataBase {
+  constructor(http2) {
+    super(http2 ?? new HttpClient({ baseURL: "https://dapi.binance.com/dapi/v1" }));
   }
-  reconnect() {
-    if (this.ws?.readyState === import_ws.default.OPEN) this.ws.close();
-    this.reconnectAttempt = 0;
-    if (!this.closedByUser) this.connect();
+  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);
   }
-  resetReconnectAttempts() {
-    this.reconnectAttempt = 0;
+  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);
   }
-  isOpen() {
-    return this.ws?.readyState === import_ws.default.OPEN;
+  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);
   }
-  send(payload) {
-    this.ws?.send(JSON.stringify(payload));
+  async premiumIndex(options) {
+    return PremiumIndexSchema.or(PremiumIndexSchema.array()).parse(
+      await this.http.get("/premiumIndex", options)
+    );
   }
-  connect() {
-    this.closedByUser = false;
-    const url = `${this.options.baseStreamUrl}?streams=${[...this.streams].join("/")}`;
-    this.ws = new import_ws.default(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);
-    });
+  async fundingRateHistory(symbol3, options) {
+    return FundingRateHistorySchema.parse(await this.http.get("/fundingRate", { symbol: symbol3, ...options }));
   }
-  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);
-    }
+  async openInterest(symbol3) {
+    return OpenInterestSchema.parse(await this.http.get("/openInterest", { symbol: symbol3 }));
   }
-  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);
+  async openInterestHist(pair, contractType2, period2, options) {
+    return CoinMOpenInterestHistSchema.parse(
+      await this.http.get("/openInterestHist", { pair, contractType: contractType2, period: period2, ...options })
+    );
   }
 };
 
-// src/ws/FuturesMarketWS.ts
-var FuturesMarketWS = class extends BaseWS {
-  constructor(baseStreamUrl = "wss://fstream.binance.com/stream") {
-    super({ baseStreamUrl });
+// src/resources/CoinMAccount.ts
+var CoinMAccount = class {
+  constructor(http2) {
+    this.http = http2;
   }
-  kline(symbol3, interval) {
-    return `${symbol3.toLowerCase()}@kline_${interval}`;
+  async balance() {
+    return CoinMBalanceResponseSchema.parse(await this.http.get("/dapi/v1/balance", void 0, "signed"));
   }
-  continuousKline(symbol3, contractType2, interval) {
-    return `${symbol3.toLowerCase()}@continuousKline_${contractType2}_${interval}`;
+  async account() {
+    return CoinMAccountSchema.parse(await this.http.get("/dapi/v1/account", void 0, "signed"));
   }
-  indexPriceKline(symbol3, interval) {
-    return `${symbol3.toLowerCase()}@indexPriceKline_${interval}`;
+  async positionRisk(options) {
+    return CoinMPositionRiskResponseSchema.parse(
+      await this.http.get("/dapi/v1/positionRisk", options, "signed")
+    );
   }
-  markPriceKline(symbol3, interval) {
-    return `${symbol3.toLowerCase()}@markPriceKline_${interval}`;
+  async incomeHistory(options) {
+    return CoinMIncomeHistoryResponseSchema.parse(await this.http.get("/dapi/v1/income", options, "signed"));
   }
-  aggTrade(symbol3) {
-    return `${symbol3.toLowerCase()}@aggTrade`;
+  async userTrades(options) {
+    return CoinMUserTradesResponseSchema.parse(
+      await this.http.get("/dapi/v1/userTrades", options, "signed")
+    );
   }
-  trade(symbol3) {
-    return `${symbol3.toLowerCase()}@trade`;
+  async leverageBrackets(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : void 0;
+    return CoinMLeverageBracketResponseSchema.parse(
+      await this.http.get("/dapi/v1/leverageBracket", params, "signed")
+    );
+  }
+  async commissionRate(symbol3) {
+    return CoinMCommissionRateSchema.parse(
+      await this.http.get("/dapi/v1/commissionRate", { symbol: symbol3 }, "signed")
+    );
+  }
+  async positionMode() {
+    return CoinMPositionModeSchema.parse(
+      await this.http.get("/dapi/v1/positionSide/dual", void 0, "signed")
+    );
+  }
+  async setPositionMode(dualSidePosition) {
+    return this.http.post("/dapi/v1/positionSide/dual", { dualSidePosition }, "signed");
+  }
+};
+
+// src/resources/CoinMTrading.ts
+var CoinMTrading = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  async setLeverage(symbol3, leverage) {
+    return CoinMLeverageChangeSchema.parse(
+      await this.http.post("/dapi/v1/leverage", { symbol: symbol3, leverage }, "signed")
+    );
+  }
+  async setMarginType(symbol3, marginType) {
+    return CoinMMarginTypeChangeSchema.parse(
+      await this.http.post("/dapi/v1/marginType", { symbol: symbol3, marginType }, "signed")
+    );
+  }
+  async createOrder(params) {
+    return CoinMOrderResponseSchema.parse(await this.http.post("/dapi/v1/order", params, "signed"));
+  }
+  async createTestOrder(params) {
+    return this.http.post("/dapi/v1/order/test", params, "signed");
+  }
+  async getOrder(symbol3, options) {
+    return CoinMOrderResponseSchema.parse(
+      await this.http.get("/dapi/v1/order", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async cancelOrder(symbol3, options) {
+    return CoinMOrderResponseSchema.parse(
+      await this.http.delete("/dapi/v1/order", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async cancelAllOpenOrders(symbol3) {
+    return this.http.delete("/dapi/v1/allOpenOrders", { symbol: symbol3 }, "signed");
+  }
+  async getOpenOrders(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : void 0;
+    return CoinMOrdersResponseSchema.parse(await this.http.get("/dapi/v1/openOrders", params, "signed"));
+  }
+  async getAllOrders(symbol3, options) {
+    return CoinMOrdersResponseSchema.parse(
+      await this.http.get("/dapi/v1/allOrders", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async modifyPositionMargin(symbol3, amount, type) {
+    return CoinMPositionMarginChangeSchema.parse(
+      await this.http.post("/dapi/v1/positionMargin", { symbol: symbol3, amount, type }, "signed")
+    );
+  }
+};
+
+// src/resources/CoinMUserDataStream.ts
+var CoinMUserDataStream = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  async createListenKey() {
+    return ListenKeySchema.parse(await this.http.post("/dapi/v1/listenKey", void 0, "apiKey"));
+  }
+  async keepAliveListenKey() {
+    return this.http.put("/dapi/v1/listenKey", void 0, "apiKey");
+  }
+  async closeListenKey() {
+    return this.http.delete("/dapi/v1/listenKey", void 0, "apiKey");
+  }
+};
+
+// src/types/margin.types.ts
+var import_zod8 = require("zod");
+var MarginAssetBalanceSchema = import_zod8.z.object({
+  asset: import_zod8.z.string(),
+  borrowed: import_zod8.z.string().transform(Number),
+  free: import_zod8.z.string().transform(Number),
+  interest: import_zod8.z.string().transform(Number),
+  locked: import_zod8.z.string().transform(Number),
+  netAsset: import_zod8.z.string().transform(Number)
+});
+var CrossMarginAccountSchema = import_zod8.z.object({
+  borrowEnabled: import_zod8.z.boolean(),
+  marginLevel: import_zod8.z.string().transform(Number),
+  totalAssetOfBtc: import_zod8.z.string().transform(Number),
+  totalLiabilityOfBtc: import_zod8.z.string().transform(Number),
+  totalNetAssetOfBtc: import_zod8.z.string().transform(Number),
+  tradeEnabled: import_zod8.z.boolean(),
+  transferEnabled: import_zod8.z.boolean(),
+  accountType: import_zod8.z.string().optional(),
+  userAssets: import_zod8.z.array(MarginAssetBalanceSchema)
+}).loose();
+var IsolatedMarginAssetSchema = import_zod8.z.object({
+  asset: import_zod8.z.string(),
+  borrowEnabled: import_zod8.z.boolean(),
+  borrowed: import_zod8.z.string().transform(Number),
+  free: import_zod8.z.string().transform(Number),
+  interest: import_zod8.z.string().transform(Number),
+  locked: import_zod8.z.string().transform(Number),
+  netAsset: import_zod8.z.string().transform(Number),
+  netAssetOfBtc: import_zod8.z.string().transform(Number),
+  repayEnabled: import_zod8.z.boolean(),
+  totalAsset: import_zod8.z.string().transform(Number)
+}).loose();
+var IsolatedMarginSymbolSchema = import_zod8.z.object({
+  baseAsset: IsolatedMarginAssetSchema,
+  quoteAsset: IsolatedMarginAssetSchema,
+  symbol: import_zod8.z.string(),
+  isolatedCreated: import_zod8.z.boolean().optional(),
+  enabled: import_zod8.z.boolean(),
+  marginLevel: import_zod8.z.string().transform(Number),
+  marginLevelStatus: import_zod8.z.string().optional(),
+  marginRatio: import_zod8.z.string().transform(Number).optional(),
+  indexPrice: import_zod8.z.string().transform(Number).optional(),
+  liquidatePrice: import_zod8.z.string().transform(Number).optional(),
+  liquidateRate: import_zod8.z.string().transform(Number).optional(),
+  tradeEnabled: import_zod8.z.boolean()
+}).loose();
+var IsolatedMarginAccountSchema = import_zod8.z.object({
+  assets: import_zod8.z.array(IsolatedMarginSymbolSchema),
+  totalAssetOfBtc: import_zod8.z.string().transform(Number).optional(),
+  totalLiabilityOfBtc: import_zod8.z.string().transform(Number).optional(),
+  totalNetAssetOfBtc: import_zod8.z.string().transform(Number).optional()
+});
+var MaxBorrowableSchema = import_zod8.z.object({
+  amount: import_zod8.z.string().transform(Number),
+  borrowLimit: import_zod8.z.string().transform(Number)
+});
+var MaxTransferableSchema = import_zod8.z.object({
+  amount: import_zod8.z.string().transform(Number),
+  fullAmount: import_zod8.z.string().transform(Number).optional()
+});
+var BorrowRepayParamsSchema = import_zod8.z.object({
+  asset: import_zod8.z.string(),
+  isIsolated: import_zod8.z.enum(["TRUE", "FALSE"]).optional(),
+  symbol: import_zod8.z.string().optional(),
+  amount: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]),
+  type: import_zod8.z.enum(["BORROW", "REPAY"])
+});
+var BorrowRepayResultSchema = import_zod8.z.object({ tranId: import_zod8.z.number() });
+var BorrowRepayRecordEntrySchema = import_zod8.z.object({
+  isolatedSymbol: import_zod8.z.string().optional(),
+  txId: import_zod8.z.number(),
+  asset: import_zod8.z.string(),
+  principal: import_zod8.z.string().transform(Number),
+  timestamp: import_zod8.z.number(),
+  status: import_zod8.z.string()
+}).loose();
+var BorrowRepayRecordResponseSchema = import_zod8.z.object({
+  rows: import_zod8.z.array(BorrowRepayRecordEntrySchema),
+  total: import_zod8.z.number()
+});
+var MarginTransferResultSchema = import_zod8.z.object({ tranId: import_zod8.z.number() });
+var IsolatedTransferParamsSchema = import_zod8.z.object({
+  asset: import_zod8.z.string(),
+  symbol: import_zod8.z.string(),
+  transFrom: import_zod8.z.enum(["SPOT", "ISOLATED_MARGIN"]),
+  transTo: import_zod8.z.enum(["SPOT", "ISOLATED_MARGIN"]),
+  amount: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()])
+});
+var MarginInterestHistoryEntrySchema = import_zod8.z.object({
+  txId: import_zod8.z.number(),
+  interestAccuredTime: import_zod8.z.number(),
+  asset: import_zod8.z.string(),
+  rawAsset: import_zod8.z.string().optional(),
+  principal: import_zod8.z.string().transform(Number),
+  interest: import_zod8.z.string().transform(Number),
+  interestRate: import_zod8.z.string().transform(Number),
+  type: import_zod8.z.string(),
+  isolatedSymbol: import_zod8.z.string().optional()
+}).loose();
+var MarginInterestHistoryResponseSchema = import_zod8.z.object({
+  rows: import_zod8.z.array(MarginInterestHistoryEntrySchema),
+  total: import_zod8.z.number()
+});
+var MarginForceLiquidationEntrySchema = import_zod8.z.object({
+  avgPrice: import_zod8.z.string().transform(Number),
+  executedQty: import_zod8.z.string().transform(Number),
+  orderId: import_zod8.z.number(),
+  price: import_zod8.z.string().transform(Number),
+  qty: import_zod8.z.string().transform(Number),
+  side: import_zod8.z.string(),
+  symbol: import_zod8.z.string(),
+  timeInForce: import_zod8.z.string(),
+  isIsolated: import_zod8.z.boolean().optional(),
+  updatedTime: import_zod8.z.number()
+}).loose();
+var MarginForceLiquidationResponseSchema = import_zod8.z.object({
+  rows: import_zod8.z.array(MarginForceLiquidationEntrySchema),
+  total: import_zod8.z.number()
+});
+var MarginPriceIndexSchema = import_zod8.z.object({
+  calcTime: import_zod8.z.number(),
+  price: import_zod8.z.string().transform(Number),
+  symbol: import_zod8.z.string()
+});
+var MarginOrderSchema = import_zod8.z.object({
+  symbol: import_zod8.z.string(),
+  orderId: import_zod8.z.number(),
+  clientOrderId: import_zod8.z.string(),
+  isIsolated: import_zod8.z.boolean().optional(),
+  price: import_zod8.z.string().transform(Number),
+  origQty: import_zod8.z.string().transform(Number),
+  executedQty: import_zod8.z.string().transform(Number),
+  cummulativeQuoteQty: import_zod8.z.string().transform(Number),
+  status: import_zod8.z.string(),
+  timeInForce: import_zod8.z.string().optional(),
+  type: import_zod8.z.string(),
+  side: import_zod8.z.string(),
+  transactTime: import_zod8.z.number().optional(),
+  time: import_zod8.z.number().optional(),
+  updateTime: import_zod8.z.number().optional(),
+  fills: import_zod8.z.array(import_zod8.z.unknown()).optional()
+}).loose();
+var MarginOrderResponseSchema = MarginOrderSchema;
+var MarginOrdersResponseSchema = import_zod8.z.array(MarginOrderSchema);
+var MarginCreateOrderParamsSchema = import_zod8.z.object({
+  symbol: import_zod8.z.string(),
+  isIsolated: import_zod8.z.enum(["TRUE", "FALSE"]).optional(),
+  side: import_zod8.z.enum(["BUY", "SELL"]),
+  type: import_zod8.z.string(),
+  quantity: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional(),
+  quoteOrderQty: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional(),
+  price: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional(),
+  stopPrice: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional(),
+  newClientOrderId: import_zod8.z.string().optional(),
+  icebergQty: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional(),
+  timeInForce: import_zod8.z.enum(["GTC", "IOC", "FOK"]).optional(),
+  sideEffectType: import_zod8.z.enum(["NO_SIDE_EFFECT", "MARGIN_BUY", "AUTO_REPAY", "AUTO_BORROW_REPAY"]).optional(),
+  newOrderRespType: import_zod8.z.enum(["ACK", "RESULT", "FULL"]).optional(),
+  autoRepayAtCancel: import_zod8.z.boolean().optional()
+});
+var MarginTradeSchema = import_zod8.z.object({
+  symbol: import_zod8.z.string(),
+  id: import_zod8.z.number(),
+  orderId: import_zod8.z.number(),
+  price: import_zod8.z.string().transform(Number),
+  qty: import_zod8.z.string().transform(Number),
+  quoteQty: import_zod8.z.string().transform(Number),
+  commission: import_zod8.z.string().transform(Number),
+  commissionAsset: import_zod8.z.string(),
+  time: import_zod8.z.number(),
+  isBuyer: import_zod8.z.boolean(),
+  isMaker: import_zod8.z.boolean(),
+  isBestMatch: import_zod8.z.boolean().optional(),
+  isIsolated: import_zod8.z.boolean().optional()
+}).loose();
+var MarginTradesResponseSchema = import_zod8.z.array(MarginTradeSchema);
+
+// src/resources/Margin.ts
+var MarginAccount = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  async crossAccount() {
+    return CrossMarginAccountSchema.parse(await this.http.get("/sapi/v1/margin/account", void 0, "signed"));
+  }
+  async isolatedAccount(symbols) {
+    const params = symbols?.length ? { symbols: symbols.join(",") } : void 0;
+    return IsolatedMarginAccountSchema.parse(
+      await this.http.get("/sapi/v1/margin/isolated/account", params, "signed")
+    );
+  }
+  async maxBorrowable(asset, isolatedSymbol) {
+    return MaxBorrowableSchema.parse(
+      await this.http.get("/sapi/v1/margin/maxBorrowable", { asset, isolatedSymbol }, "signed")
+    );
+  }
+  async maxTransferable(asset, isolatedSymbol) {
+    return MaxTransferableSchema.parse(
+      await this.http.get("/sapi/v1/margin/maxTransferable", { asset, isolatedSymbol }, "signed")
+    );
+  }
+  async borrowRepay(params) {
+    return BorrowRepayResultSchema.parse(
+      await this.http.post("/sapi/v1/margin/borrow-repay", params, "signed")
+    );
+  }
+  async borrow(asset, amount, options) {
+    return this.borrowRepay({
+      asset,
+      amount,
+      type: "BORROW",
+      isIsolated: options?.isIsolated ? "TRUE" : void 0,
+      symbol: options?.symbol
+    });
+  }
+  async repay(asset, amount, options) {
+    return this.borrowRepay({
+      asset,
+      amount,
+      type: "REPAY",
+      isIsolated: options?.isIsolated ? "TRUE" : void 0,
+      symbol: options?.symbol
+    });
+  }
+  async borrowRepayRecord(type, options) {
+    return BorrowRepayRecordResponseSchema.parse(
+      await this.http.get("/sapi/v1/margin/borrow-repay", { type, ...options }, "signed")
+    );
+  }
+  async transfer(asset, amount, type) {
+    return MarginTransferResultSchema.parse(
+      await this.http.post("/sapi/v1/margin/transfer", { asset, amount, type }, "signed")
+    );
+  }
+  async isolatedTransfer(params) {
+    return MarginTransferResultSchema.parse(
+      await this.http.post("/sapi/v1/margin/isolated/transfer", params, "signed")
+    );
+  }
+  async interestHistory(options) {
+    return MarginInterestHistoryResponseSchema.parse(
+      await this.http.get("/sapi/v1/margin/interestHistory", options, "signed")
+    );
+  }
+  async forceLiquidationRecord(options) {
+    return MarginForceLiquidationResponseSchema.parse(
+      await this.http.get("/sapi/v1/margin/forceLiquidationRec", options, "signed")
+    );
+  }
+  async priceIndex(symbol3) {
+    return MarginPriceIndexSchema.parse(await this.http.get("/sapi/v1/margin/priceIndex", { symbol: symbol3 }));
+  }
+};
+var MarginTrading = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  async createOrder(params) {
+    return MarginOrderResponseSchema.parse(await this.http.post("/sapi/v1/margin/order", params, "signed"));
+  }
+  async cancelOrder(symbol3, options) {
+    return MarginOrderResponseSchema.parse(
+      await this.http.delete("/sapi/v1/margin/order", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async cancelAllOpenOrders(symbol3, isIsolated) {
+    return MarginOrdersResponseSchema.parse(
+      await this.http.delete("/sapi/v1/margin/openOrders", { symbol: symbol3, isIsolated }, "signed")
+    );
+  }
+  async getOrder(symbol3, options) {
+    return MarginOrderResponseSchema.parse(
+      await this.http.get("/sapi/v1/margin/order", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async getOpenOrders(options) {
+    return MarginOrdersResponseSchema.parse(await this.http.get("/sapi/v1/margin/openOrders", options, "signed"));
+  }
+  async getAllOrders(symbol3, options) {
+    return MarginOrdersResponseSchema.parse(
+      await this.http.get("/sapi/v1/margin/allOrders", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+  async myTrades(symbol3, options) {
+    return MarginTradesResponseSchema.parse(
+      await this.http.get("/sapi/v1/margin/myTrades", { symbol: symbol3, ...options }, "signed")
+    );
+  }
+};
+
+// src/types/wallet.types.ts
+var import_zod9 = require("zod");
+var TransferTypeSchema = import_zod9.z.enum([
+  "MAIN_UMFUTURE",
+  "MAIN_CMFUTURE",
+  "MAIN_MARGIN",
+  "MAIN_MINING",
+  "MAIN_FUNDING",
+  "MAIN_OPTION",
+  "UMFUTURE_MAIN",
+  "UMFUTURE_MARGIN",
+  "UMFUTURE_FUNDING",
+  "CMFUTURE_MAIN",
+  "CMFUTURE_MARGIN",
+  "MARGIN_MAIN",
+  "MARGIN_UMFUTURE",
+  "MARGIN_CMFUTURE",
+  "MARGIN_MINING",
+  "MARGIN_FUNDING",
+  "MINING_MAIN",
+  "MINING_UMFUTURE",
+  "MINING_MARGIN",
+  "FUNDING_MAIN",
+  "FUNDING_UMFUTURE",
+  "FUNDING_MARGIN",
+  "FUNDING_CMFUTURE",
+  "OPTION_MAIN",
+  "MAIN_OPTION_MARGIN",
+  "MAIN_PORTFOLIO_MARGIN",
+  "PORTFOLIO_MARGIN_MAIN",
+  "ISOLATEDMARGIN_MARGIN",
+  "MARGIN_ISOLATEDMARGIN",
+  "ISOLATEDMARGIN_ISOLATEDMARGIN"
+]);
+var UniversalTransferParamsSchema = import_zod9.z.object({
+  type: TransferTypeSchema,
+  asset: import_zod9.z.string(),
+  amount: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]),
+  fromSymbol: import_zod9.z.string().optional(),
+  toSymbol: import_zod9.z.string().optional()
+});
+var UniversalTransferResultSchema = import_zod9.z.object({ tranId: import_zod9.z.number() });
+var UniversalTransferHistoryEntrySchema = import_zod9.z.object({
+  asset: import_zod9.z.string(),
+  amount: import_zod9.z.string().transform(Number),
+  type: import_zod9.z.string(),
+  status: import_zod9.z.string(),
+  tranId: import_zod9.z.number(),
+  timestamp: import_zod9.z.number(),
+  fromSymbol: import_zod9.z.string().nullable().optional(),
+  toSymbol: import_zod9.z.string().nullable().optional()
+}).loose();
+var UniversalTransferHistoryResponseSchema = import_zod9.z.object({
+  total: import_zod9.z.number(),
+  rows: import_zod9.z.array(UniversalTransferHistoryEntrySchema)
+});
+var FundingAssetSchema = import_zod9.z.object({
+  asset: import_zod9.z.string(),
+  free: import_zod9.z.string().transform(Number),
+  locked: import_zod9.z.string().transform(Number),
+  freeze: import_zod9.z.string().transform(Number),
+  withdrawing: import_zod9.z.string().transform(Number),
+  btcValuation: import_zod9.z.string().transform(Number)
+});
+var FundingAssetsResponseSchema = import_zod9.z.array(FundingAssetSchema);
+var UserAssetSchema = import_zod9.z.object({
+  asset: import_zod9.z.string(),
+  free: import_zod9.z.string().transform(Number),
+  locked: import_zod9.z.string().transform(Number),
+  freeze: import_zod9.z.string().transform(Number),
+  withdrawing: import_zod9.z.string().transform(Number),
+  ipoable: import_zod9.z.string().transform(Number),
+  btcValuation: import_zod9.z.string().transform(Number)
+});
+var UserAssetsResponseSchema = import_zod9.z.array(UserAssetSchema);
+var DepositHistoryEntrySchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  amount: import_zod9.z.string().transform(Number),
+  coin: import_zod9.z.string(),
+  network: import_zod9.z.string(),
+  status: import_zod9.z.number(),
+  address: import_zod9.z.string(),
+  addressTag: import_zod9.z.string().optional(),
+  txId: import_zod9.z.string(),
+  insertTime: import_zod9.z.number(),
+  transferType: import_zod9.z.number(),
+  confirmTimes: import_zod9.z.string().optional(),
+  unlockConfirm: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]).optional(),
+  walletType: import_zod9.z.number().optional()
+}).loose();
+var DepositHistoryResponseSchema = import_zod9.z.array(DepositHistoryEntrySchema);
+var WithdrawHistoryEntrySchema = import_zod9.z.object({
+  id: import_zod9.z.string(),
+  amount: import_zod9.z.string().transform(Number),
+  transactionFee: import_zod9.z.string().transform(Number),
+  coin: import_zod9.z.string(),
+  status: import_zod9.z.number(),
+  address: import_zod9.z.string(),
+  txId: import_zod9.z.string().optional(),
+  applyTime: import_zod9.z.string(),
+  network: import_zod9.z.string(),
+  transferType: import_zod9.z.number(),
+  withdrawOrderId: import_zod9.z.string().nullable().optional(),
+  info: import_zod9.z.string().optional(),
+  confirmNo: import_zod9.z.number().optional(),
+  walletType: import_zod9.z.number().optional()
+}).loose();
+var WithdrawHistoryResponseSchema = import_zod9.z.array(WithdrawHistoryEntrySchema);
+var WithdrawParamsSchema = import_zod9.z.object({
+  coin: import_zod9.z.string(),
+  address: import_zod9.z.string(),
+  amount: import_zod9.z.union([import_zod9.z.string(), import_zod9.z.number()]),
+  withdrawOrderId: import_zod9.z.string().optional(),
+  network: import_zod9.z.string().optional(),
+  addressTag: import_zod9.z.string().optional(),
+  transactionFeeFlag: import_zod9.z.boolean().optional(),
+  name: import_zod9.z.string().optional(),
+  walletType: import_zod9.z.number().optional()
+});
+var WithdrawResultSchema = import_zod9.z.object({ id: import_zod9.z.string() });
+var DepositAddressSchema = import_zod9.z.object({
+  address: import_zod9.z.string(),
+  coin: import_zod9.z.string(),
+  tag: import_zod9.z.string(),
+  url: import_zod9.z.string().optional()
+});
+var ApiKeyPermissionsSchema = import_zod9.z.object({
+  ipRestrict: import_zod9.z.boolean(),
+  createTime: import_zod9.z.number(),
+  enableWithdrawals: import_zod9.z.boolean(),
+  enableInternalTransfer: import_zod9.z.boolean(),
+  enableFutures: import_zod9.z.boolean(),
+  enableMargin: import_zod9.z.boolean(),
+  enableSpotAndMarginTrading: import_zod9.z.boolean(),
+  permitsUniversalTransfer: import_zod9.z.boolean().optional(),
+  enableReading: import_zod9.z.boolean().optional(),
+  tradingAuthorityExpirationTime: import_zod9.z.number().optional()
+}).loose();
+var AssetDetailSchema = import_zod9.z.record(
+  import_zod9.z.string(),
+  import_zod9.z.object({
+    minWithdrawAmount: import_zod9.z.string().transform(Number),
+    depositStatus: import_zod9.z.boolean(),
+    withdrawFee: import_zod9.z.number(),
+    withdrawStatus: import_zod9.z.boolean(),
+    depositTip: import_zod9.z.string().optional()
+  }).loose()
+);
+var DustLogEntrySchema = import_zod9.z.object({
+  transId: import_zod9.z.number(),
+  serviceChargeAmount: import_zod9.z.string().transform(Number),
+  amount: import_zod9.z.string().transform(Number),
+  operateTime: import_zod9.z.string(),
+  transferedAmount: import_zod9.z.string().transform(Number),
+  fromAsset: import_zod9.z.string()
+}).loose();
+var DustLogResponseSchema = import_zod9.z.object({
+  total: import_zod9.z.number(),
+  userAssetDribblets: import_zod9.z.array(
+    import_zod9.z.object({
+      operateTime: import_zod9.z.number(),
+      totalTransferedAmount: import_zod9.z.string().transform(Number),
+      totalServiceChargeAmount: import_zod9.z.string().transform(Number),
+      transId: import_zod9.z.number(),
+      userAssetDribbletDetails: import_zod9.z.array(DustLogEntrySchema)
+    })
+  )
+});
+var DustConversionResultSchema = import_zod9.z.object({
+  totalServiceCharge: import_zod9.z.string().transform(Number),
+  totalTransfered: import_zod9.z.string().transform(Number),
+  transferResult: import_zod9.z.array(
+    import_zod9.z.object({
+      amount: import_zod9.z.string().transform(Number),
+      fromAsset: import_zod9.z.string(),
+      operateTime: import_zod9.z.number(),
+      serviceChargeAmount: import_zod9.z.string().transform(Number),
+      tranId: import_zod9.z.number(),
+      transferedAmount: import_zod9.z.string().transform(Number)
+    }).loose()
+  )
+}).loose();
+var TradeFeeEntrySchema = import_zod9.z.object({
+  symbol: import_zod9.z.string(),
+  makerCommission: import_zod9.z.string().transform(Number),
+  takerCommission: import_zod9.z.string().transform(Number)
+});
+var TradeFeeResponseSchema = import_zod9.z.array(TradeFeeEntrySchema);
+var AccountSnapshotSchema = import_zod9.z.object({
+  code: import_zod9.z.number(),
+  msg: import_zod9.z.string(),
+  snapshotVos: import_zod9.z.array(
+    import_zod9.z.object({
+      type: import_zod9.z.string(),
+      updateTime: import_zod9.z.number(),
+      data: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.unknown())
+    }).loose()
+  )
+}).loose();
+
+// src/resources/Wallet.ts
+var Wallet = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  async universalTransfer(params) {
+    return UniversalTransferResultSchema.parse(
+      await this.http.post("/sapi/v1/asset/transfer", params, "signed")
+    );
+  }
+  async universalTransferHistory(options) {
+    return UniversalTransferHistoryResponseSchema.parse(
+      await this.http.get("/sapi/v1/asset/transfer", options, "signed")
+    );
+  }
+  async fundingWallet(options) {
+    return FundingAssetsResponseSchema.parse(
+      await this.http.post("/sapi/v1/asset/get-funding-asset", options, "signed")
+    );
+  }
+  async userAsset(options) {
+    return UserAssetsResponseSchema.parse(
+      await this.http.post("/sapi/v3/asset/getUserAsset", options, "signed")
+    );
+  }
+  async depositHistory(options) {
+    return DepositHistoryResponseSchema.parse(
+      await this.http.get("/sapi/v1/capital/deposit/hisrec", options, "signed")
+    );
+  }
+  async withdrawHistory(options) {
+    return WithdrawHistoryResponseSchema.parse(
+      await this.http.get("/sapi/v1/capital/withdraw/history", options, "signed")
+    );
+  }
+  async withdraw(params) {
+    return WithdrawResultSchema.parse(
+      await this.http.post("/sapi/v1/capital/withdraw/apply", params, "signed")
+    );
+  }
+  async depositAddress(coin, network) {
+    return DepositAddressSchema.parse(
+      await this.http.get("/sapi/v1/capital/deposit/address", { coin, network }, "signed")
+    );
+  }
+  async accountSnapshot(type, options) {
+    return AccountSnapshotSchema.parse(
+      await this.http.get("/sapi/v1/accountSnapshot", { type, ...options }, "signed")
+    );
+  }
+  async apiKeyPermissions() {
+    return ApiKeyPermissionsSchema.parse(
+      await this.http.get("/sapi/v1/account/apiRestrictions", void 0, "signed")
+    );
+  }
+  async assetDetail(asset) {
+    const params = asset ? { asset } : void 0;
+    return AssetDetailSchema.parse(await this.http.get("/sapi/v1/asset/assetDetail", params, "signed"));
+  }
+  async dustLog(options) {
+    return DustLogResponseSchema.parse(
+      await this.http.get("/sapi/v1/asset/dribblet", options, "signed")
+    );
+  }
+  async convertDustToBnb(assets, accountType) {
+    return DustConversionResultSchema.parse(
+      await this.http.post("/sapi/v1/asset/dust", { asset: assets, accountType }, "signed")
+    );
+  }
+  async tradeFee(symbol3) {
+    const params = symbol3 ? { symbol: symbol3 } : void 0;
+    return TradeFeeResponseSchema.parse(await this.http.get("/sapi/v1/asset/tradeFee", params, "signed"));
+  }
+};
+
+// src/types/subaccount.types.ts
+var import_zod10 = require("zod");
+var SubAccountEntrySchema = import_zod10.z.object({
+  email: import_zod10.z.string(),
+  isFreeze: import_zod10.z.boolean(),
+  createTime: import_zod10.z.number(),
+  isManagedSubAccount: import_zod10.z.boolean().optional(),
+  isAssetManagementSubAccount: import_zod10.z.boolean().optional(),
+  type: import_zod10.z.string().optional()
+}).loose();
+var SubAccountListResponseSchema = import_zod10.z.object({
+  subAccounts: import_zod10.z.array(SubAccountEntrySchema)
+});
+var SubAccountStatusSchema = import_zod10.z.object({
+  email: import_zod10.z.string(),
+  isSubUserEnabled: import_zod10.z.boolean(),
+  isUserActive: import_zod10.z.boolean(),
+  insertTime: import_zod10.z.number(),
+  isMarginEnabled: import_zod10.z.boolean(),
+  isFutureEnabled: import_zod10.z.boolean(),
+  mobile: import_zod10.z.number().optional()
+}).loose();
+var SubAccountStatusResponseSchema = import_zod10.z.array(SubAccountStatusSchema);
+var SubAccountSpotAssetSchema = import_zod10.z.object({
+  asset: import_zod10.z.string(),
+  free: import_zod10.z.string().transform(Number),
+  locked: import_zod10.z.string().transform(Number)
+});
+var SubAccountSpotAssetsResponseSchema = import_zod10.z.object({
+  balances: import_zod10.z.array(SubAccountSpotAssetSchema)
+});
+var SubAccountSpotSummaryEntrySchema = import_zod10.z.object({
+  email: import_zod10.z.string(),
+  totalAsset: import_zod10.z.string().transform(Number)
+}).loose();
+var SubAccountSpotSummarySchema = import_zod10.z.object({
+  totalCount: import_zod10.z.number(),
+  masterAccountTotalAsset: import_zod10.z.string().transform(Number),
+  spotSubUserAssetBtcVoList: import_zod10.z.array(SubAccountSpotSummaryEntrySchema)
+});
+var SubAccountFuturesSummarySchema = import_zod10.z.object({
+  totalCount: import_zod10.z.number().optional(),
+  totalMarginBalanceOfBTC: import_zod10.z.string().transform(Number).optional(),
+  totalUnrealizedProfitOfBTC: import_zod10.z.string().transform(Number).optional(),
+  totalWalletBalanceOfBTC: import_zod10.z.string().transform(Number).optional(),
+  subAccountList: import_zod10.z.array(import_zod10.z.record(import_zod10.z.string(), import_zod10.z.unknown())).optional()
+}).loose();
+var SubAccountMarginAccountSchema = import_zod10.z.object({
+  email: import_zod10.z.string(),
+  marginLevel: import_zod10.z.string().transform(Number),
+  totalAssetOfBtc: import_zod10.z.string().transform(Number),
+  totalLiabilityOfBtc: import_zod10.z.string().transform(Number),
+  totalNetAssetOfBtc: import_zod10.z.string().transform(Number),
+  marginTradeCoeffVo: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.unknown()).optional(),
+  marginUserAssetVoList: import_zod10.z.array(import_zod10.z.record(import_zod10.z.string(), import_zod10.z.unknown())).optional()
+}).loose();
+var SubAccountUniversalTransferParamsSchema = import_zod10.z.object({
+  fromEmail: import_zod10.z.string().optional(),
+  toEmail: import_zod10.z.string().optional(),
+  fromAccountType: import_zod10.z.enum(["SPOT", "USDT_FUTURE", "COIN_FUTURE", "MARGIN", "ISOLATED_MARGIN"]),
+  toAccountType: import_zod10.z.enum(["SPOT", "USDT_FUTURE", "COIN_FUTURE", "MARGIN", "ISOLATED_MARGIN"]),
+  symbol: import_zod10.z.string().optional(),
+  asset: import_zod10.z.string(),
+  amount: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.number()]),
+  clientTranId: import_zod10.z.string().optional()
+});
+var SubAccountUniversalTransferResultSchema = import_zod10.z.object({
+  tranId: import_zod10.z.number(),
+  clientTranId: import_zod10.z.string().optional()
+});
+var SubAccountUniversalTransferEntrySchema = import_zod10.z.object({
+  tranId: import_zod10.z.number(),
+  fromEmail: import_zod10.z.string(),
+  toEmail: import_zod10.z.string(),
+  asset: import_zod10.z.string(),
+  amount: import_zod10.z.string().transform(Number),
+  fromAccountType: import_zod10.z.string(),
+  toAccountType: import_zod10.z.string(),
+  status: import_zod10.z.string(),
+  createTimeStamp: import_zod10.z.number(),
+  clientTranId: import_zod10.z.string().optional()
+}).loose();
+var SubAccountUniversalTransferHistoryResponseSchema = import_zod10.z.object({
+  result: import_zod10.z.array(SubAccountUniversalTransferEntrySchema),
+  totalCount: import_zod10.z.number()
+});
+var VirtualSubAccountResultSchema = import_zod10.z.object({ email: import_zod10.z.string() });
+var SubAccountDepositAddressSchema = import_zod10.z.object({
+  address: import_zod10.z.string(),
+  coin: import_zod10.z.string(),
+  tag: import_zod10.z.string(),
+  url: import_zod10.z.string().optional()
+});
+var SubAccountDepositHistoryEntrySchema = import_zod10.z.object({
+  id: import_zod10.z.string(),
+  amount: import_zod10.z.string().transform(Number),
+  coin: import_zod10.z.string(),
+  network: import_zod10.z.string(),
+  status: import_zod10.z.number(),
+  address: import_zod10.z.string(),
+  txId: import_zod10.z.string(),
+  insertTime: import_zod10.z.number(),
+  transferType: import_zod10.z.number()
+}).loose();
+var SubAccountDepositHistoryResponseSchema = import_zod10.z.array(SubAccountDepositHistoryEntrySchema);
+var SubAccountEnableResultSchema = import_zod10.z.object({
+  email: import_zod10.z.string(),
+  isFuturesEnabled: import_zod10.z.boolean().optional(),
+  isMarginEnabled: import_zod10.z.boolean().optional()
+}).loose();
+
+// src/resources/SubAccount.ts
+var SubAccount = class {
+  constructor(http2) {
+    this.http = http2;
+  }
+  async list(options) {
+    const res = await this.http.get("/sapi/v1/sub-account/list", options, "signed");
+    return SubAccountListResponseSchema.parse(res).subAccounts;
+  }
+  async status(email) {
+    const params = email ? { email } : void 0;
+    return SubAccountStatusResponseSchema.parse(
+      await this.http.get("/sapi/v1/sub-account/status", params, "signed")
+    );
+  }
+  async spotAssets(email) {
+    return SubAccountSpotAssetsResponseSchema.parse(
+      await this.http.get("/sapi/v3/sub-account/assets", { email }, "signed")
+    );
+  }
+  async spotSummary(options) {
+    return SubAccountSpotSummarySchema.parse(
+      await this.http.get("/sapi/v1/sub-account/spotSummary", options, "signed")
+    );
+  }
+  async futuresAccountSummary(futuresType) {
+    return SubAccountFuturesSummarySchema.parse(
+      await this.http.get("/sapi/v2/sub-account/futures/accountSummary", { futuresType }, "signed")
+    );
+  }
+  async marginAccount(email) {
+    return SubAccountMarginAccountSchema.parse(
+      await this.http.get("/sapi/v1/sub-account/margin/account", { email }, "signed")
+    );
+  }
+  async universalTransfer(params) {
+    return SubAccountUniversalTransferResultSchema.parse(
+      await this.http.post("/sapi/v1/sub-account/universalTransfer", params, "signed")
+    );
+  }
+  async universalTransferHistory(options) {
+    return SubAccountUniversalTransferHistoryResponseSchema.parse(
+      await this.http.get("/sapi/v1/sub-account/universalTransfer", options, "signed")
+    );
+  }
+  async createVirtualSubAccount(subAccountString) {
+    return VirtualSubAccountResultSchema.parse(
+      await this.http.post("/sapi/v1/sub-account/virtualSubAccount", { subAccountString }, "signed")
+    );
+  }
+  async enableFutures(email) {
+    return SubAccountEnableResultSchema.parse(
+      await this.http.post("/sapi/v1/sub-account/futures/enable", { email }, "signed")
+    );
+  }
+  async enableMargin(email) {
+    return SubAccountEnableResultSchema.parse(
+      await this.http.post("/sapi/v1/sub-account/margin/enable", { email }, "signed")
+    );
+  }
+  async depositAddress(email, coin, network) {
+    return SubAccountDepositAddressSchema.parse(
+      await this.http.get("/sapi/v1/capital/deposit/subAddress", { email, coin, network }, "signed")
+    );
+  }
+  async depositHistory(options) {
+    return SubAccountDepositHistoryResponseSchema.parse(
+      await this.http.get("/sapi/v1/capital/deposit/subHisrec", options, "signed")
+    );
+  }
+};
+
+// src/ws/BaseWS.ts
+var import_node_events = require("events");
+var import_ws = __toESM(require("ws"), 1);
+
+// src/types/ws.types.ts
+var import_zod11 = require("zod");
+var WsKlinePayloadSchema = import_zod11.z.object({
+  e: import_zod11.z.literal("kline"),
+  E: import_zod11.z.number(),
+  s: import_zod11.z.string(),
+  k: import_zod11.z.object({
+    t: import_zod11.z.number(),
+    T: import_zod11.z.number(),
+    s: import_zod11.z.string(),
+    i: import_zod11.z.string(),
+    o: import_zod11.z.string().transform(Number),
+    c: import_zod11.z.string().transform(Number),
+    h: import_zod11.z.string().transform(Number),
+    l: import_zod11.z.string().transform(Number),
+    v: import_zod11.z.string().transform(Number),
+    n: import_zod11.z.number(),
+    x: import_zod11.z.boolean(),
+    q: import_zod11.z.string().transform(Number),
+    V: import_zod11.z.string().transform(Number),
+    Q: import_zod11.z.string().transform(Number)
+  })
+});
+var WsAggTradePayloadSchema = import_zod11.z.object({
+  e: import_zod11.z.literal("aggTrade"),
+  E: import_zod11.z.number(),
+  s: import_zod11.z.string(),
+  a: import_zod11.z.number(),
+  p: import_zod11.z.string().transform(Number),
+  q: import_zod11.z.string().transform(Number),
+  f: import_zod11.z.number(),
+  l: import_zod11.z.number(),
+  T: import_zod11.z.number(),
+  m: import_zod11.z.boolean()
+});
+var WsTradePayloadSchema = import_zod11.z.object({
+  e: import_zod11.z.literal("trade"),
+  E: import_zod11.z.number(),
+  s: import_zod11.z.string(),
+  t: import_zod11.z.number(),
+  p: import_zod11.z.string().transform(Number),
+  q: import_zod11.z.string().transform(Number),
+  T: import_zod11.z.number(),
+  m: import_zod11.z.boolean()
+});
+var WsDepthUpdatePayloadSchema = import_zod11.z.object({
+  e: import_zod11.z.literal("depthUpdate"),
+  E: import_zod11.z.number(),
+  s: import_zod11.z.string(),
+  U: import_zod11.z.number(),
+  u: import_zod11.z.number(),
+  T: import_zod11.z.number().optional(),
+  pu: import_zod11.z.number().optional(),
+  b: import_zod11.z.array(import_zod11.z.tuple([import_zod11.z.string(), import_zod11.z.string()])),
+  a: import_zod11.z.array(import_zod11.z.tuple([import_zod11.z.string(), import_zod11.z.string()]))
+});
+var WsTicker24hrPayloadSchema = import_zod11.z.object({
+  e: import_zod11.z.literal("24hrTicker"),
+  E: import_zod11.z.number(),
+  s: import_zod11.z.string(),
+  p: import_zod11.z.string().transform(Number),
+  P: import_zod11.z.string().transform(Number),
+  c: import_zod11.z.string().transform(Number),
+  o: import_zod11.z.string().transform(Number),
+  h: import_zod11.z.string().transform(Number),
+  l: import_zod11.z.string().transform(Number),
+  v: import_zod11.z.string().transform(Number),
+  q: import_zod11.z.string().transform(Number)
+});
+var WsBookTickerPayloadSchema = import_zod11.z.object({
+  u: import_zod11.z.number(),
+  s: import_zod11.z.string(),
+  b: import_zod11.z.string().transform(Number),
+  B: import_zod11.z.string().transform(Number),
+  a: import_zod11.z.string().transform(Number),
+  A: import_zod11.z.string().transform(Number)
+});
+var WsMarkPricePayloadSchema = import_zod11.z.object({
+  e: import_zod11.z.literal("markPriceUpdate"),
+  E: import_zod11.z.number(),
+  s: import_zod11.z.string(),
+  p: import_zod11.z.string().transform(Number),
+  i: import_zod11.z.string().transform(Number),
+  P: import_zod11.z.string().transform(Number),
+  r: import_zod11.z.string().transform(Number),
+  T: import_zod11.z.number()
+});
+var WsMiniTickerPayloadSchema = import_zod11.z.object({
+  e: import_zod11.z.literal("24hrMiniTicker"),
+  E: import_zod11.z.number(),
+  s: import_zod11.z.string(),
+  c: import_zod11.z.string().transform(Number),
+  o: import_zod11.z.string().transform(Number),
+  h: import_zod11.z.string().transform(Number),
+  l: import_zod11.z.string().transform(Number),
+  v: import_zod11.z.string().transform(Number),
+  q: import_zod11.z.string().transform(Number)
+});
+var WsForceOrderPayloadSchema = import_zod11.z.object({
+  e: import_zod11.z.literal("forceOrder"),
+  E: import_zod11.z.number(),
+  o: import_zod11.z.object({
+    s: import_zod11.z.string(),
+    S: import_zod11.z.string(),
+    o: import_zod11.z.string(),
+    f: import_zod11.z.string(),
+    q: import_zod11.z.string().transform(Number),
+    p: import_zod11.z.string().transform(Number),
+    ap: import_zod11.z.string().transform(Number),
+    X: import_zod11.z.string(),
+    l: import_zod11.z.string().transform(Number),
+    z: import_zod11.z.string().transform(Number),
+    T: import_zod11.z.number()
+  })
+});
+var WsCompositeIndexPayloadSchema = import_zod11.z.object({
+  e: import_zod11.z.literal("compositeIndex"),
+  E: import_zod11.z.number(),
+  s: import_zod11.z.string(),
+  p: import_zod11.z.string().transform(Number),
+  c: import_zod11.z.array(
+    import_zod11.z.object({
+      b: import_zod11.z.string(),
+      q: import_zod11.z.string(),
+      w: import_zod11.z.string().transform(Number),
+      p: import_zod11.z.string().transform(Number)
+    })
+  )
+});
+var WsAssetIndexPayloadSchema = import_zod11.z.object({
+  e: import_zod11.z.literal("assetIndex"),
+  E: import_zod11.z.number(),
+  s: import_zod11.z.string(),
+  i: import_zod11.z.string().transform(Number),
+  b: import_zod11.z.string().transform(Number),
+  a: import_zod11.z.string().transform(Number)
+});
+var WsRollingWindowTickerPayloadSchema = import_zod11.z.object({
+  e: import_zod11.z.enum(["1hTicker", "4hTicker", "1dTicker", "7dTicker", "30dTicker"]),
+  E: import_zod11.z.number(),
+  s: import_zod11.z.string(),
+  p: import_zod11.z.string().transform(Number),
+  P: import_zod11.z.string().transform(Number),
+  o: import_zod11.z.string().transform(Number),
+  h: import_zod11.z.string().transform(Number),
+  l: import_zod11.z.string().transform(Number),
+  c: import_zod11.z.string().transform(Number),
+  v: import_zod11.z.string().transform(Number),
+  q: import_zod11.z.string().transform(Number),
+  O: import_zod11.z.number(),
+  C: import_zod11.z.number()
+});
+var WsSpotAvgPricePayloadSchema = import_zod11.z.object({
+  e: import_zod11.z.literal("avgPrice"),
+  E: import_zod11.z.number(),
+  s: import_zod11.z.string(),
+  i: import_zod11.z.string(),
+  w: import_zod11.z.string().transform(Number),
+  T: import_zod11.z.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 import_node_events.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 === import_ws.default.OPEN) this.ws.close();
+    this.reconnectAttempt = 0;
+    if (!this.closedByUser) this.connect();
+  }
+  resetReconnectAttempts() {
+    this.reconnectAttempt = 0;
+  }
+  isOpen() {
+    return this.ws?.readyState === import_ws.default.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 import_ws.default(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}`;
@@ -2314,48 +3711,185 @@ var SpotUserWS = class extends import_node_events2.EventEmitter {
       this.emit("error", err);
     });
   }
-  close() {
-    this.closedByUser = true;
-    this.ws?.close();
+  close() {
+    this.closedByUser = true;
+    this.ws?.close();
+  }
+  reconnect() {
+    if (this.ws?.readyState === import_ws2.default.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
+var import_node_events3 = require("events");
+var import_ws3 = __toESM(require("ws"), 1);
+var FuturesUserWS = class extends import_node_events3.EventEmitter {
+  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 import_ws3.default(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 === import_ws3.default.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/CoinMMarketWS.ts
+var CoinMMarketWS = class extends BaseWS {
+  constructor(baseStreamUrl = "wss://dstream.binance.com/stream") {
+    super({ baseStreamUrl });
+  }
+  kline(symbol3, interval) {
+    return `${symbol3.toLowerCase()}@kline_${interval}`;
+  }
+  continuousKline(pair, contractType2, interval) {
+    return `${pair.toLowerCase()}_${contractType2}@continuousKline_${interval}`;
+  }
+  indexPriceKline(pair, interval) {
+    return `${pair.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`;
+  }
+  allMarketTickers() {
+    return "!ticker@arr";
+  }
+  miniTicker(symbol3) {
+    return `${symbol3.toLowerCase()}@miniTicker`;
+  }
+  allMiniTickers() {
+    return "!miniTicker@arr";
+  }
+  bookTicker(symbol3) {
+    return `${symbol3.toLowerCase()}@bookTicker`;
   }
-  reconnect() {
-    if (this.ws?.readyState === import_ws2.default.OPEN) this.ws.close();
-    this.reconnectAttempt = 0;
-    if (!this.closedByUser) this.connect();
+  allBookTickers() {
+    return "!bookTicker";
   }
-  resetReconnectAttempts() {
-    this.reconnectAttempt = 0;
+  markPrice(symbol3, updateSpeed = "3s") {
+    return `${symbol3.toLowerCase()}@markPrice@${updateSpeed}`;
   }
-  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);
-    }
+  markPriceForPair(pair, updateSpeed = "3s") {
+    return `${pair.toLowerCase()}@markPrice@${updateSpeed}`;
   }
-  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);
+  liquidationOrder(symbol3) {
+    return `${symbol3.toLowerCase()}@forceOrder`;
+  }
+  allLiquidationOrders() {
+    return "!forceOrder@arr";
   }
 };
 
-// src/ws/FuturesUserWS.ts
-var import_node_events3 = require("events");
-var import_ws3 = __toESM(require("ws"), 1);
-var FuturesUserWS = class extends import_node_events3.EventEmitter {
+// src/ws/CoinMUserWS.ts
+var import_node_events4 = require("events");
+var import_ws4 = __toESM(require("ws"), 1);
+var CoinMUserWS = class extends import_node_events4.EventEmitter {
   constructor(options) {
     super();
     this.options = options;
@@ -2366,12 +3900,12 @@ var FuturesUserWS = class extends import_node_events3.EventEmitter {
   connect() {
     const listenKey = this.options.getListenKey();
     if (!listenKey) {
-      this.emit("error", new Error("No listenKey available for user data stream"));
+      this.emit("error", new Error("No listenKey available for COIN-M user data stream"));
       return;
     }
     this.closedByUser = false;
     const url = `${this.options.baseUserUrl}/${listenKey}`;
-    this.ws = new import_ws3.default(url);
+    this.ws = new import_ws4.default(url);
     this.ws.on("open", () => {
       this.reconnectAttempt = 0;
       this.emit("open");
@@ -2392,7 +3926,7 @@ var FuturesUserWS = class extends import_node_events3.EventEmitter {
     this.ws?.close();
   }
   reconnect() {
-    if (this.ws?.readyState === import_ws3.default.OPEN) this.ws.close();
+    if (this.ws?.readyState === import_ws4.default.OPEN) this.ws.close();
     this.reconnectAttempt = 0;
     if (!this.closedByUser) this.connect();
   }
@@ -2427,31 +3961,36 @@ var FuturesUserWS = class extends import_node_events3.EventEmitter {
 
 // src/ws/WsApi.ts
 var import_node_crypto2 = require("crypto");
-var import_ws4 = __toESM(require("ws"), 1);
+var import_ws5 = __toESM(require("ws"), 1);
 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;
+    this.signer = new Signer({
+      algorithm: options.signatureAlgorithm,
+      apiSecret: options.apiSecret,
+      privateKey: options.privateKey
+    });
   }
   async request(method, params = {}, options) {
-    const { apiKey, apiSecret } = this.options;
+    const { apiKey } = this.options;
     const signed = options?.signed ?? true;
     const { id = (0, import_node_crypto2.randomUUID)(), ...methodParams } = params;
     const requestParams = { ...methodParams };
     if (signed) {
-      if (!apiKey || !apiSecret) {
-        throw new Error("API key and secret required for signed WebSocket API requests");
+      if (!apiKey || !this.signer.canSign()) {
+        throw new Error("API key and secret (or privateKey) 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 = (0, import_node_crypto2.createHmac)("sha256", apiSecret).update(queryString).digest("hex");
+      requestParams.signature = this.signer.sign(queryString);
     }
     return new Promise((resolve, reject) => {
-      const ws = new import_ws4.default(this.options.baseUrl);
+      const ws = new import_ws5.default(this.options.baseUrl);
       const timeout = setTimeout(() => {
         ws.close();
         reject(new NetworkError(`WebSocket API request timed out: ${method}`));
@@ -2552,6 +4091,174 @@ var WsApi = class {
   }
 };
 
+// src/ws/SpotWsApi.ts
+var import_node_crypto3 = require("crypto");
+var import_ws6 = __toESM(require("ws"), 1);
+function buildQueryString2(data) {
+  return Object.entries(data).filter(([, val]) => val !== void 0 && val !== null).map(([key, val]) => `${key}=${encodeURIComponent(String(val))}`).join("&");
+}
+var SpotWsApi = class {
+  constructor(options) {
+    this.options = options;
+    this.signer = new Signer({
+      algorithm: options.signatureAlgorithm,
+      apiSecret: options.apiSecret,
+      privateKey: options.privateKey
+    });
+  }
+  async request(method, params = {}, options) {
+    const { apiKey } = this.options;
+    const signed = options?.signed ?? true;
+    const { id = (0, import_node_crypto3.randomUUID)(), ...methodParams } = params;
+    const requestParams = { ...methodParams };
+    if (signed) {
+      if (!apiKey || !this.signer.canSign()) {
+        throw new Error("API key and secret (or privateKey) required for signed WebSocket API requests");
+      }
+      requestParams.apiKey = apiKey;
+      requestParams.timestamp = Date.now();
+      requestParams.recvWindow = this.options.recvWindow ?? 5e3;
+      const queryString = buildQueryString2(requestParams);
+      requestParams.signature = this.signer.sign(queryString);
+    }
+    return new Promise((resolve, reject) => {
+      const ws = new import_ws6.default(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));
+      });
+    });
+  }
+  // ---- Trading (signed) ----
+  placeOrder(params) {
+    return this.request("order.place", params);
+  }
+  testOrder(params) {
+    return this.request("order.test", params);
+  }
+  cancelOrder(params) {
+    return this.request("order.cancel", params);
+  }
+  cancelReplaceOrder(params) {
+    return this.request("order.cancelReplace", params);
+  }
+  orderStatus(params) {
+    return this.request("order.status", params);
+  }
+  openOrdersStatus(params = {}) {
+    return this.request("openOrders.status", params);
+  }
+  cancelOpenOrders(params) {
+    return this.request("openOrders.cancelAll", 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);
+  }
+  openOrderListsStatus() {
+    return this.request("openOrderLists.status", {});
+  }
+  // ---- Account (signed) ----
+  accountStatus() {
+    return this.request("account.status", {});
+  }
+  accountCommission(params) {
+    return this.request("account.commission", params);
+  }
+  accountRateLimitsOrders() {
+    return this.request("account.rateLimits.orders", {});
+  }
+  allOrders(params) {
+    return this.request("allOrders", params);
+  }
+  allOrderLists(params = {}) {
+    return this.request("allOrderLists", params);
+  }
+  myTrades(params) {
+    return this.request("myTrades", params);
+  }
+  // ---- User data stream (managed listen keys) ----
+  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) ----
+  ping() {
+    return this.request("ping", {}, { signed: false });
+  }
+  time() {
+    return this.request("time", {}, { signed: false });
+  }
+  exchangeInfo(params = {}) {
+    return this.request("exchangeInfo", params, { signed: false });
+  }
+  depth(params) {
+    return this.request("depth", params, { signed: false });
+  }
+  recentTrades(params) {
+    return this.request("trades.recent", params, { signed: false });
+  }
+  historicalTrades(params) {
+    return this.request("trades.historical", params, { signed: false });
+  }
+  aggTrades(params) {
+    return this.request("trades.aggregate", params, { signed: false });
+  }
+  klines(params) {
+    return this.request("klines", params, { signed: false });
+  }
+  uiKlines(params) {
+    return this.request("uiKlines", params, { signed: false });
+  }
+  avgPrice(params) {
+    return this.request("avgPrice", params, { signed: false });
+  }
+  ticker24hr(params = {}) {
+    return this.request("ticker.24hr", params, { signed: false });
+  }
+  tickerTradingDay(params) {
+    return this.request("ticker.tradingDay", params, { signed: false });
+  }
+  tickerPrice(params = {}) {
+    return this.request("ticker.price", params, { signed: false });
+  }
+  tickerBook(params = {}) {
+    return this.request("ticker.book", params, { signed: false });
+  }
+  ticker(params) {
+    return this.request("ticker", params, { signed: false });
+  }
+};
+
 // src/client/BinanceClient.ts
 var BinanceClient = class {
   constructor(options = {}) {
@@ -2559,18 +4266,29 @@ var BinanceClient = class {
     this.keepAliveInterval = null;
     this.spotListenKeyValue = null;
     this.spotKeepAliveInterval = null;
+    this.coinmListenKeyValue = null;
+    this.coinmKeepAliveInterval = null;
     const { endpoints } = resolveEnvironment(options);
+    this.policy = options.safety ? new TradingPolicy(options.safety) : void 0;
     const httpOptions = {
+      policy: this.policy,
       apiKey: options.apiKey,
       apiSecret: options.apiSecret,
+      privateKey: options.privateKey,
+      signatureAlgorithm: options.signatureAlgorithm,
       recvWindow: options.recvWindow ?? 5e3,
       timeoutMs: options.timeoutMs ?? 15e3,
       maxRetries: options.maxRetries ?? 3,
       retryBaseDelayMs: options.retryBaseDelayMs,
-      retryMaxDelayMs: options.retryMaxDelayMs
+      retryMaxDelayMs: options.retryMaxDelayMs,
+      rateLimitWeightPerMinute: options.rateLimitWeightPerMinute,
+      rateLimitSafetyMargin: options.rateLimitSafetyMargin,
+      httpsAgent: options.httpsAgent,
+      proxy: options.proxy
     };
     this.authHttp = new HttpClient({ baseURL: endpoints.restRoot, ...httpOptions });
-    const spotHttp = new HttpClient({ baseURL: endpoints.restSpot, ...httpOptions });
+    this.spotHttp = new HttpClient({ baseURL: endpoints.restSpot, ...httpOptions });
+    const spotHttp = this.spotHttp;
     this.spot = {
       market: new SpotMarket(spotHttp),
       account: new SpotAccount(spotHttp),
@@ -2580,6 +4298,14 @@ var BinanceClient = class {
       wsUser: new SpotUserWS({
         baseUserUrl: endpoints.wsSpotUser,
         getListenKey: () => this.spotListenKeyValue
+      }),
+      wsApi: new SpotWsApi({
+        baseUrl: endpoints.wsSpotApi,
+        apiKey: options.apiKey,
+        apiSecret: options.apiSecret,
+        privateKey: options.privateKey,
+        signatureAlgorithm: options.signatureAlgorithm,
+        recvWindow: options.recvWindow
       })
     };
     const futuresMarket = new FuturesMarket(
@@ -2609,9 +4335,30 @@ var BinanceClient = class {
         baseUrl: endpoints.wsApi,
         apiKey: options.apiKey,
         apiSecret: options.apiSecret,
+        privateKey: options.privateKey,
+        signatureAlgorithm: options.signatureAlgorithm,
         recvWindow: options.recvWindow
       })
     };
+    this.dapiHttp = new HttpClient({ baseURL: endpoints.restDapiRoot, ...httpOptions });
+    this.coinm = {
+      market: new CoinMMarket(new HttpClient({ baseURL: endpoints.restDapi, ...httpOptions })),
+      account: new CoinMAccount(this.dapiHttp),
+      trading: new CoinMTrading(this.dapiHttp),
+      userStream: new CoinMUserDataStream(this.dapiHttp),
+      ws: new CoinMMarketWS(endpoints.wsDapiMarket),
+      wsUser: new CoinMUserWS({
+        baseUserUrl: endpoints.wsDapiUser,
+        getListenKey: () => this.coinmListenKeyValue
+      })
+    };
+    this.sapiHttp = new HttpClient({ baseURL: endpoints.restApiRoot, ...httpOptions });
+    this.margin = {
+      account: new MarginAccount(this.sapiHttp),
+      trading: new MarginTrading(this.sapiHttp)
+    };
+    this.wallet = new Wallet(this.sapiHttp);
+    this.subaccount = new SubAccount(this.sapiHttp);
   }
   static nowSeconds() {
     return Math.floor(Date.now() / 1e3);
@@ -2628,6 +4375,31 @@ var BinanceClient = class {
     const dir = side3 === "buy" ? 1 : -1;
     return dir === 1 ? entryPrice * (1 - 1 / leverage + mm) : entryPrice * (1 + 1 / leverage - mm);
   }
+  /**
+   * Syncs local time against each REST host's server clock and stores the offset, applied to
+   * every subsequent signed request's `timestamp` param. Call this once after construction to
+   * mitigate `-1021` errors caused by local clock drift.
+   */
+  async syncTime() {
+    await Promise.all([
+      this.authHttp.syncTime("/fapi/v1/time"),
+      this.spotHttp.syncTime("/time"),
+      this.dapiHttp.syncTime("/dapi/v1/time"),
+      this.sapiHttp.syncTime("/api/v3/time")
+    ]);
+  }
+  /**
+   * Snapshot of the most recently observed `X-MBX-USED-WEIGHT-*` / `X-MBX-ORDER-COUNT-*`
+   * response headers, per REST host. Each host tracks its own weight budget independently.
+   */
+  getRateLimitUsage() {
+    return {
+      spot: this.spotHttp.getRateLimitUsage(),
+      futures: this.authHttp.getRateLimitUsage(),
+      coinm: this.dapiHttp.getRateLimitUsage(),
+      sapi: this.sapiHttp.getRateLimitUsage()
+    };
+  }
   async startUserStream() {
     const { listenKey } = await this.futures.userStream.createListenKey();
     this.listenKeyValue = listenKey;
@@ -2664,25 +4436,50 @@ var BinanceClient = class {
     });
     this.spotListenKeyValue = null;
   }
+  async startCoinMUserStream() {
+    const { listenKey } = await this.coinm.userStream.createListenKey();
+    this.coinmListenKeyValue = listenKey;
+    this.coinmKeepAliveInterval = setInterval(() => {
+      this.coinm.userStream.keepAliveListenKey().catch(() => {
+      });
+    }, 30 * 60 * 1e3);
+    this.coinm.wsUser.connect();
+    return listenKey;
+  }
+  closeCoinMUserStream() {
+    if (this.coinmKeepAliveInterval) clearInterval(this.coinmKeepAliveInterval);
+    this.coinmKeepAliveInterval = null;
+    this.coinm.wsUser.close();
+    this.coinm.userStream.closeListenKey().catch(() => {
+    });
+    this.coinmListenKeyValue = null;
+  }
   closeAllWebSockets() {
     this.futures.ws.close();
     this.futures.wsUser.close();
     this.spot.ws.close();
     this.spot.wsUser.close();
+    this.coinm.ws.close();
+    this.coinm.wsUser.close();
     this.closeUserStream();
     this.closeSpotUserStream();
+    this.closeCoinMUserStream();
   }
   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();
+    else if (target === "spotUser") this.spot.wsUser.reconnect();
+    else if (target === "coinm") this.coinm.ws.reconnect();
+    else this.coinm.wsUser.reconnect();
   }
   resetReconnectAttempts() {
     this.futures.ws.resetReconnectAttempts();
     this.futures.wsUser.resetReconnectAttempts();
     this.spot.ws.resetReconnectAttempts();
     this.spot.wsUser.resetReconnectAttempts();
+    this.coinm.ws.resetReconnectAttempts();
+    this.coinm.wsUser.resetReconnectAttempts();
   }
 };
 
@@ -2690,10 +4487,10 @@ var BinanceClient = class {
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 
 // src/tools/account.tools.ts
-var import_zod9 = require("zod");
+var import_zod13 = require("zod");
 
 // src/tools/types.ts
-var import_zod8 = require("zod");
+var import_zod12 = require("zod");
 function normalizeSymbol(value) {
   return String(value ?? "").trim().toUpperCase();
 }
@@ -2702,248 +4499,248 @@ function textResult(data) {
 }
 
 // src/tools/account.tools.ts
-var optionalSymbol = import_zod9.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional();
-var limit = import_zod9.z.number().int().positive().max(1e3).default(100);
-var startTime = import_zod9.z.number().int().positive().optional();
-var endTime = import_zod9.z.number().int().positive().optional();
+var optionalSymbol = import_zod13.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional();
+var limit = import_zod13.z.number().int().positive().max(1e3).default(100);
+var startTime = import_zod13.z.number().int().positive().optional();
+var endTime = import_zod13.z.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: import_zod9.z.object({}),
+      inputSchema: import_zod13.z.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: import_zod9.z.object({}),
+      inputSchema: import_zod13.z.object({}),
       handler: async () => textResult(await a.accountV3())
     },
     {
       name: "futures_balance_v2",
       description: "Get futures account balance (v2 legacy) per asset (signed).",
-      inputSchema: import_zod9.z.object({}),
+      inputSchema: import_zod13.z.object({}),
       handler: async () => textResult(await a.balance())
     },
     {
       name: "futures_account_v2",
       description: "Get futures account information (v2 legacy) (signed).",
-      inputSchema: import_zod9.z.object({}),
+      inputSchema: import_zod13.z.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: import_zod9.z.object({ symbol: optionalSymbol }),
+      inputSchema: import_zod13.z.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: import_zod9.z.object({ symbol: optionalSymbol, incomeType: import_zod9.z.string().optional().describe("e.g. TRANSFER, REALIZED_PNL, FUNDING_FEE, COMMISSION"), startTime, endTime, limit: limit.default(100) }),
+      inputSchema: import_zod13.z.object({ symbol: optionalSymbol, incomeType: import_zod13.z.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: import_zod9.z.object({ symbol: import_zod9.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), startTime, endTime, limit: limit.default(100), fromId: import_zod9.z.number().int().positive().optional() }),
+      inputSchema: import_zod13.z.object({ symbol: import_zod13.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), startTime, endTime, limit: limit.default(100), fromId: import_zod13.z.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: import_zod9.z.object({ symbol: optionalSymbol }),
+      inputSchema: import_zod13.z.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: import_zod9.z.object({ symbol: import_zod9.z.string().min(1).describe("USD-M pair, e.g. ETHUSDT") }),
+      inputSchema: import_zod13.z.object({ symbol: import_zod13.z.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: import_zod9.z.object({}),
+      inputSchema: import_zod13.z.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: import_zod9.z.object({ enabled: import_zod9.z.boolean().describe("true to enable, false to disable") }),
+      inputSchema: import_zod13.z.object({ enabled: import_zod13.z.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: import_zod9.z.object({}),
+      inputSchema: import_zod13.z.object({}),
       handler: async () => textResult(await a.feeBurnStatus())
     },
     {
       name: "futures_set_fee_burn",
       description: "Toggle BNB fee burn on futures trades (signed).",
-      inputSchema: import_zod9.z.object({ enabled: import_zod9.z.boolean().describe("true to enable fee burn") }),
+      inputSchema: import_zod13.z.object({ enabled: import_zod13.z.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: import_zod9.z.object({}),
+      inputSchema: import_zod13.z.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: import_zod9.z.object({ hedgeMode: import_zod9.z.boolean().describe("true = hedge mode, false = one-way") }),
+      inputSchema: import_zod13.z.object({ hedgeMode: import_zod13.z.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: import_zod9.z.object({}),
+      inputSchema: import_zod13.z.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: import_zod9.z.object({ symbol: import_zod9.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), type: import_zod9.z.enum(["1", "2"]).describe("1 = add margin, 2 = reduce margin"), startTime, endTime, limit: limit.default(50) }),
+      inputSchema: import_zod13.z.object({ symbol: import_zod13.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), type: import_zod13.z.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: import_zod9.z.object({}),
+      inputSchema: import_zod13.z.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: import_zod9.z.object({ symbol: optionalSymbol, startTime, endTime }),
+      inputSchema: import_zod13.z.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: import_zod9.z.object({ downloadId: import_zod9.z.string().min(1) }),
+      inputSchema: import_zod13.z.object({ downloadId: import_zod13.z.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: import_zod9.z.object({ symbol: optionalSymbol, startTime, endTime }),
+      inputSchema: import_zod13.z.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: import_zod9.z.object({ downloadId: import_zod9.z.string().min(1) }),
+      inputSchema: import_zod13.z.object({ downloadId: import_zod13.z.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: import_zod9.z.object({}),
+      inputSchema: import_zod13.z.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: import_zod9.z.object({ asset: import_zod9.z.string().min(1).describe("Asset, e.g. USDT") }),
+      inputSchema: import_zod13.z.object({ asset: import_zod13.z.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: import_zod9.z.object({ startTime: startTime.unwrap(), endTime: endTime.unwrap() }),
+      inputSchema: import_zod13.z.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: import_zod9.z.object({ downloadId: import_zod9.z.string().min(1) }),
+      inputSchema: import_zod13.z.object({ downloadId: import_zod13.z.string().min(1) }),
       handler: async ({ downloadId }) => textResult(await a.getIncomeDownloadStatus(downloadId))
     }
   ];
 }
 
 // src/tools/derived.tools.ts
-var import_zod10 = require("zod");
-var symbol = import_zod10.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT");
+var import_zod14 = require("zod");
+var symbol = import_zod14.z.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: import_zod10.z.object({ symbol, refresh: import_zod10.z.boolean().default(false).describe("Bypass the 60s cache") }),
+      inputSchema: import_zod14.z.object({ symbol, refresh: import_zod14.z.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: import_zod10.z.object({
+      inputSchema: import_zod14.z.object({
         symbol,
-        price: import_zod10.z.number().positive().optional(),
-        quantity: import_zod10.z.number().positive().optional(),
-        marketOrder: import_zod10.z.boolean().default(false).describe("Use MARKET_LOT_SIZE bounds instead of LOT_SIZE")
+        price: import_zod14.z.number().positive().optional(),
+        quantity: import_zod14.z.number().positive().optional(),
+        marketOrder: import_zod14.z.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: import_zod10.z.object({
+      inputSchema: import_zod14.z.object({
         symbol,
-        side: import_zod10.z.enum(["BUY", "SELL"]),
-        stopPrice: import_zod10.z.number().positive().describe("Protective stop price"),
-        entryPrice: import_zod10.z.number().positive().optional().describe("Defaults to current mark price"),
-        riskAmount: import_zod10.z.number().positive().optional().describe("Quote-currency amount to risk, e.g. 50 USDT"),
-        riskPct: import_zod10.z.number().positive().max(100).optional().describe("Percent of available balance to risk (signed call)"),
-        leverage: import_zod10.z.number().int().min(1).max(125).optional().describe("Used to report required margin"),
-        marketOrder: import_zod10.z.boolean().default(false)
+        side: import_zod14.z.enum(["BUY", "SELL"]),
+        stopPrice: import_zod14.z.number().positive().describe("Protective stop price"),
+        entryPrice: import_zod14.z.number().positive().optional().describe("Defaults to current mark price"),
+        riskAmount: import_zod14.z.number().positive().optional().describe("Quote-currency amount to risk, e.g. 50 USDT"),
+        riskPct: import_zod14.z.number().positive().max(100).optional().describe("Percent of available balance to risk (signed call)"),
+        leverage: import_zod14.z.number().int().min(1).max(125).optional().describe("Used to report required margin"),
+        marketOrder: import_zod14.z.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: import_zod10.z.object({
+      inputSchema: import_zod14.z.object({
         symbol,
-        positionSide: import_zod10.z.enum(["BOTH", "LONG", "SHORT"]).optional().describe("Required when hedge mode has both sides open"),
-        portion: import_zod10.z.number().positive().max(1).default(1).describe("Fraction of the position to close, e.g. 0.5 for half"),
-        dryRun: import_zod10.z.boolean().default(false)
+        positionSide: import_zod14.z.enum(["BOTH", "LONG", "SHORT"]).optional().describe("Required when hedge mode has both sides open"),
+        portion: import_zod14.z.number().positive().max(1).default(1).describe("Fraction of the position to close, e.g. 0.5 for half"),
+        dryRun: import_zod14.z.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: import_zod10.z.object({
+      inputSchema: import_zod14.z.object({
         symbol,
-        period: import_zod10.z.enum(["5m", "15m", "30m", "1h", "2h", "4h", "6h", "12h", "1d"]).default("1h")
+        period: import_zod14.z.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: import_zod10.z.object({}),
+      inputSchema: import_zod14.z.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: import_zod10.z.object({
+      inputSchema: import_zod14.z.object({
         symbol,
-        side: import_zod10.z.enum(["BUY", "SELL"]),
-        quantity: import_zod10.z.union([import_zod10.z.string(), import_zod10.z.number()]),
-        entryPrice: import_zod10.z.number().positive().optional().describe("Omit for a MARKET entry"),
-        stopLossPrice: import_zod10.z.number().positive(),
-        takeProfitPrice: import_zod10.z.number().positive().optional(),
-        positionSide: import_zod10.z.enum(["BOTH", "LONG", "SHORT"]).optional(),
-        workingType: import_zod10.z.enum(["MARK_PRICE", "CONTRACT_PRICE"]).default("MARK_PRICE")
+        side: import_zod14.z.enum(["BUY", "SELL"]),
+        quantity: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]),
+        entryPrice: import_zod14.z.number().positive().optional().describe("Omit for a MARKET entry"),
+        stopLossPrice: import_zod14.z.number().positive(),
+        takeProfitPrice: import_zod14.z.number().positive().optional(),
+        positionSide: import_zod14.z.enum(["BOTH", "LONG", "SHORT"]).optional(),
+        workingType: import_zod14.z.enum(["MARK_PRICE", "CONTRACT_PRICE"]).default("MARK_PRICE")
       }),
       handler: async (args) => textResult(await ops.placeBracketOrder({ ...args, symbol: normalizeSymbol(args.symbol) }))
     }
@@ -2951,14 +4748,14 @@ function derivedTools(client) {
 }
 
 // src/tools/market-data.tools.ts
-var import_zod11 = require("zod");
+var import_zod15 = require("zod");
 var u = (s) => s.optional();
-var optSymbol = u(import_zod11.z.string().min(1)).describe("USD-M pair, e.g. BTCUSDT");
-var limitDefault = import_zod11.z.number().int().positive().max(1500).default(100);
-var startTime2 = import_zod11.z.number().int().positive().optional();
-var endTime2 = import_zod11.z.number().int().positive().optional();
-var period = import_zod11.z.enum(["5m", "15m", "30m", "1h", "2h", "4h", "6h", "12h", "1d"]).default("1h");
-var contractType = import_zod11.z.enum(["perpetual", "current_quarter", "next_quarter"]).default("perpetual");
+var optSymbol = u(import_zod15.z.string().min(1)).describe("USD-M pair, e.g. BTCUSDT");
+var limitDefault = import_zod15.z.number().int().positive().max(1500).default(100);
+var startTime2 = import_zod15.z.number().int().positive().optional();
+var endTime2 = import_zod15.z.number().int().positive().optional();
+var period = import_zod15.z.enum(["5m", "15m", "30m", "1h", "2h", "4h", "6h", "12h", "1d"]).default("1h");
+var contractType = import_zod15.z.enum(["perpetual", "current_quarter", "next_quarter"]).default("perpetual");
 function marketDataTools(client) {
   const m = client.futures.market;
   const d = client.futures.data;
@@ -2966,65 +4763,65 @@ function marketDataTools(client) {
     {
       name: "futures_ping",
       description: "Test connectivity to the Binance USD-M futures REST API. Returns empty object {} on success.",
-      inputSchema: import_zod11.z.object({}),
+      inputSchema: import_zod15.z.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: import_zod11.z.object({}),
+      inputSchema: import_zod15.z.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: import_zod11.z.object({}),
+      inputSchema: import_zod15.z.object({}),
       handler: async () => textResult(await m.exchangeInfo())
     },
     {
       name: "futures_ticker_price",
       description: "Get latest price for one symbol (v1).",
-      inputSchema: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: optSymbol }),
+      inputSchema: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: optSymbol }),
+      inputSchema: import_zod15.z.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: import_zod11.z.object({
-        symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
-        limit: import_zod11.z.enum(["5", "10", "20", "50", "100", "500", "1000"]).default("100")
+      inputSchema: import_zod15.z.object({
+        symbol: import_zod15.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        limit: import_zod15.z.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: import_zod11.z.object({
-        symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+      inputSchema: import_zod15.z.object({
+        symbol: import_zod15.z.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)))
@@ -3032,30 +4829,30 @@ function marketDataTools(client) {
     {
       name: "futures_historical_trades",
       description: "Get older trades for a symbol by fromId (older than recent).",
-      inputSchema: import_zod11.z.object({
-        symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+      inputSchema: import_zod15.z.object({
+        symbol: import_zod15.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
         limit: limitDefault.default(500),
-        fromId: import_zod11.z.number().int().positive().optional()
+        fromId: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({
-        symbol: import_zod11.z.string().min(1).describe("Base pair, e.g. BTCUSDT"),
+      inputSchema: import_zod15.z.object({
+        symbol: import_zod15.z.string().min(1).describe("Base pair, e.g. BTCUSDT"),
         contractType,
         interval: KlineIntervalSchema,
         limit: limitDefault.default(500),
@@ -3067,80 +4864,80 @@ function marketDataTools(client) {
     {
       name: "futures_index_price_klines",
       description: "Get index price candlesticks for a pair (e.g. BTCUSDT index).",
-      inputSchema: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("Base pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: limitDefault.default(100), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({}),
+      inputSchema: import_zod15.z.object({}),
       handler: async () => textResult(await d.fundingInfo())
     },
     {
       name: "futures_open_interest",
       description: "Get the current total open interest for a symbol.",
-      inputSchema: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), period, limit: limitDefault.default(30) }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({
-        symbol: import_zod11.z.string().min(1).describe("Base pair, e.g. BTCUSDT"),
+      inputSchema: import_zod15.z.object({
+        symbol: import_zod15.z.string().min(1).describe("Base pair, e.g. BTCUSDT"),
         period,
         limit: limitDefault.default(30),
         startTime: startTime2,
@@ -3151,63 +4948,63 @@ function marketDataTools(client) {
     {
       name: "futures_asset_index",
       description: "Get multi-assets mode asset index (collateral price) for one asset or all assets.",
-      inputSchema: import_zod11.z.object({ symbol: optSymbol.describe("Asset index symbol, e.g. ADAUSD") }),
+      inputSchema: import_zod15.z.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: import_zod11.z.object({ symbol: optSymbol }),
+      inputSchema: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BNBUSDT"), limit: limitDefault.default(100), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), interval: KlineIntervalSchema, limit: limitDefault.default(500), startTime: startTime2, endTime: endTime2 }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: import_zod11.z.number().int().positive().default(1e3) }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"), limit: import_zod15.z.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: import_zod11.z.object({ symbol: import_zod11.z.string().min(1).describe("Base pair, e.g. BTCUSDT") }),
+      inputSchema: import_zod15.z.object({ symbol: import_zod15.z.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: import_zod11.z.object({ symbol: optSymbol }),
+      inputSchema: import_zod15.z.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: import_zod11.z.object({ symbol: optSymbol }),
+      inputSchema: import_zod15.z.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: import_zod11.z.object({
+      inputSchema: import_zod15.z.object({
         symbol: optSymbol,
-        autoCloseType: import_zod11.z.enum(["LIQUIDATION", "ADL"]).optional(),
+        autoCloseType: import_zod15.z.enum(["LIQUIDATION", "ADL"]).optional(),
         startTime: startTime2,
         endTime: endTime2,
         limit: limitDefault.default(50)
@@ -3227,7 +5024,7 @@ function marketDataTools(client) {
 }
 
 // src/tools/paper.tools.ts
-var import_zod12 = require("zod");
+var import_zod16 = require("zod");
 function createPaperContext(client, initialState = {}) {
   return {
     client,
@@ -3245,7 +5042,7 @@ function paperTools(ctx) {
     {
       name: "paper_init",
       description: "Initialize paper-trading state (reset balances, positions, history). No API keys required.",
-      inputSchema: import_zod12.z.object({ balance: import_zod12.z.number().positive().default(1e4).describe("Starting USDT balance") }),
+      inputSchema: import_zod16.z.object({ balance: import_zod16.z.number().positive().default(1e4).describe("Starting USDT balance") }),
       handler: async ({ balance }) => {
         s.balance = balance;
         s.positions = [];
@@ -3256,17 +5053,17 @@ function paperTools(ctx) {
     {
       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: import_zod12.z.object({}),
+      inputSchema: import_zod16.z.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: import_zod12.z.object({
-        symbol: import_zod12.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
-        side: import_zod12.z.enum(["LONG", "SHORT"]),
-        quantity: import_zod12.z.number().positive(),
-        price: import_zod12.z.number().positive().optional().describe("If omitted, uses live ticker price")
+      inputSchema: import_zod16.z.object({
+        symbol: import_zod16.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        side: import_zod16.z.enum(["LONG", "SHORT"]),
+        quantity: import_zod16.z.number().positive(),
+        price: import_zod16.z.number().positive().optional().describe("If omitted, uses live ticker price")
       }),
       handler: async ({ symbol: symbol3, side: side3, quantity, price }) => {
         const sym = normalizeSymbol(symbol3);
@@ -3280,10 +5077,10 @@ function paperTools(ctx) {
     {
       name: "paper_close_position",
       description: "Close a paper position by id (or symbol) and realize PnL at the live/last price.",
-      inputSchema: import_zod12.z.object({
-        id: import_zod12.z.string().optional().describe("Position id from paper_open_position"),
-        symbol: import_zod12.z.string().min(1).optional().describe("Close the position for this symbol"),
-        price: import_zod12.z.number().positive().optional().describe("If omitted, uses live ticker price")
+      inputSchema: import_zod16.z.object({
+        id: import_zod16.z.string().optional().describe("Position id from paper_open_position"),
+        symbol: import_zod16.z.string().min(1).optional().describe("Close the position for this symbol"),
+        price: import_zod16.z.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 ?? ""));
@@ -3301,7 +5098,7 @@ function paperTools(ctx) {
     {
       name: "paper_positions",
       description: "List open paper positions with live unrealized PnL (marked to market).",
-      inputSchema: import_zod12.z.object({}),
+      inputSchema: import_zod16.z.object({}),
       handler: async () => {
         const out = await Promise.all(
           s.positions.map(async (p) => {
@@ -3315,39 +5112,39 @@ function paperTools(ctx) {
     {
       name: "paper_history",
       description: "List paper-trading history of open/close events with realized PnL.",
-      inputSchema: import_zod12.z.object({}),
+      inputSchema: import_zod16.z.object({}),
       handler: async () => textResult(s.history)
     },
     {
       name: "paper_summary",
       description: "Summarize paper-trading state: balance, open positions, trade count.",
-      inputSchema: import_zod12.z.object({}),
+      inputSchema: import_zod16.z.object({}),
       handler: async () => textResult({ balance: s.balance, openPositions: s.positions.length, trades: s.history.length })
     }
   ];
 }
 
 // src/tools/spot.tools.ts
-var import_zod13 = require("zod");
-var spotSymbol = import_zod13.z.string().min(1).describe("Spot pair, e.g. BTCUSDT");
-var optionalSymbol2 = import_zod13.z.string().min(1).describe("Spot pair, e.g. BTCUSDT").optional();
-var limit2 = import_zod13.z.number().int().positive().max(1e3).default(100);
-var startTime3 = import_zod13.z.number().int().positive().optional();
-var endTime3 = import_zod13.z.number().int().positive().optional();
-var side = import_zod13.z.enum(["BUY", "SELL"]);
-var spotOrderParamsSchema = import_zod13.z.object({
+var import_zod17 = require("zod");
+var spotSymbol = import_zod17.z.string().min(1).describe("Spot pair, e.g. BTCUSDT");
+var optionalSymbol2 = import_zod17.z.string().min(1).describe("Spot pair, e.g. BTCUSDT").optional();
+var limit2 = import_zod17.z.number().int().positive().max(1e3).default(100);
+var startTime3 = import_zod17.z.number().int().positive().optional();
+var endTime3 = import_zod17.z.number().int().positive().optional();
+var side = import_zod17.z.enum(["BUY", "SELL"]);
+var spotOrderParamsSchema = import_zod17.z.object({
   symbol: spotSymbol,
   side,
-  type: import_zod13.z.enum(["LIMIT", "MARKET", "LIMIT_MAKER", "STOP_LOSS", "STOP_LOSS_LIMIT", "TAKE_PROFIT", "TAKE_PROFIT_LIMIT"]),
-  quantity: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).optional().describe("Base-asset quantity; omit if using quoteOrderQty"),
-  quoteOrderQty: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).optional().describe("Quote-asset quantity (e.g. spend 100 USDT on a MARKET order)"),
-  price: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).optional().describe("Required for LIMIT / STOP_LOSS_LIMIT / TAKE_PROFIT_LIMIT"),
-  stopPrice: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).optional().describe("Trigger price for STOP_LOSS / TAKE_PROFIT variants"),
-  timeInForce: import_zod13.z.enum(["GTC", "IOC", "FOK"]).optional().describe("Required for LIMIT"),
-  newClientOrderId: import_zod13.z.string().optional(),
-  newOrderRespType: import_zod13.z.enum(["ACK", "RESULT", "FULL"]).optional(),
-  icebergQty: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).optional(),
-  selfTradePreventionMode: import_zod13.z.enum(["NONE", "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"]).optional()
+  type: import_zod17.z.enum(["LIMIT", "MARKET", "LIMIT_MAKER", "STOP_LOSS", "STOP_LOSS_LIMIT", "TAKE_PROFIT", "TAKE_PROFIT_LIMIT"]),
+  quantity: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).optional().describe("Base-asset quantity; omit if using quoteOrderQty"),
+  quoteOrderQty: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).optional().describe("Quote-asset quantity (e.g. spend 100 USDT on a MARKET order)"),
+  price: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).optional().describe("Required for LIMIT / STOP_LOSS_LIMIT / TAKE_PROFIT_LIMIT"),
+  stopPrice: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).optional().describe("Trigger price for STOP_LOSS / TAKE_PROFIT variants"),
+  timeInForce: import_zod17.z.enum(["GTC", "IOC", "FOK"]).optional().describe("Required for LIMIT"),
+  newClientOrderId: import_zod17.z.string().optional(),
+  newOrderRespType: import_zod17.z.enum(["ACK", "RESULT", "FULL"]).optional(),
+  icebergQty: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).optional(),
+  selfTradePreventionMode: import_zod17.z.enum(["NONE", "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"]).optional()
 });
 function spotTools(client) {
   const m = client.spot.market;
@@ -3358,128 +5155,128 @@ function spotTools(client) {
     {
       name: "spot_ping",
       description: "Test connectivity to the Binance Spot REST API.",
-      inputSchema: import_zod13.z.object({}),
+      inputSchema: import_zod17.z.object({}),
       handler: async () => textResult(await m.ping())
     },
     {
       name: "spot_server_time",
       description: "Get the current Binance Spot server time in ms since epoch.",
-      inputSchema: import_zod13.z.object({}),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({}),
+      inputSchema: import_zod17.z.object({}),
       handler: async () => textResult(await m.exchangeInfo())
     },
     {
       name: "spot_ticker_price",
       description: "Get the latest price for a Spot symbol.",
-      inputSchema: import_zod13.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({
+      inputSchema: import_zod17.z.object({
         symbol: spotSymbol,
-        limit: import_zod13.z.enum(["5", "10", "20", "50", "100", "500", "1000", "5000"]).default("100")
+        limit: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol, limit: limit2.default(500) }),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol, limit: limit2.default(500), fromId: import_zod13.z.number().int().positive().optional() }),
+      inputSchema: import_zod17.z.object({ symbol: spotSymbol, limit: limit2.default(500), fromId: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol, limit: limit2.default(500), startTime: startTime3, endTime: endTime3 }),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol, interval: KlineIntervalSchema, limit: limit2.default(500), startTime: startTime3, endTime: endTime3 }),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol, interval: KlineIntervalSchema, limit: limit2.default(500), startTime: startTime3, endTime: endTime3 }),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({
+      inputSchema: import_zod17.z.object({
         symbol: optionalSymbol2,
-        windowSize: import_zod13.z.enum(["1d", "7d", "30d"]).optional()
+        windowSize: import_zod17.z.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: import_zod13.z.object({ symbol: optionalSymbol2, timeZone: import_zod13.z.string().optional(), type: import_zod13.z.enum(["FULL", "MINI"]).optional() }),
+      inputSchema: import_zod17.z.object({ symbol: optionalSymbol2, timeZone: import_zod17.z.string().optional(), type: import_zod17.z.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: import_zod13.z.object({}),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol, orderId: import_zod13.z.number().int().positive().optional(), startTime: startTime3, endTime: endTime3, fromId: import_zod13.z.number().int().positive().optional(), limit: limit2.default(500) }),
+      inputSchema: import_zod17.z.object({ symbol: spotSymbol, orderId: import_zod17.z.number().int().positive().optional(), startTime: startTime3, endTime: endTime3, fromId: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol, preventedMatchId: import_zod13.z.number().int().positive().optional(), orderId: import_zod13.z.number().int().positive().optional(), limit: limit2.default(500) }),
+      inputSchema: import_zod17.z.object({ symbol: spotSymbol, preventedMatchId: import_zod17.z.number().int().positive().optional(), orderId: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({}),
+      inputSchema: import_zod17.z.object({}),
       handler: async () => textResult(await a.rateLimitOrder())
     },
     // ---- Trading (signed) ----
@@ -3498,109 +5295,109 @@ function spotTools(client) {
     {
       name: "spot_get_order",
       description: "Query a specific Spot order by orderId or client order id. Signed.",
-      inputSchema: import_zod13.z.object({ symbol: spotSymbol, orderId: import_zod13.z.number().int().positive().optional(), origClientOrderId: import_zod13.z.string().optional() }),
+      inputSchema: import_zod17.z.object({ symbol: spotSymbol, orderId: import_zod17.z.number().int().positive().optional(), origClientOrderId: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol, orderId: import_zod13.z.number().int().positive().optional(), origClientOrderId: import_zod13.z.string().optional(), newClientOrderId: import_zod13.z.string().optional() }),
+      inputSchema: import_zod17.z.object({ symbol: spotSymbol, orderId: import_zod17.z.number().int().positive().optional(), origClientOrderId: import_zod17.z.string().optional(), newClientOrderId: import_zod17.z.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: import_zod13.z.object({ symbol: optionalSymbol2 }),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol, orderId: import_zod13.z.number().int().positive().optional(), startTime: startTime3, endTime: endTime3, limit: limit2 }),
+      inputSchema: import_zod17.z.object({ symbol: spotSymbol, orderId: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({
+      inputSchema: import_zod17.z.object({
         symbol: spotSymbol,
         side,
-        type: import_zod13.z.enum(["LIMIT", "MARKET", "STOP_LOSS", "STOP_LOSS_LIMIT", "TAKE_PROFIT", "TAKE_PROFIT_LIMIT"]),
-        cancelReplaceMode: import_zod13.z.enum(["STOP_ON_FAILURE", "ALLOW_FAILURE"]).default("STOP_ON_FAILURE"),
-        cancelOrderId: import_zod13.z.number().int().positive().optional(),
-        cancelOrigClientOrderId: import_zod13.z.string().optional(),
-        cancelNewClientOrderId: import_zod13.z.string().optional(),
-        quantity: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).optional(),
-        price: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).optional(),
-        timeInForce: import_zod13.z.enum(["GTC", "IOC", "FOK"]).optional(),
-        newClientOrderId: import_zod13.z.string().optional()
+        type: import_zod17.z.enum(["LIMIT", "MARKET", "STOP_LOSS", "STOP_LOSS_LIMIT", "TAKE_PROFIT", "TAKE_PROFIT_LIMIT"]),
+        cancelReplaceMode: import_zod17.z.enum(["STOP_ON_FAILURE", "ALLOW_FAILURE"]).default("STOP_ON_FAILURE"),
+        cancelOrderId: import_zod17.z.number().int().positive().optional(),
+        cancelOrigClientOrderId: import_zod17.z.string().optional(),
+        cancelNewClientOrderId: import_zod17.z.string().optional(),
+        quantity: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).optional(),
+        price: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).optional(),
+        timeInForce: import_zod17.z.enum(["GTC", "IOC", "FOK"]).optional(),
+        newClientOrderId: import_zod17.z.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: import_zod13.z.object({
+      inputSchema: import_zod17.z.object({
         symbol: spotSymbol,
         side,
-        quantity: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).describe("Total base-asset quantity for both legs"),
-        price: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).describe("Limit (take-profit) price"),
-        stopPrice: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).describe("Stop-loss trigger price"),
-        stopLimitPrice: import_zod13.z.union([import_zod13.z.string(), import_zod13.z.number()]).optional().describe("Stop-loss limit price (defaults to stopPrice)"),
-        stopLimitTimeInForce: import_zod13.z.enum(["GTC", "IOC", "FOK"]).optional(),
-        listClientOrderId: import_zod13.z.string().optional(),
-        limitClientOrderId: import_zod13.z.string().optional(),
-        stopClientOrderId: import_zod13.z.string().optional()
+        quantity: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).describe("Total base-asset quantity for both legs"),
+        price: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).describe("Limit (take-profit) price"),
+        stopPrice: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).describe("Stop-loss trigger price"),
+        stopLimitPrice: import_zod17.z.union([import_zod17.z.string(), import_zod17.z.number()]).optional().describe("Stop-loss limit price (defaults to stopPrice)"),
+        stopLimitTimeInForce: import_zod17.z.enum(["GTC", "IOC", "FOK"]).optional(),
+        listClientOrderId: import_zod17.z.string().optional(),
+        limitClientOrderId: import_zod17.z.string().optional(),
+        stopClientOrderId: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol, orderListId: import_zod13.z.number().int().positive().optional(), listClientOrderId: import_zod13.z.string().optional(), newClientOrderId: import_zod13.z.string().optional() }),
+      inputSchema: import_zod17.z.object({ symbol: spotSymbol, orderListId: import_zod17.z.number().int().positive().optional(), listClientOrderId: import_zod17.z.string().optional(), newClientOrderId: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol, orderListId: import_zod13.z.number().int().positive().optional(), origClientOrderId: import_zod13.z.string().optional() }),
+      inputSchema: import_zod17.z.object({ symbol: spotSymbol, orderListId: import_zod17.z.number().int().positive().optional(), origClientOrderId: import_zod17.z.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: import_zod13.z.object({}),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol, fromId: import_zod13.z.number().int().positive().optional(), startTime: startTime3, endTime: endTime3, limit: limit2 }),
+      inputSchema: import_zod17.z.object({ symbol: spotSymbol, fromId: import_zod17.z.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: import_zod13.z.object({ symbol: spotSymbol }),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({}),
+      inputSchema: import_zod17.z.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: import_zod13.z.object({}),
+      inputSchema: import_zod17.z.object({}),
       handler: async () => {
         client.closeSpotUserStream();
         return textResult({ stopped: true });
@@ -3611,33 +5408,33 @@ function spotTools(client) {
 }
 
 // src/tools/trading.tools.ts
-var import_zod14 = require("zod");
-var symbol2 = import_zod14.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT");
-var optionalSymbol3 = import_zod14.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional();
-var limit3 = import_zod14.z.number().int().positive().max(1e3).default(100);
-var startTime4 = import_zod14.z.number().int().positive().optional();
-var endTime4 = import_zod14.z.number().int().positive().optional();
-var side2 = import_zod14.z.enum(["BUY", "SELL"]);
-var positionSide = import_zod14.z.enum(["BOTH", "LONG", "SHORT"]).optional();
-var orderParamsSchema = import_zod14.z.object({
+var import_zod18 = require("zod");
+var symbol2 = import_zod18.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT");
+var optionalSymbol3 = import_zod18.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional();
+var limit3 = import_zod18.z.number().int().positive().max(1e3).default(100);
+var startTime4 = import_zod18.z.number().int().positive().optional();
+var endTime4 = import_zod18.z.number().int().positive().optional();
+var side2 = import_zod18.z.enum(["BUY", "SELL"]);
+var positionSide = import_zod18.z.enum(["BOTH", "LONG", "SHORT"]).optional();
+var orderParamsSchema = import_zod18.z.object({
   symbol: symbol2,
   side: side2,
-  type: import_zod14.z.enum(["LIMIT", "MARKET", "STOP", "STOP_MARKET", "TAKE_PROFIT", "TAKE_PROFIT_MARKET", "TRAILING_STOP_MARKET"]),
-  quantity: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).describe("Order quantity in base asset"),
-  price: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).optional().describe("Required for LIMIT and STOP/TAKE_PROFIT (limit-triggered) types"),
-  timeInForce: import_zod14.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
-  stopPrice: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).optional().describe("Trigger price for STOP/STOP_MARKET/TAKE_PROFIT/TAKE_PROFIT_MARKET"),
-  reduceOnly: import_zod14.z.boolean().optional().describe("true = only reduces the position, never opens"),
+  type: import_zod18.z.enum(["LIMIT", "MARKET", "STOP", "STOP_MARKET", "TAKE_PROFIT", "TAKE_PROFIT_MARKET", "TRAILING_STOP_MARKET"]),
+  quantity: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).describe("Order quantity in base asset"),
+  price: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).optional().describe("Required for LIMIT and STOP/TAKE_PROFIT (limit-triggered) types"),
+  timeInForce: import_zod18.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+  stopPrice: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).optional().describe("Trigger price for STOP/STOP_MARKET/TAKE_PROFIT/TAKE_PROFIT_MARKET"),
+  reduceOnly: import_zod18.z.boolean().optional().describe("true = only reduces the position, never opens"),
   positionSide,
-  newClientOrderId: import_zod14.z.string().optional(),
-  closePosition: import_zod14.z.boolean().optional().describe("Close the full position on trigger (mutually exclusive with quantity)"),
-  newOrderRespType: import_zod14.z.enum(["ACK", "RESULT"]).optional(),
-  priceProtect: import_zod14.z.boolean().optional(),
-  workingType: import_zod14.z.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional().describe("Trigger price basis; default CONTRACT_PRICE"),
-  callbackRate: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).optional().describe("Percent callback for TRAILING_STOP_MARKET, e.g. 0.5"),
-  activationPrice: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).optional().describe("Activation price for TRAILING_STOP_MARKET"),
-  selfTradePreventionMode: import_zod14.z.enum(["NONE", "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"]).optional(),
-  goodTillDate: import_zod14.z.number().int().optional().describe("Timestamp when a GTD order expires")
+  newClientOrderId: import_zod18.z.string().optional(),
+  closePosition: import_zod18.z.boolean().optional().describe("Close the full position on trigger (mutually exclusive with quantity)"),
+  newOrderRespType: import_zod18.z.enum(["ACK", "RESULT"]).optional(),
+  priceProtect: import_zod18.z.boolean().optional(),
+  workingType: import_zod18.z.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional().describe("Trigger price basis; default CONTRACT_PRICE"),
+  callbackRate: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).optional().describe("Percent callback for TRAILING_STOP_MARKET, e.g. 0.5"),
+  activationPrice: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).optional().describe("Activation price for TRAILING_STOP_MARKET"),
+  selfTradePreventionMode: import_zod18.z.enum(["NONE", "EXPIRE_TAKER", "EXPIRE_MAKER", "EXPIRE_BOTH"]).optional(),
+  goodTillDate: import_zod18.z.number().int().optional().describe("Timestamp when a GTD order expires")
 });
 function tradingTools(client) {
   const t = client.futures.trading;
@@ -3657,66 +5454,66 @@ function tradingTools(client) {
     {
       name: "futures_get_order",
       description: "Query a specific order by orderId or client order id. Signed.",
-      inputSchema: import_zod14.z.object({ symbol: symbol2, orderId: import_zod14.z.number().int().positive().optional(), origClientOrderId: import_zod14.z.string().optional() }),
+      inputSchema: import_zod18.z.object({ symbol: symbol2, orderId: import_zod18.z.number().int().positive().optional(), origClientOrderId: import_zod18.z.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: import_zod14.z.object({ symbol: symbol2, orderId: import_zod14.z.number().int().positive().optional(), origClientOrderId: import_zod14.z.string().optional() }),
+      inputSchema: import_zod18.z.object({ symbol: symbol2, orderId: import_zod18.z.number().int().positive().optional(), origClientOrderId: import_zod18.z.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: import_zod14.z.object({ symbol: symbol2, orderId: import_zod14.z.number().int().positive().optional(), origClientOrderId: import_zod14.z.string().optional() }),
+      inputSchema: import_zod18.z.object({ symbol: symbol2, orderId: import_zod18.z.number().int().positive().optional(), origClientOrderId: import_zod18.z.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: import_zod14.z.object({ symbol: optionalSymbol3 }),
+      inputSchema: import_zod18.z.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: import_zod14.z.object({ symbol: symbol2, orderId: import_zod14.z.number().int().positive().optional(), startTime: startTime4, endTime: endTime4, limit: limit3 }),
+      inputSchema: import_zod18.z.object({ symbol: symbol2, orderId: import_zod18.z.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: import_zod14.z.object({ symbol: symbol2 }),
+      inputSchema: import_zod18.z.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: import_zod14.z.object({
+      inputSchema: import_zod18.z.object({
         symbol: symbol2,
         side: side2,
-        quantity: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]),
-        price: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).optional(),
-        orderId: import_zod14.z.number().int().positive().optional(),
-        origClientOrderId: import_zod14.z.string().optional(),
-        stopPrice: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).optional(),
-        timeInForce: import_zod14.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+        quantity: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]),
+        price: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).optional(),
+        orderId: import_zod18.z.number().int().positive().optional(),
+        origClientOrderId: import_zod18.z.string().optional(),
+        stopPrice: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).optional(),
+        timeInForce: import_zod18.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
         positionSide,
-        newClientOrderId: import_zod14.z.string().optional()
+        newClientOrderId: import_zod18.z.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: import_zod14.z.object({ symbol: symbol2, startTime: startTime4, endTime: endTime4, limit: limit3 }),
+      inputSchema: import_zod18.z.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: import_zod14.z.object({ orders: import_zod14.z.array(orderParamsSchema).min(1).max(5) }),
+      inputSchema: import_zod18.z.object({ orders: import_zod18.z.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));
@@ -3725,124 +5522,124 @@ function tradingTools(client) {
     {
       name: "futures_cancel_batch_orders",
       description: "Cancel multiple orders at once (up to 10 by orderId list or client order id list). Signed.",
-      inputSchema: import_zod14.z.object({
+      inputSchema: import_zod18.z.object({
         symbol: symbol2,
-        orderIdList: import_zod14.z.array(import_zod14.z.number().int().positive()).max(10).optional(),
-        origClientOrderIdList: import_zod14.z.array(import_zod14.z.string()).max(10).optional()
+        orderIdList: import_zod18.z.array(import_zod18.z.number().int().positive()).max(10).optional(),
+        origClientOrderIdList: import_zod18.z.array(import_zod18.z.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: import_zod14.z.object({ symbol: symbol2, leverage: import_zod14.z.number().int().min(1).max(125) }),
+      inputSchema: import_zod18.z.object({ symbol: symbol2, leverage: import_zod18.z.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: import_zod14.z.object({ symbol: symbol2, marginType: import_zod14.z.enum(["isolated", "cross"]) }),
+      inputSchema: import_zod18.z.object({ symbol: symbol2, marginType: import_zod18.z.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: import_zod14.z.object({ symbol: symbol2, amount: import_zod14.z.number().positive(), marginType: import_zod14.z.enum(["1", "2"]).describe("1 = add margin, 2 = reduce margin") }),
+      inputSchema: import_zod18.z.object({ symbol: symbol2, amount: import_zod18.z.number().positive(), marginType: import_zod18.z.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: import_zod14.z.object({ symbol: symbol2, countdownTime: import_zod14.z.number().int().min(100).max(6e4) }),
+      inputSchema: import_zod18.z.object({ symbol: symbol2, countdownTime: import_zod18.z.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: import_zod14.z.object({
-        algoType: import_zod14.z.enum(["CONDITIONAL", "VP"]),
+      inputSchema: import_zod18.z.object({
+        algoType: import_zod18.z.enum(["CONDITIONAL", "VP"]),
         symbol: symbol2,
         side: side2,
         positionSide,
-        type: import_zod14.z.enum(["STOP_MARKET", "TAKE_PROFIT_MARKET", "LIMIT"]).describe("For CONDITIONAL: STOP_MARKET/TAKE_PROFIT_MARKET. For VP: LIMIT"),
-        quantity: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]),
-        triggerPrice: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).optional().describe("Required for CONDITIONAL"),
-        price: import_zod14.z.union([import_zod14.z.string(), import_zod14.z.number()]).optional(),
-        timeInForce: import_zod14.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
-        workingType: import_zod14.z.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional(),
-        priceProtect: import_zod14.z.boolean().optional(),
-        reduceOnly: import_zod14.z.boolean().optional(),
-        closePosition: import_zod14.z.boolean().optional(),
-        urgency: import_zod14.z.enum(["LOW", "MEDIUM", "HIGH"]).optional().describe("Required for VP"),
-        clientAlgoId: import_zod14.z.string().optional()
+        type: import_zod18.z.enum(["STOP_MARKET", "TAKE_PROFIT_MARKET", "LIMIT"]).describe("For CONDITIONAL: STOP_MARKET/TAKE_PROFIT_MARKET. For VP: LIMIT"),
+        quantity: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]),
+        triggerPrice: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).optional().describe("Required for CONDITIONAL"),
+        price: import_zod18.z.union([import_zod18.z.string(), import_zod18.z.number()]).optional(),
+        timeInForce: import_zod18.z.enum(["GTC", "IOC", "FOK", "GTX"]).optional(),
+        workingType: import_zod18.z.enum(["MARK_PRICE", "CONTRACT_PRICE"]).optional(),
+        priceProtect: import_zod18.z.boolean().optional(),
+        reduceOnly: import_zod18.z.boolean().optional(),
+        closePosition: import_zod18.z.boolean().optional(),
+        urgency: import_zod18.z.enum(["LOW", "MEDIUM", "HIGH"]).optional().describe("Required for VP"),
+        clientAlgoId: import_zod18.z.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: import_zod14.z.object({ symbol: symbol2, algoId: import_zod14.z.number().int().positive().optional(), clientAlgoId: import_zod14.z.string().optional() }),
+      inputSchema: import_zod18.z.object({ symbol: symbol2, algoId: import_zod18.z.number().int().positive().optional(), clientAlgoId: import_zod18.z.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: import_zod14.z.object({ symbol: symbol2 }),
+      inputSchema: import_zod18.z.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: import_zod14.z.object({ symbol: symbol2, algoId: import_zod14.z.number().int().positive().optional(), clientAlgoId: import_zod14.z.string().optional() }),
+      inputSchema: import_zod18.z.object({ symbol: symbol2, algoId: import_zod18.z.number().int().positive().optional(), clientAlgoId: import_zod18.z.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: import_zod14.z.object({ symbol: optionalSymbol3 }),
+      inputSchema: import_zod18.z.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: import_zod14.z.object({ symbol: symbol2, startTime: startTime4, endTime: endTime4, limit: limit3 }),
+      inputSchema: import_zod18.z.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: import_zod14.z.object({ fromAsset: import_zod14.z.string().optional(), toAsset: import_zod14.z.string().optional() }),
+      inputSchema: import_zod18.z.object({ fromAsset: import_zod18.z.string().optional(), toAsset: import_zod18.z.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: import_zod14.z.object({
-        fromAsset: import_zod14.z.string().min(1),
-        toAsset: import_zod14.z.string().min(1),
-        fromAmount: import_zod14.z.number().positive().optional(),
-        toAmount: import_zod14.z.number().positive().optional(),
-        validTime: import_zod14.z.enum(["10s", "30s", "1m", "2m"]).optional()
+      inputSchema: import_zod18.z.object({
+        fromAsset: import_zod18.z.string().min(1),
+        toAsset: import_zod18.z.string().min(1),
+        fromAmount: import_zod18.z.number().positive().optional(),
+        toAmount: import_zod18.z.number().positive().optional(),
+        validTime: import_zod18.z.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: import_zod14.z.object({ quoteId: import_zod14.z.string().min(1) }),
+      inputSchema: import_zod18.z.object({ quoteId: import_zod18.z.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: import_zod14.z.object({ orderId: import_zod14.z.string().optional(), quoteId: import_zod14.z.string().optional() }),
+      inputSchema: import_zod18.z.object({ orderId: import_zod18.z.string().optional(), quoteId: import_zod18.z.string().optional() }),
       handler: async ({ orderId, quoteId }) => textResult(await t.convertOrderStatus({ orderId, quoteId }))
     }
   ];
 }
 
 // src/tools/ws.tools.ts
-var import_zod15 = require("zod");
+var import_zod19 = require("zod");
 var buffers = /* @__PURE__ */ new Map();
 var MAX_BUFFER = 500;
 function bufferFor(client) {
@@ -3869,8 +5666,8 @@ function wsTools(client) {
     {
       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: import_zod15.z.object({
-        topics: import_zod15.z.array(import_zod15.z.string().min(1)).min(1).describe('Stream topics, e.g. ["btcusdt@aggTrade", "btcusdt@kline_1m"]')
+      inputSchema: import_zod19.z.object({
+        topics: import_zod19.z.array(import_zod19.z.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());
@@ -3882,7 +5679,7 @@ function wsTools(client) {
     {
       name: "futures_ws_unsubscribe",
       description: "Unsubscribe from previously subscribed market data streams.",
-      inputSchema: import_zod15.z.object({ topics: import_zod15.z.array(import_zod15.z.string().min(1)).min(1) }),
+      inputSchema: import_zod19.z.object({ topics: import_zod19.z.array(import_zod19.z.string().min(1)).min(1) }),
       handler: async ({ topics }) => {
         const normalized = topics.map((t) => t.trim().toLowerCase());
         client.futures.ws.unsubscribe(normalized);
@@ -3893,19 +5690,19 @@ function wsTools(client) {
     {
       name: "futures_ws_subscriptions",
       description: "List the currently subscribed WebSocket market streams for this client.",
-      inputSchema: import_zod15.z.object({}),
+      inputSchema: import_zod19.z.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: import_zod15.z.object({ limit: import_zod15.z.number().int().min(1).max(200).default(50) }),
+      inputSchema: import_zod19.z.object({ limit: import_zod19.z.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: import_zod15.z.object({}),
+      inputSchema: import_zod19.z.object({}),
       handler: async () => {
         clearBufferedWsEvents(client);
         return textResult({ cleared: true });
@@ -3914,13 +5711,13 @@ function wsTools(client) {
     {
       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: import_zod15.z.object({}),
+      inputSchema: import_zod19.z.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: import_zod15.z.object({}),
+      inputSchema: import_zod19.z.object({}),
       handler: async () => {
         client.closeUserStream();
         return textResult({ stopped: true });
@@ -3929,49 +5726,49 @@ function wsTools(client) {
     {
       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: import_zod15.z.object({
-        symbol: import_zod15.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
-        orderId: import_zod15.z.number().int().positive().optional(),
-        origClientOrderId: import_zod15.z.string().optional()
+      inputSchema: import_zod19.z.object({
+        symbol: import_zod19.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        orderId: import_zod19.z.number().int().positive().optional(),
+        origClientOrderId: import_zod19.z.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: import_zod15.z.object({}),
+      inputSchema: import_zod19.z.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: import_zod15.z.object({ symbol: import_zod15.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional() }),
+      inputSchema: import_zod19.z.object({ symbol: import_zod19.z.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: import_zod15.z.object({}),
+      inputSchema: import_zod19.z.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: import_zod15.z.object({ listenKey: import_zod15.z.string().min(1) }),
+      inputSchema: import_zod19.z.object({ listenKey: import_zod19.z.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: import_zod15.z.object({ symbol: import_zod15.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT").optional() }),
+      inputSchema: import_zod19.z.object({ symbol: import_zod19.z.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: import_zod15.z.object({
-        symbol: import_zod15.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
-        limit: import_zod15.z.enum(["5", "10", "20", "50", "100", "500", "1000"]).optional()
+      inputSchema: import_zod19.z.object({
+        symbol: import_zod19.z.string().min(1).describe("USD-M pair, e.g. BTCUSDT"),
+        limit: import_zod19.z.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 }))
     }
@@ -4004,7 +5801,7 @@ function createFuturesToolkit(client) {
 
 // src/mcp/server.ts
 function createBinanceMcpServer(client) {
-  const server = new import_mcp.McpServer({ name: "binance-sdk", version: "3.0.0" });
+  const server = new import_mcp.McpServer({ name: "binance-sdk", version: "2.0.0" });
   const toolkit = createFuturesToolkit(client);
   toolkit.tools.forEach((tool) => {
     server.registerTool(tool.name, { description: tool.description, inputSchema: tool.inputSchema }, async (args) => ({