@okx_ai/okx-trade-cli 1.3.0 → 1.3.1-beta.2

package/dist/index.js

@@ -1393,6 +1393,9 @@ function readNumber(args, key) {
   if (value === void 0 || value === null) {
     return void 0;
   }
+  if (typeof value === "string" && /^-?\d+(\.\d+)?$/.test(value)) {
+    return parseFloat(value);
+  }
   if (typeof value !== "number" || Number.isNaN(value)) {
     throw new ValidationError(`Parameter "${key}" must be a number.`);
   }
@@ -1472,7 +1475,8 @@ var OKX_INST_TYPES = [
   "SWAP",
   "FUTURES",
   "OPTION",
-  "MARGIN"
+  "MARGIN",
+  "EVENTS"
 ];
 function publicRateLimit(key, rps = 20) {
   return {
@@ -1770,6 +1774,7 @@ var MODULES = [
   "futures",
   "option",
   "account",
+  "event",
   ...EARN_SUB_MODULE_IDS,
   ...BOT_SUB_MODULE_IDS,
   "skills"
@@ -1963,7 +1968,7 @@ function registerAccountTools() {
         properties: {
           instType: {
             type: "string",
-            enum: ["SPOT", "MARGIN", "SWAP", "FUTURES", "OPTION"]
+            enum: ["SPOT", "MARGIN", "SWAP", "FUTURES", "OPTION", "EVENTS"]
           },
           ccy: {
             type: "string",
@@ -2029,7 +2034,7 @@ function registerAccountTools() {
         properties: {
           instType: {
             type: "string",
-            enum: ["SWAP", "FUTURES", "MARGIN", "OPTION"],
+            enum: ["SWAP", "FUTURES", "MARGIN", "OPTION", "EVENTS"],
             description: "Default SWAP"
           },
           instId: {
@@ -2090,7 +2095,7 @@ function registerAccountTools() {
         properties: {
           instType: {
             type: "string",
-            enum: ["SPOT", "MARGIN", "SWAP", "FUTURES", "OPTION"]
+            enum: ["SPOT", "MARGIN", "SWAP", "FUTURES", "OPTION", "EVENTS"]
           },
           instId: {
             type: "string",
@@ -2201,14 +2206,14 @@ function registerAccountTools() {
     {
       name: "account_get_positions",
       module: "account",
-      description: "Get current open positions across all instrument types (MARGIN, SWAP, FUTURES, OPTION). Use swap_get_positions for SWAP/FUTURES-only queries.",
+      description: "Get current open positions across all instrument types (MARGIN, SWAP, FUTURES, OPTION, EVENTS). Use swap_get_positions for SWAP/FUTURES-only queries.",
       isWrite: false,
       inputSchema: {
         type: "object",
         properties: {
           instType: {
             type: "string",
-            enum: ["MARGIN", "SWAP", "FUTURES", "OPTION"]
+            enum: ["MARGIN", "SWAP", "FUTURES", "OPTION", "EVENTS"]
           },
           instId: {
             type: "string",
@@ -5118,6 +5123,765 @@ function registerAllEarnTools() {
   ];
   return tools.map(withDemoGuard);
 }
+function findDateIdx(parts) {
+  for (let i = 1; i < parts.length; i++) {
+    if (/^\d{6}$/.test(parts[i])) return i;
+  }
+  return -1;
+}
+function inferExpiryMsFromInstId(instId) {
+  const parts = instId.split("-");
+  const upper = instId.toUpperCase();
+  const dateIdx = findDateIdx(parts);
+  if (dateIdx < 0) return null;
+  const dp = parts[dateIdx];
+  const year = 2e3 + parseInt(dp.slice(0, 2), 10);
+  const month = parseInt(dp.slice(2, 4), 10) - 1;
+  const day = parseInt(dp.slice(4, 6), 10);
+  const isUpDown = upper.includes("UPDOWN");
+  let timePart;
+  if (isUpDown) {
+    const candidate = parts[dateIdx + 2];
+    timePart = candidate && /^\d{4}$/.test(candidate) ? candidate : parts[dateIdx + 1];
+  } else {
+    timePart = parts[dateIdx + 1];
+  }
+  if (!timePart || !/^\d{4}$/.test(timePart)) return null;
+  const hour = parseInt(timePart.slice(0, 2), 10);
+  const min = parseInt(timePart.slice(2, 4), 10);
+  return Date.UTC(year, month, day, hour - 8, min, 0, 0);
+}
+function extractSeriesId(instId) {
+  const parts = instId.split("-");
+  for (let i = 0; i < parts.length; i++) {
+    if (/^\d{6}$/.test(parts[i])) {
+      return parts.slice(0, i).join("-");
+    }
+  }
+  return instId;
+}
+function fmtTimeToken(t) {
+  return t.length === 4 ? `${t.slice(0, 2)}:${t.slice(2)}` : t;
+}
+function fmtUpDownName(seriesId, dateStr, parts, dateIdx) {
+  const t1 = parts[dateIdx + 1] ?? "";
+  const t2 = parts[dateIdx + 2] ?? "";
+  const timeRange = t1 && t2 ? ` ${fmtTimeToken(t1)}-${fmtTimeToken(t2)}` : "";
+  return `${seriesId} Up/Down \xB7 ${dateStr}${timeRange}`;
+}
+function fmtStrikeName(seriesId, dateStr, label, parts, dateIdx) {
+  const strike = parts[dateIdx + 2] ?? "";
+  const strikeStr = strike && /^\d+$/.test(strike) ? Number(strike).toLocaleString("en-US") : "";
+  return strikeStr ? `${seriesId} ${label} ${strikeStr} \xB7 ${dateStr}` : `${seriesId} \xB7 ${dateStr}`;
+}
+function formatDisplayTitle(instId) {
+  const parts = instId.split("-");
+  const upper = instId.toUpperCase();
+  const seriesId = parts[0] ?? instId;
+  const dateIdx = findDateIdx(parts);
+  if (dateIdx < 0) return instId;
+  const d = parts[dateIdx];
+  const month = parseInt(d.slice(2, 4), 10);
+  const day = parseInt(d.slice(4, 6), 10);
+  const dateStr = `${month}/${day}`;
+  if (upper.includes("UPDOWN") || upper.includes("UP-DOWN")) {
+    return fmtUpDownName(seriesId, dateStr, parts, dateIdx);
+  }
+  if (upper.includes("ABOVE")) {
+    return fmtStrikeName(seriesId, dateStr, "above", parts, dateIdx);
+  }
+  if (upper.includes("TOUCH")) {
+    return fmtStrikeName(seriesId, dateStr, "touch", parts, dateIdx);
+  }
+  return `${seriesId} \xB7 ${dateStr}`;
+}
+var OUTCOME_LABELS = {
+  "0": "pending",
+  "1": "YES",
+  "2": "NO"
+};
+var ORDER_STATE_MAP = {
+  live: "Unfilled",
+  partially_filled: "Partially filled",
+  filled: "Filled",
+  canceled: "Canceled",
+  mmp_canceled: "Canceled"
+};
+function mapOrderState(raw) {
+  return ORDER_STATE_MAP[raw] ?? raw;
+}
+var TIMESTAMP_FIELDS = /* @__PURE__ */ new Set([
+  "expTime",
+  "settleTime",
+  "listTime",
+  "uTime",
+  "cTime",
+  "fixTime"
+]);
+var DEFAULT_SETTLE_CCY = "USDT";
+function convertTimestamps(item) {
+  const result = { ...item };
+  for (const key of TIMESTAMP_FIELDS) {
+    if (!(key in result)) continue;
+    const v = Number(result[key]);
+    if (v > 0) {
+      const d = new Date(v + 8 * 60 * 60 * 1e3);
+      const yyyy = d.getUTCFullYear();
+      const mo = String(d.getUTCMonth() + 1).padStart(2, "0");
+      const dd = String(d.getUTCDate()).padStart(2, "0");
+      const hh = String(d.getUTCHours()).padStart(2, "0");
+      const mi = String(d.getUTCMinutes()).padStart(2, "0");
+      result[key] = `${yyyy}-${mo}-${dd} ${hh}:${mi} UTC+8`;
+    } else {
+      delete result[key];
+    }
+  }
+  return result;
+}
+function normalizeWrite3(response) {
+  const data = response.data;
+  if (Array.isArray(data) && data.length > 0) {
+    const failed = data.filter(
+      (item) => item !== null && typeof item === "object" && "sCode" in item && item["sCode"] !== "0"
+    );
+    if (failed.length > 0) {
+      const messages2 = failed.map(
+        (item) => `[${item["sCode"]}] ${item["sMsg"] ?? "Operation failed"}`
+      );
+      throw new OkxApiError(messages2.join("; "), {
+        code: String(failed[0]["sCode"] ?? ""),
+        endpoint: response.endpoint
+      });
+    }
+  }
+  return { endpoint: response.endpoint, requestTime: response.requestTime, data };
+}
+function extractQuoteCcy(underlying) {
+  if (!underlying) return DEFAULT_SETTLE_CCY;
+  const parts = underlying.split("-");
+  return parts.length >= 2 ? parts[parts.length - 1].toUpperCase() : DEFAULT_SETTLE_CCY;
+}
+async function fetchAvailableBalance(client, ccy = DEFAULT_SETTLE_CCY) {
+  try {
+    const r = await client.privateGet(
+      "/api/v5/account/balance",
+      { ccy }
+    );
+    const data = r["data"];
+    if (Array.isArray(data) && data.length > 0) {
+      const details = data[0]["details"];
+      if (Array.isArray(details) && details.length > 0) {
+        const entry = details.find(
+          (d) => String(d["ccy"] ?? "").toUpperCase() === ccy.toUpperCase()
+        );
+        if (!entry) return { balance: null, ccy };
+        const bal = String(entry["availBal"] ?? "") || null;
+        return { balance: bal, ccy };
+      }
+    }
+  } catch {
+  }
+  return { balance: null, ccy };
+}
+var KNOWN_UNDERLYINGS = /^(BTC|ETH|TRX|EOS|SOL|IOTA|KISHU|SUSHI|BTG|XTZ|SOLVU)/i;
+function extractUnderlying(seriesId) {
+  const m = seriesId.match(KNOWN_UNDERLYINGS);
+  return m ? m[1].toUpperCase() : null;
+}
+function resolveOutcome(value) {
+  const map = {
+    up: "yes",
+    yes: "yes",
+    down: "no",
+    no: "no"
+  };
+  const resolved = map[value.toLowerCase()];
+  if (!resolved) {
+    throw new Error(
+      `Invalid outcome "${value}". Use: UP or YES for Up/Yes, DOWN or NO for Down/No.`
+    );
+  }
+  return resolved;
+}
+function filterBrowseCandidates(allSeries, underlyingFilter) {
+  const isHumanReadable = (id) => /^(BTC|ETH|TRX|EOS|SOL|IOTA|KISHU|SUSHI|BTG|XTZ|SOLVU)-/.test(id);
+  const seen = /* @__PURE__ */ new Set();
+  const candidates = [];
+  for (const s of allSeries) {
+    const settlement = s["settlement"];
+    const method = String(settlement?.["method"] ?? "");
+    const uly = String(settlement?.["underlying"] ?? "");
+    if (underlyingFilter && !uly.startsWith(underlyingFilter)) continue;
+    const key = `${method}:${uly}`;
+    if (!seen.has(key) && isHumanReadable(String(s["seriesId"] ?? ""))) {
+      seen.add(key);
+      candidates.push(s);
+    }
+  }
+  return candidates;
+}
+function isActiveMarket(m, isUpDown, now) {
+  if (!isUpDown && (!m["floorStrike"] || m["floorStrike"] === "")) return false;
+  const expMs = Number(m["expTime"] ?? 0);
+  return expMs <= 0 || expMs > now;
+}
+function toContractSummary(m) {
+  const converted = convertTimestamps(m);
+  const id = String(m["instId"] ?? "");
+  return {
+    instId: id,
+    displayTitle: formatDisplayTitle(id),
+    expTime: converted["expTime"],
+    floorStrike: m["floorStrike"],
+    px: m["px"],
+    outcome: OUTCOME_LABELS[String(m["outcome"] ?? "")] ?? m["outcome"]
+  };
+}
+async function fetchActiveContractsForSeries(client, s) {
+  const seriesId = String(s["seriesId"] ?? "");
+  const settlement = s["settlement"];
+  const method = String(settlement?.["method"] ?? "");
+  const isUpDown = method === "price_up_down";
+  try {
+    const r = await client.privateGet(
+      "/api/v5/public/event-contract/markets",
+      compactObject({ seriesId, state: "live" }),
+      privateRateLimit("event_browse", 20)
+    );
+    const normalized = normalizeResponse(r);
+    const markets = Array.isArray(normalized["data"]) ? normalized["data"] : [];
+    const now = Date.now();
+    const active = markets.filter((m) => isActiveMarket(m, isUpDown, now)).map(toContractSummary);
+    if (active.length === 0) return null;
+    return {
+      seriesId,
+      method: String(settlement?.["method"] ?? ""),
+      underlying: String(settlement?.["underlying"] ?? ""),
+      freq: String(s["freq"] ?? ""),
+      contracts: active
+    };
+  } catch {
+    return null;
+  }
+}
+function resolveUnderlyingFromSeriesResp(seriesResp) {
+  if (!seriesResp) return null;
+  const sResp = seriesResp;
+  const sData = Array.isArray(sResp["data"]) ? sResp["data"] : [];
+  if (sData.length > 0) {
+    const settlement = sData[0]["settlement"];
+    return String(settlement?.["underlying"] ?? "") || null;
+  }
+  return null;
+}
+function translateAndSortMarkets(rawData, limit) {
+  const sorted = [...rawData].sort((a, b) => {
+    const tA = Number(a["expTime"] ?? 0);
+    const tB = Number(b["expTime"] ?? 0);
+    return tA - tB;
+  });
+  const sliced = limit && limit > 0 ? sorted.slice(0, limit) : sorted;
+  return sliced.map((item) => {
+    const converted = convertTimestamps(item);
+    if (typeof converted["outcome"] === "string") {
+      converted["outcome"] = OUTCOME_LABELS[converted["outcome"]] ?? converted["outcome"];
+    }
+    converted["displayTitle"] = formatDisplayTitle(String(item["instId"] ?? ""));
+    return converted;
+  });
+}
+function enrichFill(item) {
+  const subType = String(item["subType"] ?? "");
+  const isSettle = subType === "414" || subType === "415";
+  const enriched = {
+    ...item,
+    displayTitle: formatDisplayTitle(String(item["instId"] ?? "")),
+    outcome: OUTCOME_LABELS[String(item["outcome"] ?? "")] ?? item["outcome"],
+    type: isSettle ? "settlement" : "fill"
+  };
+  if (isSettle) {
+    const fillPnl = parseFloat(String(item["fillPnl"] ?? "NaN"));
+    const isWin = subType === "414";
+    enriched["settlementResult"] = isWin ? "win" : "loss";
+    enriched["pnl"] = isNaN(fillPnl) ? void 0 : fillPnl;
+  }
+  return enriched;
+}
+async function fetchIdxPx(client, underlying) {
+  try {
+    const r = await client.publicGet(
+      "/api/v5/market/index-tickers",
+      { instId: underlying },
+      publicRateLimit("fetchIdxPx", 20)
+    );
+    const data = r["data"];
+    if (Array.isArray(data) && data.length > 0) {
+      return String(data[0]["idxPx"] ?? "") || null;
+    }
+  } catch {
+  }
+  return null;
+}
+function handlePlaceOrderError(base, rawArgs, endpoint) {
+  if (!Array.isArray(base["data"])) return;
+  const item = base["data"][0];
+  const sCode = item && String(item["sCode"] ?? "");
+  if (!sCode || sCode === "0") return;
+  const sMsg = String(item["sMsg"] ?? "Order failed");
+  if (sCode === "51001") {
+    const instId = requireString(asRecord(rawArgs), "instId");
+    const seriesId = extractSeriesId(instId);
+    const expiryMs = inferExpiryMsFromInstId(instId);
+    const isExpired = expiryMs !== null && expiryMs < Date.now();
+    const reason = isExpired ? `The contract (${instId}) has expired.` : `The contract (${instId}) was not found \u2014 it may not exist or has not started yet.`;
+    throw new OkxApiError(
+      `${reason} Ask the user if they'd like to place the same order on the next session. If yes, call event_get_markets with seriesId=${seriesId} and state=live to find available contracts.`,
+      { code: sCode, endpoint }
+    );
+  }
+  throw new OkxApiError(`[${sCode}] ${sMsg}`, { code: sCode, endpoint });
+}
+var OUTCOME_SCHEMA = {
+  type: "string",
+  enum: ["UP", "YES", "DOWN", "NO"],
+  description: `Which outcome to trade.
+UP/DOWN direction contracts: UP (price rises during the period) or DOWN (price falls).
+YES/NO price-target or touch contracts: YES (condition met) or NO (condition not met).
+Check the series type from event_get_series to determine which applies.
+NOTE: px is the event contract price (0.01\u20130.99), NOT the underlying asset price. It reflects market-implied probability when actively trading.`
+};
+function registerEventContractTools() {
+  return [
+    // -----------------------------------------------------------------------
+    // Read-only — browse (user-facing) + series / events / markets (internal)
+    // -----------------------------------------------------------------------
+    {
+      name: "event_browse",
+      module: "event",
+      description: "Browse currently active (in-progress) event contracts. Call when user asks what event contracts are available to trade. Internally fetches series and live markets in parallel, returns only in-progress contracts (floorStrike set). If a live quote field px is present, it is the event contract price (0.01\u20130.99), not the underlying asset price; it reflects the market-implied probability when actively trading. Grouped by settlement type and underlying.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          underlying: {
+            type: "string",
+            description: "Filter by underlying asset, e.g. BTC-USD, ETH-USD. Omit for all."
+          }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const underlyingFilter = readString(args, "underlying");
+        const seriesResp = await context.client.privateGet(
+          "/api/v5/public/event-contract/series",
+          compactObject({}),
+          privateRateLimit("event_browse", 10)
+        );
+        const normalizedSeries = normalizeResponse(seriesResp);
+        const allSeries = Array.isArray(normalizedSeries["data"]) ? normalizedSeries["data"] : [];
+        const candidates = filterBrowseCandidates(allSeries, underlyingFilter);
+        const marketResults = await Promise.all(
+          candidates.map((s) => fetchActiveContractsForSeries(context.client, s))
+        );
+        const results = marketResults.filter(Boolean);
+        return {
+          data: results,
+          total: results.reduce((n, r) => n + (r?.contracts?.length ?? 0), 0)
+        };
+      }
+    },
+    {
+      name: "event_get_series",
+      module: "event",
+      description: "List event contract series. Returns all available series with settlement type and underlying. Use event_browse to see currently active contracts.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          seriesId: {
+            type: "string",
+            description: "Filter by series ID, e.g. BTC-ABOVE-DAILY. Omit for all."
+          }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v5/public/event-contract/series",
+          compactObject({ seriesId: readString(args, "seriesId") }),
+          privateRateLimit("event_get_series", 20)
+        );
+        return normalizeResponse(response);
+      }
+    },
+    {
+      name: "event_get_events",
+      module: "event",
+      description: "List expiry periods within a series. state: preopen|live|settling|expired. expTime is pre-formatted UTC+8.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          seriesId: {
+            type: "string",
+            description: "Series ID, e.g. BTC-ABOVE-DAILY (required)"
+          },
+          eventId: {
+            type: "string",
+            description: "Filter by event ID, e.g. BTC-ABOVE-DAILY-260224-1600"
+          },
+          state: {
+            type: "string",
+            enum: ["preopen", "live", "settling", "expired"],
+            description: "preopen=markets not yet trading; live=active; settling=awaiting settlement; expired=done"
+          },
+          limit: {
+            type: "number",
+            description: "Max results (default 100, max 100)"
+          },
+          before: {
+            type: "string",
+            description: "Pagination: return records newer than this expTime"
+          },
+          after: {
+            type: "string",
+            description: "Pagination: return records older than this expTime"
+          }
+        },
+        required: ["seriesId"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v5/public/event-contract/events",
+          compactObject({
+            seriesId: requireString(args, "seriesId"),
+            eventId: readString(args, "eventId"),
+            state: readString(args, "state"),
+            limit: readNumber(args, "limit"),
+            before: readString(args, "before"),
+            after: readString(args, "after")
+          }),
+          privateRateLimit("event_get_events", 20)
+        );
+        const base = normalizeResponse(response);
+        const data = Array.isArray(base["data"]) ? base["data"].map(convertTimestamps) : base["data"];
+        return { ...base, data };
+      }
+    },
+    {
+      name: "event_get_markets",
+      module: "event",
+      description: "List tradeable contracts within a series. state=live for active contracts, state=expired for settlement results. floorStrike=strike price; px (when present) is the event contract price (0.01\u20130.99), not the underlying asset price \u2014 reflects the market-implied probability when actively trading; outcome pre-translated (pending/YES/NO/UP/DOWN); timestamps UTC+8.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          seriesId: {
+            type: "string",
+            description: "Series ID, e.g. BTC-ABOVE-DAILY (required)"
+          },
+          eventId: {
+            type: "string",
+            description: "Filter by event ID, e.g. BTC-ABOVE-DAILY-260224-1600"
+          },
+          instId: {
+            type: "string",
+            description: "Filter by instrument ID"
+          },
+          state: {
+            type: "string",
+            enum: ["preopen", "live", "settling", "expired"],
+            description: "preopen=not yet trading; live=active; settling=awaiting settlement; expired=settled"
+          },
+          limit: {
+            type: "number",
+            description: "Max results (default 100, max 100)"
+          },
+          before: {
+            type: "string",
+            description: "Pagination: return records newer than this expTime"
+          },
+          after: {
+            type: "string",
+            description: "Pagination: return records older than this expTime"
+          }
+        },
+        required: ["seriesId"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const seriesId = requireString(args, "seriesId");
+        const knownUnderlying = extractUnderlying(seriesId);
+        const [marketsResp, seriesResp, idxPxFromKnown] = await Promise.all([
+          context.client.privateGet(
+            "/api/v5/public/event-contract/markets",
+            compactObject({
+              seriesId,
+              eventId: readString(args, "eventId"),
+              instId: readString(args, "instId"),
+              state: readString(args, "state"),
+              before: readString(args, "before"),
+              after: readString(args, "after")
+            }),
+            privateRateLimit("event_get_markets", 20)
+          ),
+          knownUnderlying ? Promise.resolve(null) : context.client.privateGet(
+            "/api/v5/public/event-contract/series",
+            compactObject({ seriesId }),
+            privateRateLimit("event_get_series", 20)
+          ),
+          knownUnderlying ? fetchIdxPx(context.client, knownUnderlying + "-USDT") : Promise.resolve(null)
+        ]);
+        let underlying = knownUnderlying ? knownUnderlying + "-USDT" : null;
+        if (!underlying) {
+          underlying = resolveUnderlyingFromSeriesResp(seriesResp);
+        }
+        const idxPx = idxPxFromKnown ?? (underlying && !knownUnderlying ? await fetchIdxPx(context.client, underlying) : null);
+        const base = normalizeResponse(marketsResp);
+        const limit = readNumber(args, "limit");
+        const rawData = Array.isArray(base["data"]) ? base["data"] : [];
+        const translated = translateAndSortMarkets(rawData, limit);
+        return {
+          ...base,
+          data: translated,
+          currentIdxPx: idxPx,
+          underlying
+        };
+      }
+    },
+    {
+      name: "event_get_orders",
+      module: "event",
+      description: "Query event contract orders. state=live for open orders; omit for history. outcome pre-translated (YES/NO/UP/DOWN).",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          instId: {
+            type: "string",
+            description: "Event contract instrument ID"
+          },
+          state: {
+            type: "string",
+            description: "live=pending orders; omit for history"
+          },
+          limit: {
+            type: "number",
+            description: "Max results (default 20)"
+          }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const state = readString(args, "state");
+        const isPending = state === "live";
+        const endpoint = isPending ? "/api/v5/trade/orders-pending" : "/api/v5/trade/orders-history";
+        const response = await context.client.privateGet(
+          endpoint,
+          compactObject({
+            instType: "EVENTS",
+            instId: readString(args, "instId"),
+            limit: readNumber(args, "limit")
+          }),
+          privateRateLimit("event_get_orders", 20)
+        );
+        const base = normalizeResponse(response);
+        const data = Array.isArray(base["data"]) ? base["data"].map((item) => ({
+          ...item,
+          displayTitle: formatDisplayTitle(String(item["instId"] ?? "")),
+          outcome: OUTCOME_LABELS[String(item["outcome"] ?? "")] ?? item["outcome"],
+          state: String(item["state"] ?? ""),
+          stateLabel: mapOrderState(String(item["state"] ?? ""))
+        })) : base["data"];
+        return { ...base, data };
+      }
+    },
+    {
+      name: "event_get_fills",
+      module: "event",
+      description: "Get event contract fill history. outcome pre-translated (YES/NO/UP/DOWN). Each record includes a 'type' field: 'fill' (subType 410, opening trade) or 'settlement' (subType 414 win / subType 415 loss, contract expiry payout). Settlement records include 'settlementResult' (win/loss) and 'pnl' fields \u2014 no separate market lookup needed to determine outcome.",
+      isWrite: false,
+      inputSchema: {
+        type: "object",
+        properties: {
+          instId: {
+            type: "string",
+            description: "Event contract instrument ID"
+          },
+          limit: {
+            type: "number",
+            description: "Max results (default 20)"
+          }
+        }
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privateGet(
+          "/api/v5/trade/fills",
+          compactObject({
+            instType: "EVENTS",
+            instId: readString(args, "instId"),
+            limit: readNumber(args, "limit")
+          }),
+          privateRateLimit("event_get_fills", 20)
+        );
+        const base = normalizeResponse(response);
+        const data = Array.isArray(base["data"]) ? base["data"].map(enrichFill) : base["data"];
+        return { ...base, data };
+      }
+    },
+    // -----------------------------------------------------------------------
+    // Private — write
+    // -----------------------------------------------------------------------
+    {
+      name: "event_place_order",
+      module: "event",
+      description: `Place an event contract order. [CAUTION] Places a real order.
+- outcome: UP/YES (bet price goes up/condition met) or DOWN/NO (bet price goes down/condition not met)
+- For limit orders: px is the event contract price (0.01\u20130.99), NOT the underlying asset price. It reflects market-implied probability when actively trading
+- tdMode is always isolated; speedBump is auto-set per exchange requirement \u2014 do not pass either`,
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          instId: {
+            type: "string",
+            description: "Event contract instrument ID, e.g. BTC-ABOVE-DAILY-260224-1600-120000"
+          },
+          side: {
+            type: "string",
+            enum: ["buy", "sell"],
+            description: "buy=open position, sell=close position"
+          },
+          outcome: OUTCOME_SCHEMA,
+          ordType: {
+            type: "string",
+            enum: ["market", "limit", "post_only"],
+            description: "Order type (default market)"
+          },
+          sz: {
+            type: "string",
+            description: "For limit/post_only: number of contracts. For market: quote currency amount (server converts to contracts using best available price; actual fill count may differ)."
+          },
+          px: {
+            type: "string",
+            description: "Event contract price (0.01\u20130.99). Required when ordType=limit. Do NOT use for market orders."
+          }
+        },
+        required: ["instId", "side", "outcome", "sz"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const ordType = readString(args, "ordType") ?? "market";
+        const speedBump = ordType !== "post_only" ? "1" : void 0;
+        const instId = requireString(args, "instId");
+        const response = await context.client.privatePost(
+          "/api/v5/trade/order",
+          compactObject({
+            instId,
+            tdMode: "isolated",
+            side: requireString(args, "side"),
+            outcome: resolveOutcome(requireString(args, "outcome")),
+            ordType,
+            sz: requireString(args, "sz"),
+            px: readString(args, "px"),
+            speedBump,
+            tag: context.config.sourceTag
+          }),
+          privateRateLimit("event_place_order", 60)
+        );
+        const base = normalizeResponse(response);
+        handlePlaceOrderError(base, asRecord(rawArgs), response.endpoint);
+        const data = Array.isArray(base["data"]) ? base["data"].map(({ tag: _t, ...rest }) => rest) : base["data"];
+        const placeSeriesId = extractSeriesId(instId);
+        const placeUnderlying = extractUnderlying(placeSeriesId);
+        const placeCcy = extractQuoteCcy(placeUnderlying ? placeUnderlying + "-USDT" : null);
+        const balResult = await fetchAvailableBalance(context.client, placeCcy);
+        const result = { ...base, data };
+        if (balResult.balance) {
+          result["availableBalance"] = balResult.balance;
+          result["availableBalanceCcy"] = balResult.ccy;
+        }
+        if (ordType === "market") {
+          result["orderNote"] = "Market order: sz is a quote currency amount. The exchange converts it to contracts based on best available price.";
+        }
+        return result;
+      }
+    },
+    {
+      name: "event_amend_order",
+      module: "event",
+      description: "Amend a pending event contract order (change price or size). [CAUTION] Modifies a real order. Only limit/post_only orders can be amended.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          instId: { type: "string", description: "Event contract instrument ID" },
+          ordId: { type: "string", description: "Order ID to amend" },
+          newPx: { type: "string", description: "New event contract price (0.01\u20130.99). Omit to keep current." },
+          newSz: { type: "string", description: "New size in contracts (omit to keep current)" }
+        },
+        required: ["instId", "ordId"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const response = await context.client.privatePost(
+          "/api/v5/trade/amend-order",
+          compactObject({
+            instId: requireString(args, "instId"),
+            ordId: requireString(args, "ordId"),
+            newPx: readString(args, "newPx"),
+            newSz: readString(args, "newSz"),
+            speedBump: "1"
+          }),
+          privateRateLimit("event_amend_order", 60)
+        );
+        return normalizeWrite3(response);
+      }
+    },
+    {
+      name: "event_cancel_order",
+      module: "event",
+      description: "Cancel a pending event contract order. [CAUTION] Cancels a real order. instId must be the full event contract instrument ID (e.g. BTC-ABOVE-DAILY-260224-1600-69700), NOT a spot trading pair.",
+      isWrite: true,
+      inputSchema: {
+        type: "object",
+        properties: {
+          instId: {
+            type: "string",
+            description: "Event contract instrument ID"
+          },
+          ordId: {
+            type: "string",
+            description: "Order ID to cancel"
+          }
+        },
+        required: ["instId", "ordId"]
+      },
+      handler: async (rawArgs, context) => {
+        const args = asRecord(rawArgs);
+        const instId = requireString(args, "instId");
+        const response = await context.client.privatePost(
+          "/api/v5/trade/cancel-order",
+          { instId, ordId: requireString(args, "ordId") },
+          privateRateLimit("event_cancel_order", 60)
+        );
+        if (Array.isArray(response.data) && response.data.length > 0) {
+          const item = response.data[0];
+          const sCode = item && String(item["sCode"] ?? "");
+          if (sCode === "51001") {
+            const expiryMs = inferExpiryMsFromInstId(instId);
+            const isExpired = expiryMs !== null && expiryMs < Date.now();
+            const reason = isExpired ? `The contract (${instId}) has already expired \u2014 the order was auto-cancelled at settlement. Check event_get_fills to confirm the outcome.` : `Instrument (${instId}) not found. Verify the instId with event_get_markets before retrying.`;
+            throw new OkxApiError(reason, { code: sCode, endpoint: response.endpoint });
+          }
+        }
+        return normalizeWrite3(response);
+      }
+    }
+  ];
+}
 function buildContractTradeTools(cfg) {
   const { prefix, module, label, instTypes, instIdExample } = cfg;
   const [defaultType, otherType] = instTypes;
@@ -7756,6 +8520,7 @@ function allToolSpecs() {
     ...registerOptionAlgoTools(),
     ...registerAlgoTradeTools(),
     ...registerAccountTools(),
+    ...registerEventContractTools(),
     ...registerBotTools(),
     ...registerAllEarnTools(),
     ...registerAuditTools(),
@@ -8848,7 +9613,7 @@ async function cmdDiagnoseMcp(options = {}) {
 
 // src/commands/diagnose.ts
 var CLI_VERSION = readCliVersion();
-var GIT_HASH = true ? "6d4d559" : "dev";
+var GIT_HASH = true ? "765bfa2" : "dev";
 function maskKey2(key) {
   if (!key) return "(not set)";
   if (key.length <= 8) return "****";
@@ -9837,6 +10602,47 @@ var HELP_TREE = {
       }
     }
   },
+  event: {
+    description: "Event contract trading \u2014 binary outcome prediction markets (Yes/No, Up/Down)",
+    commands: {
+      browse: {
+        usage: "okx event browse [--underlying <asset>]",
+        description: "Browse all active (in-progress) event contracts; px is event contract price (0.01\u20130.99), not the underlying asset price \u2014 reflects market-implied probability when actively trading"
+      },
+      series: {
+        usage: "okx event series [--seriesId <id>]",
+        description: "List event contract series grouped by type (UP/DOWN direction or YES/NO price-target)"
+      },
+      events: {
+        usage: "okx event events <seriesId> [--state <preopen|live|settling|expired>] [--limit <n>]",
+        description: "List events in a series (each event = one expiry)"
+      },
+      markets: {
+        usage: "okx event markets <seriesId> [--eventId <id>] [--state <preopen|live|settling|expired>] [--limit <n>]",
+        description: "List markets; px is event contract price (0.01\u20130.99), not the underlying asset price \u2014 reflects market-implied probability when actively trading; expired includes translated outcome and settleValue"
+      },
+      place: {
+        usage: "okx event place <instId> <side> <outcome> <sz> [--px <price>] [--ordType <market|limit|post_only>]",
+        description: "[CAUTION] Place an event contract order. outcome: UP/YES or DOWN/NO. limit: sz=contracts, px required. market: sz=quote currency amount, no px."
+      },
+      amend: {
+        usage: "okx event amend <instId> <ordId> [--px <price>] [--sz <n>]",
+        description: "[CAUTION] Amend a pending limit order (change price or size)"
+      },
+      cancel: {
+        usage: "okx event cancel <instId> <ordId>",
+        description: "Cancel a pending event contract order"
+      },
+      orders: {
+        usage: "okx event orders [--instId <id>] [--state live] [--limit <n>]",
+        description: "List event orders (state=live for pending; omit for history)"
+      },
+      fills: {
+        usage: "okx event fills [--instId <id>] [--limit <n>]",
+        description: "Get event contract fill history"
+      }
+    }
+  },
   config: {
     description: "Manage CLI configuration profiles",
     commands: {
@@ -10195,6 +11001,11 @@ var CLI_OPTIONS = {
   dir: { type: "string" },
   page: { type: "string" },
   format: { type: "string" },
+  // event contract
+  underlying: { type: "string" },
+  seriesId: { type: "string" },
+  eventId: { type: "string" },
+  outcome: { type: "string" },
   // diagnostics — cli/mcp/all/output are diagnose-specific; verbose is shared
   verbose: { type: "boolean", default: false },
   mcp: { type: "boolean", default: false },
@@ -13213,10 +14024,462 @@ function printSkillInstallResult(meta, json) {
   }
 }
 
+// src/commands/event-contract.ts
+function getData8(result) {
+  return result.data;
+}
+function fmtMethod(raw) {
+  const map = {
+    // API returns values in various cases; normalise to lowercase for lookup
+    price_above: "Price Above",
+    price_up_down: "Up/Down",
+    price_once_touch: "One Touch",
+    // Uppercase variants (in case API returns them)
+    PRICE_ABOVE: "Price Above",
+    PRICE_UP_DOWN: "Up/Down",
+    PRICE_ONCE_TOUCH: "One Touch"
+  };
+  return map[String(raw)] ?? String(raw ?? "");
+}
+function fmtFreq(raw) {
+  const map = {
+    fifteen_min: "15min",
+    daily: "Daily",
+    hourly: "1h",
+    weekly: "Weekly",
+    FIFTEEN_MIN: "15min",
+    DAILY: "Daily",
+    HOURLY: "1h",
+    WEEKLY: "Weekly"
+  };
+  return map[String(raw)] ?? String(raw ?? "");
+}
+function fmtOutcome(raw) {
+  const s = String(raw ?? "").toLowerCase();
+  if (s === "" || s === "pending") return "";
+  return String(raw ?? "");
+}
+function fmtMarketOutcome(instId, outcome) {
+  const formatted = fmtOutcome(outcome);
+  if (formatted === "") return "";
+  return fmtOrderOutcome(instId, formatted);
+}
+function fmtOrderOutcome(instId, outcome) {
+  const id = String(instId ?? "").toUpperCase();
+  const isUpDown = id.includes("UPDOWN") || id.includes("UP-DOWN");
+  const normalized = String(outcome ?? "").toLowerCase();
+  if (outcome === "1" || outcome === 1 || normalized === "yes") return isUpDown ? "UP" : "YES";
+  if (outcome === "2" || outcome === 2 || normalized === "no") return isUpDown ? "DOWN" : "NO";
+  return String(outcome ?? "");
+}
+function fmtPeriodFromInstId(instId) {
+  const parts = instId.split("-");
+  const upper = instId.toUpperCase();
+  const dateIdx = findDateIdx(parts);
+  if (dateIdx < 0) return instId;
+  const dp = parts[dateIdx];
+  const date = `20${dp.slice(0, 2)}-${dp.slice(2, 4)}-${dp.slice(4, 6)}`;
+  const fmt = (t) => t.length === 4 ? `${t.slice(0, 2)}:${t.slice(2)}` : t;
+  const t1 = parts[dateIdx + 1] ?? "";
+  const t2 = parts[dateIdx + 2] ?? "";
+  const isUpDown = upper.includes("UPDOWN");
+  if (isUpDown && /^\d{4}$/.test(t1) && /^\d{4}$/.test(t2)) {
+    return `${date} ${fmt(t1)} ~ ${fmt(t2)} UTC+8`;
+  }
+  if (/^\d{4}$/.test(t1)) {
+    return `${date} ${fmt(t1)} UTC+8`;
+  }
+  return instId;
+}
+function fmtTs(raw) {
+  if (!raw) return "";
+  const n = Number(raw);
+  if (Number.isNaN(n)) return String(raw);
+  return new Date(n).toISOString().replace("T", " ").replace(".000Z", " UTC");
+}
+function fmtProbability(raw) {
+  if (raw === "" || raw == null) return "";
+  const n = Number(raw);
+  if (Number.isNaN(n)) return String(raw);
+  return `${(n * 100).toFixed(1)}%`;
+}
+async function cmdEventBrowse(run, opts) {
+  const result = await run("event_browse", { underlying: opts.underlying });
+  const data = getData8(result);
+  if (opts.json) return printJson(data);
+  if (!data || data.length === 0) {
+    process.stdout.write("No active event contracts found.\n");
+    return;
+  }
+  for (const group of data) {
+    const contracts = group["contracts"] ?? [];
+    const methodLabel = fmtMethod(group["method"]);
+    const freqLabel = fmtFreq(group["freq"]);
+    process.stdout.write(`
+[${methodLabel}] ${group["underlying"]}  (${freqLabel})
+`);
+    printTable(
+      contracts.map((c) => ({
+        "Contract": formatDisplayTitle(String(c["instId"] ?? "")),
+        "Expiry": c["expTime"] ?? "",
+        "Target Price": c["floorStrike"] ? String(c["floorStrike"]) : "\u2014",
+        "Probability": fmtProbability(c["px"]),
+        "Outcome": fmtOutcome(c["outcome"]) || "\u2014",
+        "instId": c["instId"]
+      }))
+    );
+  }
+  const total = data.reduce((n, g) => n + (g["contracts"]?.length ?? 0), 0);
+  process.stdout.write(`
+${total} active contract(s) across ${data.length} series.
+`);
+}
+var FEATURED_SERIES = /* @__PURE__ */ new Set([
+  "BTC-UPDOWN-15MIN",
+  "ETH-UPDOWN-15MIN",
+  "TRX-UPDOWN-15MIN",
+  "BTC-ABOVE-DAILY",
+  "ETH-ABOVE-DAILY"
+]);
+var KNOWN_PREFIXES = /^(BTC|ETH|TRX|SOL|EOS|BNB|XRP|ADA|DOGE|IOTA|SUSHI|KISHU|BTG|XTZ)-/i;
+function getSeriesMethod(s) {
+  const settlement = s["settlement"];
+  const method = settlement?.["method"] ?? s["method"];
+  return String(method ?? "").toLowerCase();
+}
+function isUpDownSeries(s) {
+  const m = getSeriesMethod(s);
+  return m.includes("up_down") || m.includes("updown");
+}
+function isFeatured(s) {
+  return FEATURED_SERIES.has(String(s["seriesId"] ?? ""));
+}
+function isKnownSeries(s) {
+  return KNOWN_PREFIXES.test(String(s["seriesId"] ?? ""));
+}
+function classifySeries(all) {
+  const featured = [];
+  const standard = [];
+  const testSeries = [];
+  for (const s of all) {
+    if (isFeatured(s)) featured.push(s);
+    else if (isKnownSeries(s)) standard.push(s);
+    else testSeries.push(s);
+  }
+  return { featured, standard, testSeries };
+}
+async function cmdEventSeries(run, opts) {
+  const result = await run("event_get_series", { seriesId: opts.seriesId });
+  const data = getData8(result);
+  if (opts.json) return printJson(data);
+  const toRow = (s, featured2) => {
+    const settlement = s["settlement"];
+    const method = settlement?.["method"] ?? s["method"];
+    const underlying = settlement?.["underlying"] ?? s["underlying"] ?? s["baseCcy"];
+    return {
+      Series: `${featured2 ? "\u2B50 " : ""}${String(s["seriesId"] ?? "")}`,
+      Type: fmtMethod(method),
+      Freq: fmtFreq(s["freq"]),
+      Underlying: String(underlying ?? ""),
+      State: String(s["state"] ?? "")
+    };
+  };
+  const all = data ?? [];
+  const { featured, standard, testSeries } = classifySeries(all);
+  const mainSeries = [...featured, ...standard];
+  const updown = mainSeries.filter(isUpDownSeries);
+  const above = mainSeries.filter((s) => !isUpDownSeries(s));
+  if (updown.length > 0) {
+    process.stdout.write("\n\u2500\u2500 Up/Down \u2500\u2500\n");
+    printTable(updown.map((s) => toRow(s, isFeatured(s))));
+  }
+  if (above.length > 0) {
+    process.stdout.write("\n\u2500\u2500 Price Above \u2500\u2500\n");
+    printTable(above.map((s) => toRow(s, isFeatured(s))));
+  }
+  if (testSeries.length > 0) {
+    if (opts.all) {
+      process.stdout.write("\n\u2500\u2500 Test / Other \u2500\u2500\n");
+      printTable(testSeries.map((s) => toRow(s, false)));
+    } else {
+      process.stdout.write(`
+${testSeries.length} test series hidden (use --all to show)
+`);
+    }
+  }
+}
+async function cmdEventEvents(run, opts) {
+  const result = await run("event_get_events", {
+    seriesId: opts.seriesId,
+    state: opts.state,
+    limit: opts.limit
+  });
+  const data = getData8(result);
+  if (opts.json) return printJson(data);
+  printTable(
+    (data ?? []).map((e) => ({
+      eventId: e["eventId"],
+      state: e["state"],
+      expTime: fmtTs(e["expTime"]),
+      settleTime: fmtTs(e["settleTime"])
+    }))
+  );
+}
+function sortByExpiry(data) {
+  return [...data].sort((a, b) => {
+    const ea = inferExpiryMsFromInstId(String(a["instId"] ?? "")) ?? Infinity;
+    const eb = inferExpiryMsFromInstId(String(b["instId"] ?? "")) ?? Infinity;
+    return ea - eb;
+  });
+}
+async function cmdEventMarkets(run, opts) {
+  const result = await run("event_get_markets", {
+    seriesId: opts.seriesId,
+    eventId: opts.eventId,
+    instId: opts.instId,
+    state: opts.state,
+    limit: opts.limit
+  });
+  const data = getData8(result);
+  if (opts.json) return printJson(data);
+  const ext = result;
+  const currentIdxPx = ext["currentIdxPx"];
+  const underlying = ext["underlying"];
+  if (currentIdxPx != null) {
+    process.stdout.write(
+      `${underlying ?? ""} current index price: $${currentIdxPx}
+`
+    );
+  }
+  const sorted = sortByExpiry(data ?? []);
+  printTable(
+    sorted.map((m) => {
+      const id = String(m["instId"] ?? "");
+      const outcome = fmtMarketOutcome(m["instId"], m["outcome"]);
+      return {
+        contract: formatDisplayTitle(id),
+        expTime: m["expTime"] ?? "",
+        targetPrice: m["floorStrike"] ?? "",
+        probability: fmtProbability(m["px"]),
+        outcome: outcome.toLowerCase() === "pending" ? "\u2014" : outcome,
+        settleValue: m["settleValue"] ?? "",
+        instId: id
+      };
+    })
+  );
+}
+async function cmdEventOrders(run, opts) {
+  const result = await run("event_get_orders", {
+    instId: opts.instId,
+    state: opts.state,
+    limit: opts.limit
+  });
+  const data = getData8(result);
+  if (opts.json) return printJson(data);
+  printTable(
+    (data ?? []).map((o) => ({
+      "Contract": formatDisplayTitle(String(o["instId"] ?? "")),
+      "Time": fmtTs(o["cTime"]),
+      "Direction": `${String(o["side"] ?? "").toUpperCase()} ${fmtOrderOutcome(o["instId"], o["outcome"]).toUpperCase()}`,
+      "Price": o["px"],
+      "Size": `${o["fillSz"] ?? 0} / ${o["sz"]}`,
+      "Status": o["stateLabel"] ?? o["state"],
+      "Order number": o["ordId"]
+    }))
+  );
+}
+async function cmdEventFills(run, opts) {
+  const result = await run("event_get_fills", {
+    instId: opts.instId,
+    limit: opts.limit
+  });
+  const data = getData8(result);
+  if (opts.json) return printJson(data);
+  printTable(
+    (data ?? []).map((f) => ({
+      "Contract": formatDisplayTitle(String(f["instId"] ?? "")),
+      "Direction": (() => {
+        const side = String(f["side"] ?? "").toUpperCase();
+        const outcome = fmtOrderOutcome(f["instId"], f["outcome"]).toUpperCase();
+        const dir = `${side} ${outcome}`.trim();
+        return dir || "\u2014";
+      })(),
+      "Fill Price": f["fillPx"],
+      "Fill Size": f["fillSz"],
+      "Time": fmtTs(f["ts"]),
+      "Order number": f["ordId"]
+    }))
+  );
+}
+async function handleExpiredContractFallback(run, opts) {
+  process.stdout.write(
+    `Order failed: Contract ${opts.instId} has expired.
+Checking next available contracts in this series...
+`
+  );
+  const seriesId = extractSeriesId(opts.instId);
+  try {
+    const mkts = await run("event_get_markets", { seriesId, state: "live" });
+    const mData = getData8(mkts) ?? [];
+    const active = mData.filter((m) => m["floorStrike"] && m["floorStrike"] !== "");
+    if (active.length > 0) {
+      printTable(
+        active.slice(0, 3).map((m) => ({
+          instId: m["instId"],
+          expTime: m["expTime"] ?? "",
+          targetPrice: m["floorStrike"] ?? ""
+        }))
+      );
+      const next = active[0];
+      const nextInstId = String(next["instId"]);
+      const pxFlag = opts.px ? ` --px ${opts.px}` : "";
+      const ordTypeFlag = opts.ordType ? ` --ordType ${opts.ordType}` : "";
+      process.stdout.write(
+        `
+To place the same order on the next contract:
+  okx event place ${nextInstId} ${opts.side} ${opts.outcome} ${opts.sz}${pxFlag}${ordTypeFlag}
+`
+      );
+    } else {
+      process.stdout.write(`No active contracts found in this series.
+`);
+    }
+  } catch {
+  }
+}
+function handlePlaceOrderError2(msg, instId) {
+  if (msg.includes("not found") || msg.includes("51001")) {
+    process.stdout.write(`Order failed: Contract ${instId} not found or not yet available.
+`);
+  } else {
+    process.stdout.write(`Order failed: ${msg}
+`);
+  }
+}
+function buildPlaceConfirmation(opts, ordType) {
+  const contractName = formatDisplayTitle(opts.instId);
+  const direction = `${opts.side.toUpperCase()} ${opts.outcome.toUpperCase()}`;
+  if (ordType === "market") {
+    return `Placing: ${contractName}  ${direction}  sz=${opts.sz} (market order, exchange converts to contracts)
+`;
+  }
+  const px = parseFloat(opts.px ?? "0");
+  const sz = parseFloat(opts.sz);
+  const cost = (sz * px).toFixed(2);
+  const maxGain = (sz * (1 - px)).toFixed(2);
+  return `Placing: ${contractName}  ${direction}  ${opts.sz} contracts at px=${opts.px} (cost \u2248 ${cost}, max gain \u2248 ${maxGain})
+`;
+}
+async function cmdEventPlace(run, opts) {
+  const ordType = opts.ordType ?? "market";
+  if (ordType === "limit" && !opts.px) {
+    process.stderr.write("Error: --px is required for limit orders.\n");
+    process.exitCode = 1;
+    return;
+  }
+  if (!opts.json) {
+    process.stdout.write(buildPlaceConfirmation(opts, ordType));
+  }
+  let result;
+  try {
+    result = await run("event_place_order", {
+      instId: opts.instId,
+      side: opts.side,
+      outcome: opts.outcome,
+      sz: opts.sz,
+      px: opts.px,
+      ordType: opts.ordType
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    const expiryMs = inferExpiryMsFromInstId(opts.instId);
+    const isExpired = expiryMs !== null && expiryMs < Date.now();
+    if (isExpired) {
+      await handleExpiredContractFallback(run, opts);
+    } else {
+      handlePlaceOrderError2(msg, opts.instId);
+    }
+    return;
+  }
+  const data = getData8(result);
+  if (opts.json) return printJson(data);
+  const order = data?.[0];
+  const stateHint = ordType === "market" ? "market order \u2014 typically fills immediately" : `${ordType} order \u2014 may still be live; verify with: okx event orders --instId ${opts.instId} --state live`;
+  const period = fmtPeriodFromInstId(opts.instId);
+  const pxPart = opts.px ? `  px: ${opts.px}` : "";
+  process.stdout.write(
+    `Order submitted: ${order?.["ordId"]}
+  Period: ${period}
+  ${opts.side.toUpperCase()} ${opts.outcome.toUpperCase()}  sz: ${opts.sz}${pxPart}  type: ${ordType}
+  (${stateHint})
+`
+  );
+  if (ordType === "market") {
+    process.stdout.write("  Note: exchange converts sz (amount) to contracts based on best available price\n");
+  }
+}
+async function cmdEventAmend(run, opts) {
+  let result;
+  try {
+    result = await run("event_amend_order", {
+      instId: opts.instId,
+      ordId: opts.ordId,
+      newPx: opts.px,
+      newSz: opts.sz
+    });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    process.stdout.write(`Failed to amend order ${opts.ordId}: ${msg}
+`);
+    return;
+  }
+  const data = getData8(result);
+  if (opts.json) return printJson(data);
+  const r = data?.[0];
+  const pxPart = opts.px ? `  new px: ${opts.px}` : "";
+  const szPart = opts.sz ? `  new sz: ${opts.sz}` : "";
+  process.stdout.write(
+    `Amended: ${r?.["ordId"] ?? opts.ordId}${pxPart}${szPart}
+`
+  );
+}
+function handleCancelCatchError(instId, ordId, err) {
+  const msg = err instanceof Error ? err.message : String(err);
+  const expiryMs = inferExpiryMsFromInstId(instId);
+  const isExpired = expiryMs !== null && expiryMs < Date.now();
+  if (isExpired) {
+    process.stdout.write(
+      `Cannot cancel: contract ${instId} has already expired.
+  The order was auto-cancelled at settlement \u2014 no action needed.
+`
+    );
+  } else {
+    process.stdout.write(`Failed to cancel order ${ordId}: ${msg}
+`);
+  }
+}
+async function cmdEventCancel(run, opts) {
+  let result;
+  try {
+    result = await run("event_cancel_order", {
+      instId: opts.instId,
+      ordId: opts.ordId
+    });
+  } catch (err) {
+    handleCancelCatchError(opts.instId, opts.ordId, err);
+    return;
+  }
+  const data = getData8(result);
+  if (opts.json) return printJson(data);
+  const r = data?.[0];
+  process.stdout.write(`Cancelled: ${r?.["ordId"] ?? opts.ordId}
+`);
+}
+
 // src/index.ts
 var _require3 = createRequire3(import.meta.url);
 var CLI_VERSION2 = _require3("../package.json").version;
-var GIT_HASH2 = true ? "6d4d559" : "dev";
+var GIT_HASH2 = true ? "765bfa2" : "dev";
 function handleConfigCommand(action, rest, json, lang, force) {
   if (action === "init") return cmdConfigInit(lang === "zh" ? "zh" : "en");
   if (action === "show") return cmdConfigShow(json);
@@ -14026,6 +15289,33 @@ function handleSkillCommand(run, action, rest, v, json, config) {
   errorLine("Valid: search, categories, add, download, remove, check, list");
   process.exitCode = 1;
 }
+function handleEventCommand(run, action, rest, v, json) {
+  const limit = v.limit !== void 0 ? Number(v.limit) : void 0;
+  const handlers = {
+    browse: () => cmdEventBrowse(run, { underlying: v.underlying ?? rest[0], json }),
+    series: () => cmdEventSeries(run, { seriesId: v.seriesId, all: v.all, json }),
+    events: () => cmdEventEvents(run, { seriesId: v.seriesId ?? rest[0], state: v.state, limit, json }),
+    markets: () => cmdEventMarkets(run, { seriesId: v.seriesId ?? rest[0], eventId: v.eventId, instId: v.instId, state: v.state, limit, json }),
+    place: () => cmdEventPlace(run, {
+      instId: v.instId ?? rest[0],
+      side: v.side ?? rest[1],
+      outcome: v.outcome ?? rest[2],
+      sz: v.sz ?? rest[3],
+      px: v.px,
+      ordType: v.ordType,
+      json
+    }),
+    amend: () => cmdEventAmend(run, { instId: v.instId ?? rest[0], ordId: v.ordId ?? rest[1], px: v.px, sz: v.sz, json }),
+    cancel: () => cmdEventCancel(run, { instId: v.instId ?? rest[0], ordId: v.ordId ?? rest[1], json }),
+    orders: () => cmdEventOrders(run, { instId: v.instId, state: v.state, limit, json }),
+    fills: () => cmdEventFills(run, { instId: v.instId, limit, json })
+  };
+  const handler = handlers[action];
+  if (handler) return handler();
+  process.stderr.write(`Unknown event command: ${action}
+`);
+  process.exitCode = 1;
+}
 function outputResult(result, json) {
   if (json) {
     outputLine(JSON.stringify(result, null, 2));
@@ -14104,6 +15394,7 @@ async function main() {
     swap: () => handleSwapCommand(run, action, rest, v, json),
     futures: () => handleFuturesCommand(run, action, rest, v, json),
     option: () => handleOptionCommand(run, action, rest, v, json),
+    event: () => handleEventCommand(run, action, rest, v, json),
     bot: () => handleBotCommand(run, action, rest, v, json),
     earn: () => handleEarnCommand(run, action, rest, v, json),
     skill: () => handleSkillCommand(run, action, rest, v, json, config)
@@ -14128,6 +15419,7 @@ export {
   handleBotGridCommand,
   handleConfigCommand,
   handleEarnCommand,
+  handleEventCommand,
   handleFuturesAlgoCommand,
   handleFuturesCommand,
   handleMarketCommand,