polycopy 0.0.1

package/dist/index.js

@@ -0,0 +1,1048 @@
+"use strict";
+const init = require("./init-C8vHJzZn.js");
+const grammy = require("grammy");
+const wallet = require("@ethersproject/wallet");
+const clobClient = require("@polymarket/clob-client");
+const builderSigningSdk = require("@polymarket/builder-signing-sdk");
+const viem = require("viem");
+const accounts = require("viem/accounts");
+const chains = require("viem/chains");
+const builderRelayerClient = require("@polymarket/builder-relayer-client");
+const setPromiseInterval = require("set-promise-interval");
+const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
+const setPromiseInterval__default = /* @__PURE__ */ _interopDefault(setPromiseInterval);
+class Notifier {
+  bot = null;
+  adminChatId = null;
+  initialized = false;
+  /**
+   * 初始化通知器
+   */
+  init(botToken, adminChatId) {
+    if (!adminChatId) {
+      init.logger.warning("未配置管理员 Chat ID，通知功能已禁用");
+      return;
+    }
+    this.bot = new grammy.Bot(botToken);
+    this.adminChatId = adminChatId;
+    this.initialized = true;
+    init.logger.info("管理员通知已启用");
+  }
+  /**
+   * 发送错误通知
+   */
+  async error(message, details) {
+    await this.send(`🔴 ${message}`, details);
+  }
+  /**
+   * 发送警告通知
+   */
+  async warning(message, details) {
+    await this.send(`🟡 ${message}`, details);
+  }
+  /**
+   * 发送成功通知
+   */
+  async success(message, details) {
+    await this.send(`🟢 ${message}`, details);
+  }
+  /**
+   * 发送消息给管理员
+   */
+  async send(message, details) {
+    if (!this.initialized || !this.bot || !this.adminChatId) {
+      return;
+    }
+    const fullMessage = details ? `${message}
+
+${details}` : message;
+    try {
+      await this.bot.api.sendMessage(this.adminChatId, fullMessage, {
+        parse_mode: "HTML"
+      });
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      init.logger.error(`发送通知失败: ${errorMsg}`);
+    }
+  }
+}
+const notifier = new Notifier();
+const CLOB_HOST = "https://clob.polymarket.com";
+class ClobClientWrapper {
+  client = null;
+  initialized = false;
+  /**
+   * 初始化客户端
+   */
+  async init(config) {
+    if (this.initialized) {
+      return;
+    }
+    const wallet$1 = new wallet.Wallet(config.privateKey);
+    init.logger.info(`钱包地址: ${wallet$1.address}`);
+    const tempClient = new clobClient.ClobClient(CLOB_HOST, clobClient.Chain.POLYGON, wallet$1);
+    this.patchClient(tempClient);
+    const creds = await tempClient.deriveApiKey();
+    init.logger.success("API 凭证已获取");
+    let builderConfig;
+    if (config.builderCreds) {
+      builderConfig = new builderSigningSdk.BuilderConfig({
+        localBuilderCreds: config.builderCreds
+      });
+    }
+    this.client = new clobClient.ClobClient(
+      CLOB_HOST,
+      clobClient.Chain.POLYGON,
+      wallet$1,
+      creds,
+      2,
+      // POLY_GNOSIS_SAFE
+      config.funderAddress,
+      // Polymarket 账户地址（页面右上角）
+      void 0,
+      // geoBlockToken
+      true,
+      // useServerTime
+      builderConfig
+    );
+    this.patchClient(this.client);
+    this.initialized = true;
+    init.logger.success("ClobClient 初始化完成");
+  }
+  /**
+   * 魔法操作：clob-client 请求出错不抛异常，只返回 { error: ... }
+   * 参考：https://github.com/Polymarket/clob-client/blob/96e25998b8ae78be27855e07faf15099602bcd47/src/http-helpers/index.ts#L90
+   * 这里统一包装，让它抛出异常
+   */
+  patchClient(client) {
+    const c = client;
+    for (const method of ["get", "post", "del"]) {
+      const original = c[method];
+      c[method] = function(...args) {
+        return original.call(c, ...args).then((result) => {
+          if (result?.error) {
+            throw new Error(
+              typeof result.error === "string" ? result.error : JSON.stringify(result.error)
+            );
+          }
+          return result;
+        });
+      };
+    }
+  }
+  /**
+   * 确保客户端已初始化
+   */
+  ensureInitialized() {
+    if (!this.client || !this.initialized) {
+      throw new Error("ClobClient 未初始化");
+    }
+    return this.client;
+  }
+  /**
+   * 获取 USDC 余额（已处理 6 位小数精度）
+   */
+  async getBalance() {
+    const client = this.ensureInitialized();
+    const result = await client.getBalanceAllowance({
+      asset_type: clobClient.AssetType.COLLATERAL
+    });
+    return parseFloat(result.balance) / 1e6;
+  }
+  /**
+   * 获取 token 的 tickSize
+   */
+  async getTickSize(tokenId) {
+    const client = this.ensureInitialized();
+    return await client.getTickSize(tokenId);
+  }
+  /**
+   * 获取 token 是否为 negRisk
+   */
+  async getNegRisk(tokenId) {
+    const client = this.ensureInitialized();
+    return await client.getNegRisk(tokenId);
+  }
+  /**
+   * 创建买单（GTC 限价单）
+   */
+  async createBuyOrder(tokenId, price, size) {
+    const client = this.ensureInitialized();
+    const userOrder = {
+      tokenID: tokenId,
+      price,
+      size,
+      side: clobClient.Side.BUY
+    };
+    try {
+      const tickSize = await this.getTickSize(tokenId);
+      const negRisk = await this.getNegRisk(tokenId);
+      const response = await client.createAndPostOrder(
+        userOrder,
+        { tickSize, negRisk },
+        clobClient.OrderType.GTC
+      );
+      if (response.success) {
+        init.logger.success(`买单创建成功: ${response.orderID}`);
+        return {
+          success: true,
+          orderId: response.orderID
+        };
+      } else {
+        init.logger.error(`买单创建失败: ${response.errorMsg}`);
+        return {
+          success: false,
+          orderId: "",
+          errorMsg: response.errorMsg
+        };
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      init.logger.error(`买单创建异常: ${errorMsg}`);
+      return {
+        success: false,
+        orderId: "",
+        errorMsg
+      };
+    }
+  }
+  /**
+   * 创建卖单（GTC 限价单）
+   */
+  async createSellOrder(tokenId, price, size) {
+    const client = this.ensureInitialized();
+    const userOrder = {
+      tokenID: tokenId,
+      price,
+      size,
+      side: clobClient.Side.SELL
+    };
+    try {
+      const tickSize = await this.getTickSize(tokenId);
+      const negRisk = await this.getNegRisk(tokenId);
+      const response = await client.createAndPostOrder(
+        userOrder,
+        { tickSize, negRisk },
+        clobClient.OrderType.GTC
+      );
+      if (response.success) {
+        return {
+          success: true,
+          orderId: response.orderID
+        };
+      } else {
+        return {
+          success: false,
+          orderId: "",
+          errorMsg: response.errorMsg
+        };
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      return {
+        success: false,
+        orderId: "",
+        errorMsg
+      };
+    }
+  }
+  /**
+   * 获取订单状态
+   */
+  async getOrder(orderId) {
+    const client = this.ensureInitialized();
+    return await client.getOrder(orderId);
+  }
+  /**
+   * 取消订单
+   */
+  async cancelOrder(orderId) {
+    const client = this.ensureInitialized();
+    try {
+      await client.cancelOrder({ orderID: orderId });
+      init.logger.info(`订单已取消: ${orderId}`);
+      return true;
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      init.logger.error(`取消订单失败: ${errorMsg}`);
+      return false;
+    }
+  }
+  /**
+   * 获取指定 token 的持仓数量
+   */
+  async getPositionSize(tokenId) {
+    const client = this.ensureInitialized();
+    const result = await client.getBalanceAllowance({
+      asset_type: clobClient.AssetType.CONDITIONAL,
+      token_id: tokenId
+    });
+    return parseFloat(result.balance) / 1e6;
+  }
+}
+const RPC_URL = "https://polygon-rpc.com";
+const CTF_ADDRESS = viem.getAddress("0x4d97dcd97ec945f40cf65f87097ace5ea0476045");
+const USDC_ADDRESS = viem.getAddress("0x2791bca1f2de4661ed88a30c99a7a9449aa84174");
+class RelayClientWrapper {
+  relayClient = null;
+  initialized = false;
+  /**
+   * 初始化 RelayClient
+   */
+  init(config) {
+    if (this.initialized) {
+      return;
+    }
+    const account = accounts.privateKeyToAccount(config.privateKey);
+    const walletClient = viem.createWalletClient({
+      account,
+      chain: chains.polygon,
+      transport: viem.http(RPC_URL)
+    });
+    const builderConfig = new builderSigningSdk.BuilderConfig({
+      localBuilderCreds: config.builderCreds
+    });
+    this.relayClient = new builderRelayerClient.RelayClient(
+      "https://relayer-v2.polymarket.com",
+      137,
+      walletClient,
+      builderConfig,
+      builderRelayerClient.RelayerTxType.SAFE
+    );
+    this.initialized = true;
+    init.logger.success("RelayClient 初始化完成");
+  }
+  /**
+   * 检查是否已初始化
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * 执行 Redeem
+   * @param conditionId 条件 ID
+   * @returns 交易哈希
+   */
+  async redeem(conditionId) {
+    if (!this.relayClient || !this.initialized) {
+      throw new Error("RelayClient 未初始化");
+    }
+    const calldata = viem.encodeFunctionData({
+      abi: [
+        {
+          name: "redeemPositions",
+          type: "function",
+          inputs: [
+            { name: "collateralToken", type: "address" },
+            { name: "parentCollectionId", type: "bytes32" },
+            { name: "conditionId", type: "bytes32" },
+            { name: "indexSets", type: "uint256[]" }
+          ],
+          outputs: [],
+          stateMutability: "nonpayable"
+        }
+      ],
+      functionName: "redeemPositions",
+      args: [USDC_ADDRESS, viem.zeroHash, conditionId, [1n, 2n]]
+    });
+    const tx = {
+      to: CTF_ADDRESS,
+      value: "0",
+      data: calldata
+    };
+    const response = await this.relayClient.execute(
+      [tx],
+      "Polymarket redeem positions"
+    );
+    const result = await response.wait();
+    if (!result) {
+      throw new Error(
+        "Redeem 交易失败：wait() 返回空结果（可能被 revert 或 relayer 拒绝）"
+      );
+    }
+    return result.transactionHash;
+  }
+}
+class AssetFilter {
+  // endTime -> Set<assetId>
+  traded = /* @__PURE__ */ new Map();
+  currentEndTime = 0;
+  /**
+   * 检查 assetId 是否可以交易
+   */
+  canTrade(assetId, endTime) {
+    if (endTime !== this.currentEndTime) {
+      this.cleanupBefore(endTime);
+      this.currentEndTime = endTime;
+    }
+    const tradedSet = this.traded.get(endTime);
+    if (!tradedSet) {
+      return true;
+    }
+    return !tradedSet.has(assetId);
+  }
+  /**
+   * 标记 assetId 已交易
+   */
+  markTraded(assetId, endTime) {
+    if (!this.traded.has(endTime)) {
+      this.traded.set(endTime, /* @__PURE__ */ new Set());
+    }
+    this.traded.get(endTime).add(assetId);
+    init.logger.info(`已标记 assetId 交易完成: ${assetId.slice(0, 10)}...`);
+  }
+  /**
+   * 清理过期记录
+   */
+  cleanupBefore(currentEndTime) {
+    let cleanedCount = 0;
+    for (const endTime of this.traded.keys()) {
+      if (endTime < currentEndTime) {
+        this.traded.delete(endTime);
+        cleanedCount++;
+      }
+    }
+    if (cleanedCount > 0) {
+      init.logger.info(`已清理 ${cleanedCount} 个过期周期的交易记录`);
+    }
+  }
+}
+class BalanceCache {
+  // endTime -> balance
+  cache = /* @__PURE__ */ new Map();
+  currentEndTime = 0;
+  /**
+   * 获取余额（带缓存）
+   * @param endTime 事件结束时间
+   * @param fetchFn 获取余额的函数
+   */
+  async getBalance(endTime, fetchFn) {
+    if (endTime !== this.currentEndTime) {
+      this.cleanupBefore(endTime);
+      this.currentEndTime = endTime;
+    }
+    if (this.cache.has(endTime)) {
+      const cached = this.cache.get(endTime);
+      init.logger.info(`使用缓存余额: ${cached} USDC`);
+      return cached;
+    }
+    const balance = await fetchFn();
+    this.cache.set(endTime, balance);
+    init.logger.info(`获取当前余额: ${balance} USDC`);
+    return balance;
+  }
+  /**
+   * 清除所有缓存（Redeem 成功后调用）
+   */
+  invalidate() {
+    if (this.cache.size > 0) {
+      this.cache.clear();
+      init.logger.info("余额缓存已清除");
+    }
+  }
+  /**
+   * 清理过期缓存
+   */
+  cleanupBefore(currentEndTime) {
+    let cleanedCount = 0;
+    for (const endTime of this.cache.keys()) {
+      if (endTime < currentEndTime) {
+        this.cache.delete(endTime);
+        cleanedCount++;
+      }
+    }
+    if (cleanedCount > 0) {
+      init.logger.info(`已清理 ${cleanedCount} 个过期周期的余额缓存`);
+    }
+  }
+}
+const TERMINAL_STATUSES = ["MATCHED", "CONFIRMED", "FAILED", "CANCELLED"];
+const POLL_INTERVAL = 3e3;
+const TIMEOUT_BUFFER = 2 * 60 * 1e3;
+class OrderWatcher {
+  /**
+   * 监控订单直到进入终态或超时
+   * @param orderId 订单 ID
+   * @param endTime 事件结束时间（毫秒）
+   * @param getOrderFn 获取订单的函数
+   */
+  async watch(orderId, endTime, getOrderFn) {
+    const timeoutAt = endTime + TIMEOUT_BUFFER;
+    const shortId = orderId.substring(0, 10) + "...";
+    init.logger.info(`开始监控订单 ${shortId}，超时: ${new Date(timeoutAt).toLocaleString()}`);
+    while (true) {
+      const now = Date.now();
+      if (now >= timeoutAt) {
+        init.logger.warning(`订单超时: ${shortId}`);
+        return { status: "TIMEOUT" };
+      }
+      try {
+        const order = await getOrderFn(orderId);
+        const status = order.status.toUpperCase();
+        if (TERMINAL_STATUSES.includes(status)) {
+          const filledSize = parseFloat(order.size_matched || "0");
+          init.logger.info(`订单 ${shortId} 终态: ${status}，成交: ${filledSize}`);
+          return {
+            status,
+            filledSize,
+            order
+          };
+        }
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        init.logger.warning(`查询订单失败: ${errorMsg}，继续重试...`);
+      }
+      await this.delay(POLL_INTERVAL);
+    }
+  }
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+const DATA_API_HOST = "https://data-api.polymarket.com";
+const BASE_INTERVAL = 5 * 60 * 1e3;
+const MAX_MATCH_TIMES = 3;
+class Redeemer {
+  // conditionId -> RedeemRecord
+  records = /* @__PURE__ */ new Map();
+  intervalId;
+  delayTimeoutId;
+  running = false;
+  redeemFn = null;
+  funderAddress = "";
+  onRedeemSuccess = null;
+  /**
+   * 启动 Redeemer
+   * @param redeemFn 执行 Redeem 的函数（返回交易哈希）
+   * @param funderAddress Polymarket 账户地址（用于查询仓位）
+   * @param onRedeemSuccess Redeem 成功后的回调（用于更新余额缓存）
+   */
+  start(redeemFn, funderAddress, onRedeemSuccess) {
+    if (this.running) {
+      return;
+    }
+    this.redeemFn = redeemFn;
+    this.funderAddress = funderAddress;
+    this.onRedeemSuccess = onRedeemSuccess || null;
+    this.running = true;
+    init.logger.info("Redeemer 已启动");
+    this.intervalId = setPromiseInterval__default.default(async () => {
+      await this.runOnce();
+    }, BASE_INTERVAL);
+  }
+  /**
+   * 启动定时任务
+   */
+  startInterval() {
+    if (!this.running || this.intervalId !== void 0) {
+      return;
+    }
+    this.intervalId = setPromiseInterval__default.default(async () => {
+      await this.runOnce();
+    }, BASE_INTERVAL);
+  }
+  /**
+   * 暂停定时任务，延迟后重启（用于 429 限流）
+   */
+  pauseAndRestart(delayMs) {
+    if (this.intervalId !== void 0) {
+      setPromiseInterval.clearPromiseInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+    this.delayTimeoutId = setTimeout(() => {
+      this.delayTimeoutId = void 0;
+      if (this.running) {
+        this.runOnce().finally(() => {
+          this.startInterval();
+        });
+      }
+    }, delayMs);
+  }
+  /**
+   * 停止 Redeemer
+   */
+  stop() {
+    if (this.intervalId !== void 0) {
+      setPromiseInterval.clearPromiseInterval(this.intervalId);
+      this.intervalId = void 0;
+    }
+    if (this.delayTimeoutId) {
+      clearTimeout(this.delayTimeoutId);
+      this.delayTimeoutId = void 0;
+    }
+    this.running = false;
+    init.logger.info("Redeemer 已停止");
+  }
+  /**
+   * 获取可 Redeem 的仓位
+   */
+  async fetchRedeemablePositions() {
+    const url = new URL(`${DATA_API_HOST}/positions`);
+    url.searchParams.set("user", this.funderAddress);
+    url.searchParams.set("redeemable", "true");
+    url.searchParams.set("sizeThreshold", ".1");
+    url.searchParams.set("sortBy", "CURRENT");
+    url.searchParams.set("sortDirection", "DESC");
+    url.searchParams.set("limit", "10");
+    const response = await fetch(url.toString());
+    if (!response.ok) {
+      throw new Error(`获取仓位失败: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    const positions = [];
+    for (const item of data) {
+      const currentValue = item._currentValue || item.currentValue || 0;
+      if (currentValue > 0) {
+        positions.push({
+          conditionId: item.conditionId,
+          assetId: item.asset,
+          currentValue
+        });
+      } else {
+        break;
+      }
+    }
+    return positions;
+  }
+  /**
+   * 执行一轮 Redeem
+   */
+  async runOnce() {
+    if (!this.running || !this.redeemFn) {
+      return;
+    }
+    let positions;
+    try {
+      positions = await this.fetchRedeemablePositions();
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      if (errorMsg.includes("429") || errorMsg.includes("Too Many Requests")) {
+        const resetSeconds = this.parseResetSeconds(errorMsg);
+        init.logger.warning(`获取仓位限流，${resetSeconds} 秒后重试`);
+        notifier.warning("API 限流", `获取仓位限流，${resetSeconds} 秒后重试`);
+        this.pauseAndRestart((resetSeconds + 60) * 1e3);
+        return;
+      }
+      init.logger.error(`获取仓位失败: ${errorMsg}`);
+      return;
+    }
+    init.logger.info(`autoRedeem: ${positions.length} 个可 Redeem 仓位`);
+    for (const position of positions) {
+      let record = this.records.get(position.conditionId);
+      if (!record) {
+        record = {
+          position,
+          success: false,
+          failedCount: 0,
+          matchedCount: 0
+        };
+        this.records.set(position.conditionId, record);
+      }
+      record.position = position;
+      if (record.success) {
+        record.matchedCount++;
+        if (record.matchedCount >= MAX_MATCH_TIMES) {
+          init.logger.error(
+            `Redeem 失败: 执行成功但仍存在 ${record.matchedCount} 次 (conditionId: ${position.conditionId.slice(0, 10)}...)`
+          );
+          notifier.error(
+            "Redeem 失败",
+            `执行成功但仓位仍存在 ${record.matchedCount} 次
+conditionId: ${position.conditionId}
+价值: ${position.currentValue} USDC`
+          );
+        }
+      } else if (record.failedCount < MAX_MATCH_TIMES) {
+        try {
+          const txHash = await this.redeemFn(position.conditionId);
+          record.success = true;
+          init.logger.info(`Redeem 交易已提交: ${txHash}`);
+        } catch (error) {
+          record.failedCount++;
+          const errorMsg = error instanceof Error ? error.message : String(error);
+          if (errorMsg.includes("429") || errorMsg.includes("Too Many Requests")) {
+            const resetSeconds = this.parseResetSeconds(errorMsg);
+            init.logger.warning(`Redeem 限流，${resetSeconds} 秒后重试`);
+            notifier.warning("Redeem 限流", `${resetSeconds} 秒后重试`);
+            this.pauseAndRestart((resetSeconds + 60) * 1e3);
+            return;
+          }
+          init.logger.error(`Redeem 异常 (第 ${record.failedCount} 次): ${errorMsg}`);
+          if (record.failedCount >= MAX_MATCH_TIMES) {
+            notifier.error(
+              "Redeem 异常",
+              `重试 ${record.failedCount} 次仍失败
+conditionId: ${position.conditionId}
+错误: ${errorMsg}`
+            );
+          }
+        }
+      }
+    }
+    const successList = [];
+    for (const [conditionId, record] of this.records.entries()) {
+      const stillExists = positions.some((p) => p.conditionId === conditionId);
+      if (!stillExists) {
+        successList.push(
+          `${record.position.assetId.slice(0, 10)}... (${record.position.currentValue} USDC, matched: ${record.matchedCount})`
+        );
+        this.records.delete(conditionId);
+      }
+    }
+    if (successList.length > 0) {
+      init.logger.success(`Redeem 成功: ${successList.length} 个`);
+      for (const item of successList) {
+        init.logger.line("", `- ${item}`);
+      }
+      this.onRedeemSuccess?.();
+    }
+    init.logger.info(`redeemedRecord: ${this.records.size} 个待确认`);
+  }
+  /**
+   * 解析 429 错误中的 resets in 时间
+   */
+  parseResetSeconds(errorMsg) {
+    const match = errorMsg.match(/resets in (\d+) seconds/);
+    return match ? parseInt(match[1]) : 3600;
+  }
+}
+const POSITION_POLL_INTERVAL = 5e3;
+const POSITION_MATCH_THRESHOLD = 0.99;
+class Trader {
+  client;
+  relayClient;
+  assetFilter;
+  balanceCache;
+  orderWatcher;
+  redeemer;
+  config = null;
+  initialized = false;
+  constructor() {
+    this.client = new ClobClientWrapper();
+    this.relayClient = new RelayClientWrapper();
+    this.assetFilter = new AssetFilter();
+    this.balanceCache = new BalanceCache();
+    this.orderWatcher = new OrderWatcher();
+    this.redeemer = new Redeemer();
+  }
+  /**
+   * 初始化交易模块
+   */
+  async init(config) {
+    if (this.initialized) {
+      return;
+    }
+    this.config = config;
+    if (!config.polymarket?.privateKey) {
+      init.logger.warning("未配置 PolyMarket 私钥，交易功能已禁用");
+      return;
+    }
+    await this.client.init({
+      privateKey: config.polymarket.privateKey,
+      funderAddress: config.polymarket.funderAddress,
+      builderCreds: config.polymarket.builderCreds
+    });
+    if (config.polymarket.builderCreds) {
+      this.relayClient.init({
+        privateKey: config.polymarket.privateKey,
+        builderCreds: config.polymarket.builderCreds
+      });
+    } else {
+      init.logger.warning("未配置 builderCreds，Redeem 功能已禁用");
+    }
+    this.initialized = true;
+    init.logger.success("交易模块初始化完成");
+  }
+  /**
+   * 启动 Redeemer（在 Telegram listener 就绪后调用）
+   */
+  startRedeemer() {
+    if (!this.config?.polymarket?.builderCreds) {
+      return;
+    }
+    this.redeemer.start(
+      this.executeRedeem.bind(this),
+      this.config.polymarket.funderAddress || "",
+      () => this.balanceCache.invalidate()
+    );
+  }
+  /**
+   * 检查是否已初始化
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * 处理预测信号
+   */
+  async executeSignal(signal) {
+    if (!this.initialized || !this.config) {
+      init.logger.warning("交易模块未初始化，跳过信号");
+      return;
+    }
+    const { metadata } = signal;
+    const { assetId, endTime, outcome } = metadata;
+    init.logger.section(`处理信号: ${outcome} (${metadata.eventId})`);
+    if (!this.assetFilter.canTrade(assetId, endTime)) {
+      init.logger.warning(`assetId 已交易，跳过: ${assetId.slice(0, 10)}...`);
+      return;
+    }
+    const tradingConfig = this.config.trading;
+    const amountMode = tradingConfig?.amountMode || "fixed";
+    const amountValue = tradingConfig?.amountValue || 1;
+    const buyPrice = tradingConfig?.buyPrice || 0.98;
+    const sellPrice = tradingConfig?.sellPrice || 1;
+    let balance;
+    try {
+      balance = await this.balanceCache.getBalance(
+        endTime,
+        () => this.client.getBalance()
+      );
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      init.logger.error(`获取余额失败: ${errorMsg}`);
+      return;
+    }
+    if (amountMode === "fixed" && balance < amountValue) {
+      const msg = `余额不足: ${balance} USDC < ${amountValue} USDC`;
+      init.logger.warning(msg);
+      notifier.warning("余额不足", `当前余额: ${balance} USDC
+需要金额: ${amountValue} USDC`);
+      return;
+    }
+    if (amountMode === "percentage" && balance <= 0) {
+      init.logger.warning(`余额为零: ${balance} USDC`);
+      notifier.warning("余额为零", `当前余额: ${balance} USDC`);
+      return;
+    }
+    const orderAmount = amountMode === "fixed" ? amountValue : balance * amountValue;
+    const size = orderAmount / buyPrice;
+    init.logger.info(`下单金额: ${orderAmount.toFixed(2)} USDC`);
+    init.logger.info(`下单价格: ${buyPrice}`);
+    init.logger.info(`下单数量: ${size.toFixed(4)}`);
+    const buyResult = await this.client.createBuyOrder(assetId, buyPrice, size);
+    if (!buyResult.success) {
+      init.logger.error(`买单失败: ${buyResult.errorMsg}`);
+      notifier.error("买单失败", `事件: ${metadata.eventId}
+错误: ${buyResult.errorMsg}`);
+      return;
+    }
+    this.assetFilter.markTraded(assetId, endTime);
+    this.watchAndHandle(buyResult.orderId, assetId, sellPrice, endTime, metadata.eventId);
+  }
+  /**
+   * 异步监控订单并处理结果（不阻塞主流程）
+   */
+  async watchAndHandle(orderId, assetId, sellPrice, endTime, eventId) {
+    try {
+      const watchResult = await this.orderWatcher.watch(
+        orderId,
+        endTime,
+        (id) => this.client.getOrder(id)
+      );
+      await this.handleBuyResult(watchResult, orderId, assetId, sellPrice, endTime);
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      init.logger.error(`订单监控异常: ${errorMsg}`);
+      notifier.error("订单监控异常", `事件: ${eventId}
+订单: ${orderId}
+错误: ${errorMsg}`);
+    }
+  }
+  /**
+   * 处理买单结果
+   */
+  async handleBuyResult(result, orderId, assetId, sellPrice, endTime) {
+    switch (result.status) {
+      case "MATCHED":
+      case "CONFIRMED":
+        const filledSize = result.filledSize || 0;
+        init.logger.success(`买单成交: ${filledSize.toFixed(4)} 份`);
+        if (sellPrice < 1) {
+          this.waitAndSell(assetId, filledSize, sellPrice, endTime);
+        } else {
+          init.logger.info("sellPrice = 1，等待 Redeem");
+        }
+        break;
+      case "CANCELLED":
+        init.logger.info("订单已取消（市场可能已结束）");
+        break;
+      case "FAILED":
+        init.logger.error("订单执行失败");
+        notifier.error("订单执行失败", `订单 ID: ${orderId}`);
+        break;
+      case "TIMEOUT":
+        init.logger.warning("订单超时，尝试取消");
+        notifier.warning("订单超时", `订单 ID: ${orderId}
+已尝试取消`);
+        await this.client.cancelOrder(orderId);
+        break;
+    }
+  }
+  /**
+   * 等待仓位同步后执行卖出（独立轮询）
+   */
+  async waitAndSell(assetId, expectedSize, sellPrice, endTime) {
+    const shortId = assetId.substring(0, 10) + "...";
+    const threshold = expectedSize * POSITION_MATCH_THRESHOLD;
+    init.logger.info(`等待仓位同步: ${shortId}，预期 >= ${threshold.toFixed(4)}`);
+    while (true) {
+      const now = Date.now();
+      if (now >= endTime) {
+        init.logger.warning(`仓位同步超时: ${shortId}，等待 Redeem`);
+        this.notifyRedeemFallback(assetId, expectedSize);
+        return;
+      }
+      try {
+        const positionSize = await this.client.getPositionSize(assetId);
+        if (positionSize >= threshold) {
+          init.logger.info(`仓位已同步: ${shortId}，数量: ${positionSize.toFixed(4)}`);
+          await this.executeSellOrder(assetId, sellPrice, positionSize);
+          return;
+        }
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        init.logger.warning(`获取仓位失败: ${shortId}，${errorMsg}`);
+      }
+      await this.delay(POSITION_POLL_INTERVAL);
+    }
+  }
+  /**
+   * 通知需要 Redeem 兜底
+   */
+  notifyRedeemFallback(assetId, expectedSize) {
+    if (!this.relayClient.isInitialized()) {
+      const msg = "仓位同步超时且 Redeem 不可用";
+      init.logger.warning(msg);
+      notifier.warning(
+        msg,
+        `Asset: ${assetId.substring(0, 20)}...
+预期数量: ${expectedSize.toFixed(4)}
+请手动处理或配置 Builder API`
+      );
+    }
+  }
+  /**
+   * 延迟
+   */
+  delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  /**
+   * 执行卖单
+   */
+  async executeSellOrder(assetId, price, size) {
+    init.logger.info(`创建卖单: ${size.toFixed(4)} 份 @ ${price}`);
+    const sellResult = await this.client.createSellOrder(assetId, price, size);
+    if (sellResult.success) {
+      init.logger.success(`卖单已创建: ${sellResult.orderId}`);
+    } else {
+      init.logger.error(`卖单创建失败: ${sellResult.errorMsg}`);
+      notifier.error("卖单创建失败", `错误: ${sellResult.errorMsg}`);
+    }
+  }
+  /**
+   * 执行 Redeem（供 Redeemer 调用）
+   */
+  async executeRedeem(conditionId) {
+    if (!this.relayClient.isInitialized()) {
+      throw new Error("RelayClient 未初始化");
+    }
+    return await this.relayClient.redeem(conditionId);
+  }
+  /**
+   * 停止交易模块
+   */
+  async shutdown() {
+    this.redeemer.stop();
+    init.logger.info("交易模块已停止");
+  }
+}
+const trader = new Trader();
+async function main() {
+  init.logger.init();
+  init.logger.section("PolyMarket 跟单机器人");
+  const config = await init.ensureConfig();
+  notifier.init(config.telegram.botToken, config.telegram.adminChatId);
+  const autoTradeEnabled = init.canAutoTrade(config);
+  if (!autoTradeEnabled) {
+    init.logger.warning("自动跟单功能未启用");
+    if (!config.polymarket?.privateKey) {
+      init.logger.line("", "- PolyMarket 配置不完整（缺少私钥）");
+    }
+    if (!config.trading?.amountMode || !config.trading?.amountValue || !config.trading?.buyPrice || !config.trading?.sellPrice) {
+      init.logger.line("", "- 交易配置不完整");
+    }
+    init.logger.line("", "当前不会跟单任何预测消息");
+  } else {
+    try {
+      await trader.init(config);
+      if (config.trading?.sellPrice === 1 && !config.polymarket?.builderCreds) {
+        init.logger.warning("sellPrice = 1 但未配置 builderCreds，持仓将无法自动结算");
+        init.logger.line("", "请配置 Builder API 凭证，或手动 claim");
+      }
+    } catch (error) {
+      const errorMsg = error instanceof Error ? error.message : String(error);
+      init.logger.error(`交易模块初始化失败: ${errorMsg}`);
+      init.logger.line("", "当前不会跟单任何预测消息");
+    }
+  }
+  const listener = new init.TelegramListener(
+    config.telegram.botToken,
+    config.telegram.targetChatIds || []
+  );
+  listener.onChatIdsChanged(async (chatIds) => {
+    const telegram = init.configLocal.getItem("telegram");
+    if (!telegram) {
+      init.logger.error("警告: 无法保存频道 ID，telegram 配置不存在");
+      return;
+    }
+    telegram.targetChatIds = chatIds.length > 0 ? chatIds : void 0;
+    init.configLocal.setItem("telegram", telegram);
+    init.logger.line("💾", `已保存频道 ID 列表: ${chatIds.length} 个频道`);
+  });
+  listener.onSignal(async (signal) => {
+    init.logger.info(`📨 收到预测信号:`);
+    init.logger.line("", `事件: ${signal.metadata.eventId}`);
+    init.logger.line("", `方向: ${signal.metadata.outcome === "Up" ? "上涨 📈" : "下跌 📉"}`);
+    init.logger.line("", `Asset: ${signal.metadata.assetId}`);
+    init.logger.line("", `结束时间: ${new Date(signal.metadata.endTime).toLocaleString()}`);
+    if (trader.isInitialized()) {
+      try {
+        await trader.executeSignal(signal);
+      } catch (error) {
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        init.logger.error(`交易执行失败: ${errorMsg}`);
+      }
+    }
+  });
+  let isShuttingDown = false;
+  const shutdown = () => {
+    if (isShuttingDown) return;
+    isShuttingDown = true;
+    process.removeAllListeners("SIGINT");
+    process.removeAllListeners("SIGTERM");
+    init.logger.blank();
+    init.logger.info("正在退出...");
+    setTimeout(() => {
+      process.exit(0);
+    }, 1e3);
+    Promise.all([
+      trader.shutdown(),
+      listener.stop()
+    ]).finally(() => {
+      process.exit(0);
+    });
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+  await listener.start(() => {
+    if (trader.isInitialized()) {
+      trader.startRedeemer();
+    }
+  });
+}
+main().catch((error) => {
+  init.logger.error("程序运行出错:", error);
+  process.exit(1);
+});