polycopy 0.1.7 → 0.1.9

package/dist/index.js

@@ -1,6 +1,8 @@
 "use strict";
-const init = require("./init-Bs-N_AZi.js");
+const processLock = require("./process-lock-y_yjnMCr.js");
 const grammy = require("grammy");
+const log4js = require("log4js");
+const path = require("path");
 const wallet = require("@ethersproject/wallet");
 const clobClient = require("@polymarket/clob-client");
 const builderSigningSdk = require("@polymarket/builder-signing-sdk");
@@ -11,7 +13,6 @@ const builderRelayerClient = require("@polymarket/builder-relayer-client");
 const setPromiseInterval = require("set-promise-interval");
 const child_process = require("child_process");
 const fs = require("fs");
-const paths = require("./paths-CEjGES8j.js");
 const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
 function _interopNamespace(e) {
   if (e && e.__esModule) return e;
@@ -30,8 +31,114 @@ function _interopNamespace(e) {
   n.default = e;
   return Object.freeze(n);
 }
+const log4js__default = /* @__PURE__ */ _interopDefault(log4js);
+const path__namespace = /* @__PURE__ */ _interopNamespace(path);
 const setPromiseInterval__default = /* @__PURE__ */ _interopDefault(setPromiseInterval);
 const fs__namespace = /* @__PURE__ */ _interopNamespace(fs);
+const LOG_FILE = path__namespace.join(processLock.LOGS_DIR, "polycopy.log");
+path__namespace.join(processLock.LOGS_DIR, "polycopy");
+log4js__default.default.configure({
+  appenders: {
+    file: {
+      type: "dateFile",
+      filename: LOG_FILE,
+      pattern: "yyyy-MM-dd",
+      alwaysIncludePattern: true,
+      compress: false,
+      keepFileExt: true,
+      maxLogSize: 2 * 1024 * 1024,
+      backups: 10,
+      layout: { type: "pattern", pattern: "[%d{yyyy-MM-dd hh:mm:ss}] %m" }
+    },
+    stdout: {
+      type: "stdout",
+      layout: { type: "pattern", pattern: "[%d{yyyy-MM-dd hh:mm:ss}] %m" }
+    }
+  },
+  categories: {
+    default: { appenders: ["stdout", "file"], level: "info" }
+  }
+});
+const log4jsLogger = log4js__default.default.getLogger("polycopy");
+const formatMessage = (message, args) => args.length > 0 ? `${message} ${args.join(" ")}` : message;
+class Logger {
+  initialized = false;
+  /**
+   * 初始化日志模块（输出日志路径信息）
+   */
+  init() {
+    if (this.initialized) return;
+    this.initialized = true;
+    console.log(`
+📁 日志目录: ${processLock.LOGS_DIR}`);
+  }
+  /**
+   * 输出信息日志（前后自动添加空行）
+   */
+  info(message, ...args) {
+    log4jsLogger.info(formatMessage(message, args));
+  }
+  /**
+   * 输出成功日志（前后自动添加空行）
+   */
+  success(message, ...args) {
+    log4jsLogger.info(`✅ ${formatMessage(message, args)}`);
+  }
+  /**
+   * 输出警告日志（前后自动添加空行）
+   */
+  warning(message, ...args) {
+    log4jsLogger.warn(`⚠️  ${formatMessage(message, args)}`);
+  }
+  /**
+   * 输出错误日志（前后自动添加空行）
+   */
+  error(message, ...args) {
+    log4jsLogger.error(`❌ ${formatMessage(message, args)}`);
+  }
+  /**
+   * 输出章节标题（前后自动添加空行）
+   */
+  section(title) {
+    log4jsLogger.info(`=== ${title} ===`);
+  }
+  /**
+   * 输出列表项（不添加空行，用于连续输出）
+   */
+  item(message, indent = 0) {
+    const indentStr = "  ".repeat(indent);
+    const formatted = `${indentStr}${message}`;
+    log4jsLogger.info(formatted);
+  }
+  /**
+   * 输出普通文本（不添加空行，用于连续输出）
+   */
+  text(message, ...args) {
+    log4jsLogger.info(formatMessage(message, args));
+  }
+  /**
+   * 输出空行
+   */
+  blank() {
+    console.log("");
+  }
+  /**
+   * 输出带前缀的信息（不添加空行）
+   * 用于在同一组日志中输出多行信息
+   */
+  line(prefix, message, ...args) {
+    const formatted = args.length > 0 ? `  ${prefix} ${message} ${args.join(" ")}` : `  ${prefix} ${message}`;
+    log4jsLogger.info(formatted);
+  }
+  /**
+   * 刷新日志输出（用于进程退出前）
+   */
+  async flush(timeoutMs = 1e3) {
+    await log4js__default.default.shutdown();
+    await new Promise((resolve) => setTimeout(resolve, timeoutMs));
+  }
+}
+const logger = new Logger();
 function parseSignalMetadata(messageText) {
   const match = messageText.match(/🤖\s*({.*})/s);
   if (!match) {
@@ -41,7 +148,7 @@ function parseSignalMetadata(messageText) {
     const jsonStr = match[1];
     const metadata = JSON.parse(jsonStr);
     if (!metadata.eventId || !metadata.assetId || !metadata.outcome || !metadata.endTime) {
-      init.logger.error("解析失败: 缺少必需字段", {
+      logger.error("解析失败: 缺少必需字段", {
         hasEventId: !!metadata.eventId,
         hasAssetId: !!metadata.assetId,
         hasOutcome: !!metadata.outcome,
@@ -50,14 +157,14 @@ function parseSignalMetadata(messageText) {
       return null;
     }
     if (metadata.outcome !== "Up" && metadata.outcome !== "Down") {
-      init.logger.error("解析失败: outcome 值无效", {
+      logger.error("解析失败: outcome 值无效", {
         outcome: metadata.outcome,
         expected: "Up 或 Down"
       });
       return null;
     }
     if (typeof metadata.endTime !== "number" || metadata.endTime <= 0) {
-      init.logger.error("解析失败: endTime 值无效", {
+      logger.error("解析失败: endTime 值无效", {
         endTime: metadata.endTime,
         expected: "毫秒级时间戳"
       });
@@ -65,9 +172,9 @@ function parseSignalMetadata(messageText) {
     }
     return metadata;
   } catch (error) {
-    init.logger.error("解析信号元数据失败:", error);
+    logger.error("解析信号元数据失败:", error);
     if (error instanceof Error) {
-      init.logger.line("", `错误详情: ${error.message}`);
+      logger.line("", `错误详情: ${error.message}`);
     }
     return null;
   }
@@ -97,12 +204,12 @@ class TelegramListener {
       await this.handleMyChatMemberUpdate(ctx);
     });
     this.bot.catch((err) => {
-      init.logger.error("Telegram Bot 错误:", err);
+      logger.error("Telegram Bot 错误:", err);
       if (err.error) {
-        init.logger.line("", `错误详情: ${err.error}`);
+        logger.line("", `错误详情: ${err.error}`);
       }
       if (err.ctx) {
-        init.logger.line("", `上下文信息:`, {
+        logger.line("", `上下文信息:`, {
           chatId: err.ctx.chat?.id,
           messageId: err.ctx.message?.message_id
         });
@@ -169,28 +276,28 @@ class TelegramListener {
           reason = "需要管理员权限才能监听";
         }
       }
-      init.logger.info(`📢 频道状态更新: ${chatTitle}`);
-      init.logger.line("", action);
-      init.logger.line(
+      logger.info(`📢 频道状态更新: ${chatTitle}`);
+      logger.line("", action);
+      logger.line(
         "",
         `当前状态: ${canListen ? "✅ 可监听预测消息" : "❌ 无法监听预测消息"}`
       );
       if (reason) {
-        init.logger.line("", `原因: ${reason}`);
+        logger.line("", `原因: ${reason}`);
       }
     }
     if (isAdmin && !this.targetChatIds.has(chatId)) {
       this.targetChatIds.add(chatId);
       await this.saveChatIds();
-      init.logger.line("📡", "已自动开始监听此频道");
+      logger.line("📡", "已自动开始监听此频道");
     }
     if ((isRemoved || !isAdmin) && this.targetChatIds.has(chatId)) {
       this.targetChatIds.delete(chatId);
       await this.saveChatIds();
       if (isRemoved) {
-        init.logger.line("⏹️", "已停止监听此频道（Bot 已被移除）");
+        logger.line("⏹️", "已停止监听此频道（Bot 已被移除）");
       } else {
-        init.logger.line("⏹️", "已停止监听此频道（Bot 不再是管理员）");
+        logger.line("⏹️", "已停止监听此频道（Bot 不再是管理员）");
       }
     }
   }
@@ -205,7 +312,7 @@ class TelegramListener {
       const chatIds = Array.from(this.targetChatIds);
       await this.onChatIdsChangedCallback(chatIds);
     } catch (error) {
-      init.logger.error("保存频道 ID 列表时出错:", error);
+      logger.error("保存频道 ID 列表时出错:", error);
     }
   }
   /**
@@ -234,9 +341,9 @@ class TelegramListener {
     }
     if (isChannel && !this.targetChatIds.has(chatId)) {
       this.targetChatIds.add(chatId);
-      init.logger.info(`➕ 自动添加频道到监听列表: ${chatTitle} (ID: ${chatId})`);
+      logger.info(`➕ 自动添加频道到监听列表: ${chatTitle} (ID: ${chatId})`);
       await this.saveChatIds();
-      init.logger.line("💾", "已保存到配置文件");
+      logger.line("💾", "已保存到配置文件");
     }
     if (!isChannel) {
       return;
@@ -250,13 +357,13 @@ class TelegramListener {
         const emojiIndex = messageText.indexOf("🤖");
         const jsonStart = emojiIndex + 1;
         const jsonEnd = Math.min(jsonStart + 200, messageText.length);
-        init.logger.warning(`解析预测消息失败:`);
-        init.logger.line("", `频道 ID: ${chatId}`);
-        init.logger.line(
+        logger.warning(`解析预测消息失败:`);
+        logger.line("", `频道 ID: ${chatId}`);
+        logger.line(
           "",
           `消息片段: ${messageText.substring(emojiIndex, jsonEnd)}${messageText.length > jsonEnd ? "..." : ""}`
         );
-        init.logger.line("", "提示: 请检查消息格式是否正确");
+        logger.line("", "提示: 请检查消息格式是否正确");
       }
       return;
     }
@@ -271,7 +378,7 @@ class TelegramListener {
       try {
         await this.onSignalCallback(parsedSignal);
       } catch (error) {
-        init.logger.error("处理信号时出错:", error);
+        logger.error("处理信号时出错:", error);
       }
     }
   }
@@ -299,15 +406,15 @@ class TelegramListener {
    */
   async start(onReady) {
     try {
-      init.logger.info("正在启动 Bot...");
+      logger.info("正在启动 Bot...");
       const botInfo = await this.bot.api.getMe();
       const botId = botInfo.id;
-      init.logger.info(`Bot 信息: @${botInfo.username} (ID: ${botId})`);
+      logger.info(`Bot 信息: @${botInfo.username} (ID: ${botId})`);
       await this.checkAndDisplayChannels(botId);
       if (onReady) {
         await onReady();
       }
-      init.logger.info("开始监听预测消息...");
+      logger.info("开始监听预测消息...");
       await this.bot.start({
         drop_pending_updates: true,
         allowed_updates: [
@@ -317,7 +424,7 @@ class TelegramListener {
         ]
       });
     } catch (error) {
-      init.logger.error("启动 Bot 失败:", error);
+      logger.error("启动 Bot 失败:", error);
       throw error;
     }
   }
@@ -328,14 +435,14 @@ class TelegramListener {
   async checkAndDisplayChannels(botId) {
     const chatIds = Array.from(this.targetChatIds);
     if (chatIds.length === 0) {
-      init.logger.info(`📋 当前没有保存的频道配置`);
-      init.logger.line(
+      logger.info(`📋 当前没有保存的频道配置`);
+      logger.line(
         "",
         "提示: 当 Bot 被添加为频道管理员时，会自动添加到监听列表"
       );
       return;
     }
-    init.logger.info(`📋 检查 Bot 所在的频道:`);
+    logger.info(`📋 检查 Bot 所在的频道:`);
     const validChannels = [];
     const invalidChannels = [];
     for (const chatId of chatIds) {
@@ -367,43 +474,43 @@ class TelegramListener {
       const adminChannels = validChannels.filter((c) => c.isAdmin);
       const nonAdminChannels = validChannels.filter((c) => !c.isAdmin);
       if (adminChannels.length > 0) {
-        init.logger.info(`📡 可监听频道 (${adminChannels.length} 个):`);
+        logger.info(`📡 可监听频道 (${adminChannels.length} 个):`);
         adminChannels.forEach((channel, index) => {
-          init.logger.item(
+          logger.item(
             `${index + 1}. ${channel.title} (ID: ${channel.id}) 👑 管理员`,
             1
           );
         });
       }
       if (nonAdminChannels.length > 0) {
-        init.logger.warning(`无法监听频道 (${nonAdminChannels.length} 个):`);
+        logger.warning(`无法监听频道 (${nonAdminChannels.length} 个):`);
         nonAdminChannels.forEach((channel, index) => {
-          init.logger.item(`${index + 1}. ${channel.title}`, 1);
-          init.logger.item(`ID: ${channel.id}`, 2);
-          init.logger.item(`状态: 🚫 非管理员（无法接收预测消息）`, 2);
-          init.logger.item(`原因: 需要管理员权限才能监听`, 2);
+          logger.item(`${index + 1}. ${channel.title}`, 1);
+          logger.item(`ID: ${channel.id}`, 2);
+          logger.item(`状态: 🚫 非管理员（无法接收预测消息）`, 2);
+          logger.item(`原因: 需要管理员权限才能监听`, 2);
         });
         nonAdminChannels.forEach((channel) => {
           this.targetChatIds.delete(channel.id);
         });
         if (nonAdminChannels.length > 0) {
           await this.saveChatIds();
-          init.logger.line("💾", "已清理无法监听的频道并保存配置");
+          logger.line("💾", "已清理无法监听的频道并保存配置");
         }
       }
     }
     if (invalidChannels.length > 0) {
-      init.logger.error(`无效频道 (${invalidChannels.length} 个):`);
+      logger.error(`无效频道 (${invalidChannels.length} 个):`);
       invalidChannels.forEach((channel, index) => {
-        init.logger.item(`${index + 1}. ID: ${channel.id}`, 1);
-        init.logger.item(`原因: ${channel.reason}`, 2);
+        logger.item(`${index + 1}. ID: ${channel.id}`, 1);
+        logger.item(`原因: ${channel.reason}`, 2);
       });
       invalidChannels.forEach((channel) => {
         this.targetChatIds.delete(channel.id);
       });
       if (invalidChannels.length > 0) {
         await this.saveChatIds();
-        init.logger.line("💾", "已清理无效频道并保存配置");
+        logger.line("💾", "已清理无效频道并保存配置");
       }
     }
   }
@@ -439,13 +546,13 @@ class TelegramService {
     this.bot = new grammy.Bot(botToken);
     this.listener = new TelegramListener(this.bot, targetChatIds);
     if (!adminChatId) {
-      init.logger.warning("未配置管理员 Chat ID，通知功能已禁用");
+      logger.warning("未配置管理员 Chat ID，通知功能已禁用");
       this.notifyEnabled = false;
       return;
     }
     this.adminChatId = adminChatId;
     this.notifyEnabled = true;
-    init.logger.info("管理员通知已启用");
+    logger.info("管理员通知已启用");
   }
   /**
    * 设置频道 ID 列表变更回调
@@ -511,7 +618,7 @@ ${details}` : message;
       });
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      init.logger.error(`发送通知失败: ${errorMsg}`);
+      logger.error(`发送通知失败: ${errorMsg}`);
     }
   }
 }
@@ -528,11 +635,11 @@ class ClobClientWrapper {
       return;
     }
     const wallet$1 = new wallet.Wallet(config.privateKey);
-    init.logger.info(`钱包地址: ${wallet$1.address}`);
+    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 凭证已获取");
+    logger.success("API 凭证已获取");
     let builderConfig;
     if (config.builderCreds) {
       builderConfig = new builderSigningSdk.BuilderConfig({
@@ -556,7 +663,7 @@ class ClobClientWrapper {
     );
     this.patchClient(this.client);
     this.initialized = true;
-    init.logger.success("ClobClient 初始化完成");
+    logger.success("ClobClient 初始化完成");
   }
   /**
    * 魔法操作：clob-client 请求出错不抛异常，只返回 { error: ... }
@@ -632,13 +739,13 @@ class ClobClientWrapper {
         clobClient.OrderType.GTC
       );
       if (response.success) {
-        init.logger.success(`买单已提交: ${response.orderID}`);
+        logger.success(`买单已提交: ${response.orderID}`);
         return {
           success: true,
           orderId: response.orderID
         };
       } else {
-        init.logger.error(`买单提交失败: ${response.errorMsg}`);
+        logger.error(`买单提交失败: ${response.errorMsg}`);
         return {
           success: false,
           orderId: "",
@@ -647,7 +754,7 @@ class ClobClientWrapper {
       }
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      init.logger.error(`买单提交失败: ${errorMsg}`);
+      logger.error(`买单提交失败: ${errorMsg}`);
       return {
         success: false,
         orderId: "",
@@ -709,11 +816,11 @@ class ClobClientWrapper {
     const client = this.ensureInitialized();
     try {
       await client.cancelOrder({ orderID: orderId });
-      init.logger.info(`订单已取消: ${orderId}`);
+      logger.info(`订单已取消: ${orderId}`);
       return true;
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      init.logger.error(`取消订单失败: ${errorMsg}`);
+      logger.error(`取消订单失败: ${errorMsg}`);
       return false;
     }
   }
@@ -759,7 +866,7 @@ class RelayClientWrapper {
       builderRelayerClient.RelayerTxType.SAFE
     );
     this.initialized = true;
-    init.logger.success("RelayClient 初始化完成");
+    logger.success("RelayClient 初始化完成");
   }
   /**
    * 检查是否已初始化
@@ -767,15 +874,7 @@ class RelayClientWrapper {
   isInitialized() {
     return this.initialized;
   }
-  /**
-   * 执行 Redeem
-   * @param conditionId 条件 ID
-   * @returns 交易哈希
-   */
-  async redeem(conditionId) {
-    if (!this.relayClient || !this.initialized) {
-      throw new Error("RelayClient 未初始化");
-    }
+  buildRedeemTransaction(conditionId) {
     const calldata = viem.encodeFunctionData({
       abi: [
         {
@@ -794,14 +893,27 @@ class RelayClientWrapper {
       functionName: "redeemPositions",
       args: [USDC_ADDRESS, viem.zeroHash, conditionId, [1n, 2n]]
     });
-    const tx = {
+    return {
       to: CTF_ADDRESS,
       value: "0",
       data: calldata
     };
+  }
+  /**
+   * 批量执行 Redeem
+   * @param conditionIds 条件 ID 列表
+   * @returns 交易哈希
+   */
+  async redeemBatch(conditionIds) {
+    if (!this.relayClient || !this.initialized) {
+      throw new Error("RelayClient 未初始化");
+    }
+    const transactions = conditionIds.map(
+      (conditionId) => this.buildRedeemTransaction(conditionId)
+    );
     const response = await this.relayClient.execute(
-      [tx],
-      "Polymarket redeem positions"
+      transactions,
+      `Polymarket redeem positions (${transactions.length})`
     );
     const result = await response.wait();
     if (!result) {
@@ -811,6 +923,14 @@ class RelayClientWrapper {
     }
     return result.transactionHash;
   }
+  /**
+   * 执行 Redeem（兼容单个）
+   * @param conditionId 条件 ID
+   * @returns 交易哈希
+   */
+  async redeem(conditionId) {
+    return this.redeemBatch([conditionId]);
+  }
 }
 class AssetFilter {
   // endTime -> Set<assetId>
@@ -838,7 +958,7 @@ class AssetFilter {
       this.traded.set(endTime, /* @__PURE__ */ new Set());
     }
     this.traded.get(endTime).add(assetId);
-    init.logger.info(`已标记 assetId: ${assetId.slice(0, 10)}...`);
+    logger.info(`已标记 assetId: ${assetId.slice(0, 10)}...`);
   }
   /**
    * 清理过期记录
@@ -852,7 +972,7 @@ class AssetFilter {
       }
     }
     if (cleanedCount > 0) {
-      init.logger.info(`已清理 ${cleanedCount} 个过期周期的交易记录`);
+      logger.info(`已清理 ${cleanedCount} 个过期周期的交易记录`);
     }
   }
 }
@@ -872,12 +992,12 @@ class BalanceCache {
     }
     if (this.cache.has(endTime)) {
       const cached = this.cache.get(endTime);
-      init.logger.info(`使用缓存余额: ${cached} USDC`);
+      logger.info(`使用缓存余额: ${cached} USDC`);
       return cached;
     }
     const balance = await fetchFn();
     this.cache.set(endTime, balance);
-    init.logger.info(`获取当前余额: ${balance} USDC`);
+    logger.info(`获取当前余额: ${balance} USDC`);
     return balance;
   }
   /**
@@ -886,7 +1006,7 @@ class BalanceCache {
   invalidate() {
     if (this.cache.size > 0) {
       this.cache.clear();
-      init.logger.info("余额缓存已清除");
+      logger.info("余额缓存已清除");
     }
   }
   /**
@@ -901,7 +1021,7 @@ class BalanceCache {
       }
     }
     if (cleanedCount > 0) {
-      init.logger.info(`已清理 ${cleanedCount} 个过期周期的余额缓存`);
+      logger.info(`已清理 ${cleanedCount} 个过期周期的余额缓存`);
     }
   }
 }
@@ -918,13 +1038,13 @@ class OrderWatcher {
   async watch(orderId, endTime, getOrderFn) {
     const timeoutAt = endTime + TIMEOUT_BUFFER;
     const shortId = orderId.substring(0, 10) + "...";
-    init.logger.info(
+    logger.info(
       `开始监控订单 ${shortId}，超时: ${new Date(timeoutAt).toLocaleString()}`
     );
     while (true) {
       const now = Date.now();
       if (now >= timeoutAt) {
-        init.logger.warning(`订单超时: ${shortId}`);
+        logger.warning(`订单超时: ${shortId}`);
         return { status: "TIMEOUT" };
       }
       try {
@@ -932,7 +1052,7 @@ class OrderWatcher {
         const status = order.status.toUpperCase();
         if (TERMINAL_STATUSES.includes(status)) {
           const filledSize = parseFloat(order.size_matched || "0");
-          init.logger.info(`订单 ${shortId} 终态: ${status}，成交: ${filledSize}`);
+          logger.info(`订单 ${shortId} 终态: ${status}，成交: ${filledSize}`);
           return {
             status,
             filledSize,
@@ -941,7 +1061,7 @@ class OrderWatcher {
         }
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        init.logger.warning(`查询订单失败: ${errorMsg}，继续重试...`);
+        logger.warning(`查询订单失败: ${errorMsg}，继续重试...`);
       }
       await this.delay(POLL_INTERVAL);
     }
@@ -952,6 +1072,7 @@ class OrderWatcher {
 }
 const DATA_API_HOST = "https://data-api.polymarket.com";
 const BASE_INTERVAL = 5 * 60 * 1e3;
+const DEFAULT_BATCH_SIZE = 5;
 const MAX_MATCH_TIMES = 3;
 class Redeemer {
   // conditionId -> RedeemRecord
@@ -962,6 +1083,7 @@ class Redeemer {
   state = "stopped";
   scheduler;
   redeemFn = null;
+  batchSize = DEFAULT_BATCH_SIZE;
   funderAddress = "";
   onRedeemSuccess = null;
   constructor(scheduler = {
@@ -983,10 +1105,14 @@ class Redeemer {
       return;
     }
     this.redeemFn = redeemFn;
+    const envBatchSize = Number(process.env.POLYCOPY_REDEEM_BATCH_SIZE || "");
+    if (!Number.isNaN(envBatchSize) && envBatchSize > 0) {
+      this.batchSize = Math.floor(envBatchSize);
+    }
     this.funderAddress = funderAddress;
     this.onRedeemSuccess = onRedeemSuccess || null;
     this.state = "running";
-    init.logger.success("自动 redeem 已启动");
+    logger.success("自动 redeem 已启动");
     this.startInterval();
   }
   /**
@@ -1034,7 +1160,7 @@ class Redeemer {
       this.delayTimeoutId = void 0;
     }
     this.state = "stopped";
-    init.logger.info("自动 redeem 已停止");
+    logger.info("自动 redeem 已停止");
   }
   /**
    * 获取可 Redeem 的仓位
@@ -1085,7 +1211,7 @@ class Redeemer {
       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} 秒后重试`);
+        logger.warning(`获取仓位限流，${resetSeconds} 秒后重试`);
         telegramService.warning(
           "API 限流",
           `获取仓位限流，${resetSeconds} 秒后重试`
@@ -1093,9 +1219,27 @@ class Redeemer {
         this.pauseAndRestart((resetSeconds + 60) * 1e3);
         return;
       }
-      init.logger.error(`获取仓位失败: ${errorMsg}`);
+      logger.error(`获取仓位失败: ${errorMsg}`);
       return;
     }
+    const currentIds = new Set(positions.map((position) => position.conditionId));
+    this.logPendingPositions(positions);
+    const pendingRecords = this.buildRecords(positions);
+    this.updateMatchedRecords(currentIds);
+    const shouldContinue = await this.executeBatches(pendingRecords);
+    if (!shouldContinue) {
+      return;
+    }
+    const successItems = this.collectSuccessRecords(currentIds);
+    if (successItems.length > 0) {
+      const successTitle = `自动 redeem: 成功 ${successItems.length} 个`;
+      const successLines = this.logPositions(successTitle, successItems);
+      telegramService.success(successTitle, successLines.join("\n"));
+      this.onRedeemSuccess?.();
+    }
+    logger.info(`redeem 状态: ${this.records.size} 个待确认`);
+  }
+  logPendingPositions(positions) {
     const pendingRedeemablePositions = positions.filter((position) => {
       const record = this.records.get(position.conditionId);
       return !record?.success;
@@ -1105,8 +1249,11 @@ class Redeemer {
         `自动 redeem: 发现 ${pendingRedeemablePositions.length} 个可 Redeem 仓位`,
         pendingRedeemablePositions.map((position) => ({ position }))
       );
+      logger.info(`Redeem 批量大小: ${this.batchSize}`);
     }
-    for (const position of positions) {
+  }
+  buildRecords(positions) {
+    return positions.map((position) => {
       let record = this.records.get(position.conditionId);
       if (!record) {
         record = {
@@ -1118,52 +1265,76 @@ class Redeemer {
         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)}...)`
-          );
-          telegramService.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);
+      return record;
+    }).filter((record) => !record.success && record.failedCount < MAX_MATCH_TIMES);
+  }
+  updateMatchedRecords(currentIds) {
+    for (const record of this.records.values()) {
+      if (!record.success) {
+        continue;
+      }
+      if (!currentIds.has(record.position.conditionId)) {
+        continue;
+      }
+      record.matchedCount++;
+      if (record.matchedCount >= MAX_MATCH_TIMES) {
+        logger.error(
+          `Redeem 失败: 执行成功但仍存在 ${record.matchedCount} 次 (conditionId: ${record.position.conditionId.slice(0, 10)}...)`
+        );
+        telegramService.error(
+          "Redeem 失败",
+          `执行成功但仓位仍存在 ${record.matchedCount} 次
+conditionId: ${record.position.conditionId}
+价值: ${record.position.currentValue} USDC`
+        );
+      }
+    }
+  }
+  async executeBatches(pendingRecords) {
+    for (let i = 0; i < pendingRecords.length; i += this.batchSize) {
+      const batch = pendingRecords.slice(i, i + this.batchSize);
+      const conditionIds = batch.map((record) => record.position.conditionId);
+      if (conditionIds.length === 0) {
+        continue;
+      }
+      try {
+        const txHash = await this.redeemFn?.(conditionIds);
+        batch.forEach((record) => {
           record.success = true;
-          init.logger.info(`Redeem 已执行: ${txHash}`);
-        } 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(`Redeem 限流，${resetSeconds} 秒后重试`);
-            telegramService.warning("Redeem 限流", `${resetSeconds} 秒后重试`);
-            this.pauseAndRestart((resetSeconds + 60) * 1e3);
-            return;
-          }
+          record.matchedCount = 0;
+        });
+        logger.info(`Redeem 已执行 (批量 ${batch.length}): ${txHash}`);
+      } 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);
+          logger.warning(`Redeem 限流，${resetSeconds} 秒后重试`);
+          telegramService.warning("Redeem 限流", `${resetSeconds} 秒后重试`);
+          this.pauseAndRestart((resetSeconds + 60) * 1e3);
+          return false;
+        }
+        batch.forEach((record) => {
           record.failedCount++;
-          init.logger.error(
-            `Redeem 异常 (第 ${record.failedCount} 次): ${errorMsg}`
-          );
+        });
+        logger.error(`Redeem 批量异常 (批量 ${batch.length}): ${errorMsg}`);
+        batch.forEach((record) => {
           if (record.failedCount >= MAX_MATCH_TIMES) {
             telegramService.error(
               "Redeem 异常",
               `重试 ${record.failedCount} 次仍失败
-conditionId: ${position.conditionId}
+conditionId: ${record.position.conditionId}
 错误: ${errorMsg}`
             );
           }
-        }
+        });
       }
     }
+    return true;
+  }
+  collectSuccessRecords(currentIds) {
     const successItems = [];
     for (const [conditionId, record] of this.records.entries()) {
-      const stillExists = positions.some((p) => p.conditionId === conditionId);
-      if (!stillExists) {
+      if (!currentIds.has(conditionId)) {
         successItems.push({
           position: record.position,
           matchedCount: record.matchedCount
@@ -1171,13 +1342,7 @@ conditionId: ${position.conditionId}
         this.records.delete(conditionId);
       }
     }
-    if (successItems.length > 0) {
-      const successTitle = `自动 redeem: 成功 ${successItems.length} 个`;
-      const successLines = this.logPositions(successTitle, successItems);
-      telegramService.success(successTitle, successLines.join("\n"));
-      this.onRedeemSuccess?.();
-    }
-    init.logger.info(`redeem 状态: ${this.records.size} 个待确认`);
+    return successItems;
   }
   /**
    * 统一格式化仓位信息
@@ -1192,15 +1357,12 @@ conditionId: ${position.conditionId}
    * 统一输出 Redeem 仓位列表
    */
   logPositions(title, items) {
-    init.logger.info(title);
+    logger.info(title);
     const lines = [];
     for (const item of items) {
-      const line = this.formatPositionLine(
-        item.position,
-        item.matchedCount
-      );
+      const line = this.formatPositionLine(item.position, item.matchedCount);
       lines.push(line);
-      init.logger.line("", `- ${line}`);
+      logger.line("", `- ${line}`);
     }
     return lines;
   }
@@ -1240,7 +1402,7 @@ class Trader {
     }
     this.config = config;
     if (!config.polymarket?.privateKey) {
-      init.logger.warning("未配置 PolyMarket 私钥，交易功能已禁用");
+      logger.warning("未配置 PolyMarket 私钥，交易功能已禁用");
       return;
     }
     await this.client.init({
@@ -1254,10 +1416,10 @@ class Trader {
         builderCreds: config.polymarket.builderCreds
       });
     } else {
-      init.logger.warning("未配置 builderCreds，自动 Redeem 功能已禁用");
+      logger.warning("未配置 builderCreds，自动 Redeem 功能已禁用");
     }
     this.initialized = true;
-    init.logger.success("交易模块初始化完成");
+    logger.success("交易模块初始化完成");
   }
   /**
    * 启动 Redeemer（在 Telegram listener 就绪后调用）
@@ -1267,7 +1429,7 @@ class Trader {
       return;
     }
     this.redeemer.start(
-      this.executeRedeem.bind(this),
+      this.executeRedeemBatch.bind(this),
       this.config.polymarket.funderAddress || "",
       () => this.balanceCache.invalidate()
     );
@@ -1283,19 +1445,19 @@ class Trader {
    */
   async executeSignal(signal) {
     if (!this.initialized || !this.config) {
-      init.logger.warning("交易模块未初始化，跳过信号");
+      logger.warning("交易模块未初始化，跳过信号");
       return;
     }
     const { metadata } = signal;
     const { assetId, endTime, outcome } = metadata;
-    init.logger.section(`处理信号: ${outcome} (${metadata.eventId})`);
+    logger.section(`处理信号: ${outcome} (${metadata.eventId})`);
     if (!this.assetFilter.canTrade(assetId, endTime)) {
-      init.logger.warning(`assetId 已交易，跳过: ${assetId.slice(0, 10)}...`);
+      logger.warning(`assetId 已交易，跳过: ${assetId.slice(0, 10)}...`);
       return;
     }
     const tradingConfig = this.config.trading;
     const amountMode = tradingConfig?.amountMode || "fixed";
-    const amountValue = tradingConfig?.amountValue || 1;
+    const amountValue = amountMode === "percentage" ? tradingConfig?.amountPercentageValue ?? 0.1 : tradingConfig?.amountFixedValue ?? 5;
     const buyPrice = tradingConfig?.buyPrice || 0.98;
     const sellPrice = tradingConfig?.sellPrice || 1;
     let balance;
@@ -1306,12 +1468,12 @@ class Trader {
       );
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      init.logger.error(`获取余额失败: ${errorMsg}`);
+      logger.error(`获取余额失败: ${errorMsg}`);
       return;
     }
     if (amountMode === "fixed" && balance < amountValue) {
       const msg = `余额不足: ${balance} USDC < ${amountValue} USDC`;
-      init.logger.warning(msg);
+      logger.warning(msg);
       telegramService.warning(
         "余额不足",
         `当前余额: ${balance} USDC
@@ -1320,18 +1482,18 @@ class Trader {
       return;
     }
     if (amountMode === "percentage" && balance <= 0) {
-      init.logger.warning(`余额为零: ${balance} USDC`);
+      logger.warning(`余额为零: ${balance} USDC`);
       telegramService.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)}`);
+    logger.info(`下单金额: ${orderAmount.toFixed(2)} USDC`);
+    logger.info(`下单价格: ${buyPrice}`);
+    logger.info(`下单数量: ${size.toFixed(4)}`);
     const buyResult = await this.client.createBuyOrder(assetId, buyPrice, size);
     if (!buyResult.success) {
-      init.logger.error(`买单失败: ${buyResult.errorMsg}`);
+      logger.error(`买单失败: ${buyResult.errorMsg}`);
       telegramService.error(
         "买单失败",
         `事件: ${metadata.eventId}
@@ -1341,7 +1503,7 @@ class Trader {
     }
     this.assetFilter.markTraded(assetId, endTime);
     if (sellPrice === 1) {
-      init.logger.info("sellPrice = 1，成交后将自动 redeem");
+      logger.info("sellPrice = 1，成交后将自动 redeem");
       return;
     }
     this.watchAndHandle(
@@ -1371,7 +1533,7 @@ class Trader {
       );
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      init.logger.error(`订单监控异常: ${errorMsg}`);
+      logger.error(`订单监控异常: ${errorMsg}`);
       telegramService.error(
         "订单监控异常",
         `事件: ${eventId}
@@ -1388,22 +1550,22 @@ class Trader {
       case "MATCHED":
       case "CONFIRMED":
         const filledSize = result.filledSize || 0;
-        init.logger.success(`买单成交: ${filledSize.toFixed(4)} 份`);
+        logger.success(`买单成交: ${filledSize.toFixed(4)} 份`);
         if (sellPrice < 1) {
           this.waitAndSell(assetId, filledSize, sellPrice, endTime);
         } else {
-          init.logger.info("sellPrice = 1，等待 Redeem");
+          logger.info("sellPrice = 1，等待 Redeem");
         }
         break;
       case "CANCELLED":
-        init.logger.info("订单已取消（市场可能已结束）");
+        logger.info("订单已取消（市场可能已结束）");
         break;
       case "FAILED":
-        init.logger.error("订单执行失败");
+        logger.error("订单执行失败");
         telegramService.error("订单执行失败", `订单 ID: ${orderId}`);
         break;
       case "TIMEOUT":
-        init.logger.warning("订单超时，尝试取消");
+        logger.warning("订单超时，尝试取消");
         await this.client.cancelOrder(orderId);
         break;
     }
@@ -1414,18 +1576,18 @@ class Trader {
   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)}`);
+    logger.info(`等待仓位同步: ${shortId}，预期 >= ${threshold.toFixed(4)}`);
     while (true) {
       const now = Date.now();
       if (now >= endTime) {
-        init.logger.warning(`仓位同步超时: ${shortId}，等待 Redeem`);
+        logger.warning(`仓位同步超时: ${shortId}，等待 Redeem`);
         this.notifyRedeemFallback(assetId, expectedSize);
         return;
       }
       try {
         const positionSize = await this.client.getPositionSize(assetId);
         if (positionSize >= threshold) {
-          init.logger.info(
+          logger.info(
             `仓位已同步: ${shortId}，数量: ${positionSize.toFixed(4)}`
           );
           await this.executeSellOrder(assetId, sellPrice, positionSize);
@@ -1433,7 +1595,7 @@ class Trader {
         }
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        init.logger.warning(`获取仓位失败: ${shortId}，${errorMsg}`);
+        logger.warning(`获取仓位失败: ${shortId}，${errorMsg}`);
       }
       await this.delay(POSITION_POLL_INTERVAL);
     }
@@ -1444,7 +1606,7 @@ class Trader {
   notifyRedeemFallback(assetId, expectedSize) {
     if (!this.relayClient.isInitialized()) {
       const msg = "仓位同步超时且 Redeem 不可用";
-      init.logger.warning(msg);
+      logger.warning(msg);
       telegramService.warning(
         msg,
         `Asset: ${assetId.substring(0, 20)}...
@@ -1463,36 +1625,36 @@ class Trader {
    * 执行卖单
    */
   async executeSellOrder(assetId, price, size) {
-    init.logger.info(`创建卖单: ${size.toFixed(4)} 份 @ ${price}`);
+    logger.info(`创建卖单: ${size.toFixed(4)} 份 @ ${price}`);
     const sellResult = await this.client.createSellOrder(assetId, price, size);
     if (sellResult.success) {
-      init.logger.success(`卖单已提交: ${sellResult.orderId}`);
+      logger.success(`卖单已提交: ${sellResult.orderId}`);
     } else {
-      init.logger.error(`卖单提交失败: ${sellResult.errorMsg}`);
+      logger.error(`卖单提交失败: ${sellResult.errorMsg}`);
       telegramService.error("卖单提交失败", `错误: ${sellResult.errorMsg}`);
     }
   }
   /**
-   * 执行 Redeem（供 Redeemer 调用）
+   * 批量执行 Redeem（供 Redeemer 调用）
    */
-  async executeRedeem(conditionId) {
+  async executeRedeemBatch(conditionIds) {
     if (!this.relayClient.isInitialized()) {
       throw new Error("RelayClient 未初始化");
     }
-    return this.relayClient.redeem(conditionId);
+    return this.relayClient.redeemBatch(conditionIds);
   }
   /**
    * 停止交易模块
    */
   async shutdown() {
     this.redeemer.stop();
-    init.logger.info("交易模块已停止");
+    logger.info("交易模块已停止");
   }
 }
 const trader = new Trader();
 function enterDaemonMode() {
-  if (!fs__namespace.existsSync(paths.PID_DIR)) {
-    fs__namespace.mkdirSync(paths.PID_DIR, { recursive: true });
+  if (!fs__namespace.existsSync(processLock.PID_DIR)) {
+    fs__namespace.mkdirSync(processLock.PID_DIR, { recursive: true });
   }
   const child = child_process.spawn(process.execPath, [__filename], {
     detached: true,
@@ -1504,46 +1666,81 @@ function enterDaemonMode() {
     }
   });
   if (child.pid) {
-    fs__namespace.writeFileSync(paths.PID_FILE, child.pid.toString());
-    init.logger.blank();
-    init.logger.success(`已进入后台模式 (PID: ${child.pid})`);
-    init.logger.line("", `日志目录: ${paths.LOGS_DIR}`);
-    init.logger.line("", `使用 'polycopy stop' 停止`);
-    init.logger.line("", `使用 'polycopy log' 查看日志`);
+    fs__namespace.writeFileSync(processLock.PID_FILE, child.pid.toString());
+    logger.blank();
+    logger.success(`已进入后台模式 (PID: ${child.pid})`);
+    logger.line("", `日志目录: ${processLock.LOGS_DIR}`);
+    logger.line("", `使用 'polycopy stop' 停止`);
+    logger.line("", `使用 'polycopy log' 查看日志`);
     child.unref();
     process.exit(0);
   } else {
-    init.logger.error("进入后台模式失败");
+    logger.error("进入后台模式失败");
     process.exit(1);
   }
 }
 async function main() {
-  init.logger.init();
-  init.logger.section("PolyMarket 跟单机器人");
-  const config = await init.ensureConfig();
+  logger.init();
+  if (process.env.POLYCOPY_DAEMON_CHILD !== "1") {
+    const runningPid = processLock.resolveRunningPid();
+    if (runningPid) {
+      console.log(`⚠️  程序正在运行中 (PID: ${runningPid})`);
+      console.log(`   请先停止程序后再启动`);
+      process.exit(1);
+    }
+    processLock.savePid(process.pid);
+  }
+  const exitOnFatal = async () => {
+    await logger.flush();
+    if (process.env.POLYCOPY_DAEMON_CHILD !== "1") {
+      processLock.removePid();
+    }
+    process.exit(1);
+  };
+  process.on("uncaughtException", async (error) => {
+    const message = error instanceof Error ? error.stack || error.message : String(error);
+    logger.error(`捕获未处理异常:
+${message}`);
+    await exitOnFatal();
+  });
+  process.on("unhandledRejection", async (reason) => {
+    const message = reason instanceof Error ? reason.stack || reason.message : String(reason);
+    logger.error(`捕获未处理 Promise 拒绝:
+${message}`);
+    await exitOnFatal();
+  });
+  process.on("beforeExit", async () => {
+    await logger.flush();
+  });
+  const config = await processLock.ensureConfig();
+  if (process.env.POLYCOPY_DAEMON === "1") {
+    enterDaemonMode();
+    return;
+  }
+  logger.section("PolyMarket 跟单机器人");
   telegramService.init(
     config.telegram.botToken,
     config.telegram.adminChatId,
     config.telegram.targetChatIds || []
   );
-  const autoTradeEnabled = init.canAutoTrade(config);
+  const autoTradeEnabled = processLock.canAutoTrade(config);
   if (!autoTradeEnabled) {
-    init.logger.warning("自动跟单功能未启用");
+    logger.warning("自动跟单功能未启用");
     if (!config.polymarket?.privateKey) {
-      init.logger.line("", "- PolyMarket 配置不完整（缺少私钥）");
+      logger.line("", "- PolyMarket 配置不完整（缺少私钥）");
     }
-    if (!config.trading?.amountMode || !config.trading?.amountValue || !config.trading?.buyPrice || !config.trading?.sellPrice) {
-      init.logger.line("", "- 交易配置不完整");
+    if (!config.trading?.amountMode || !config.trading?.buyPrice || !config.trading?.sellPrice || (config.trading.amountMode === "fixed" ? !config.trading.amountFixedValue : !config.trading.amountPercentageValue)) {
+      logger.line("", "- 交易配置不完整");
     }
-    init.logger.line("", "当前不会跟单任何预测消息");
+    logger.line("", "当前不会跟单任何预测消息");
   } else {
     try {
       await trader.init(config);
       if (config.trading?.sellPrice === 1 && !config.polymarket?.builderCreds) {
-        init.logger.error(
+        logger.error(
           "sellPrice = 1 但未配置 builderCreds，Redeem 功能无法使用，程序已退出"
         );
-        init.logger.line(
+        logger.line(
           "",
           "请配置 Builder API 凭证，或将卖价设置为 < 1 使用限价卖出模式"
         );
@@ -1551,29 +1748,29 @@ async function main() {
       }
     } catch (error) {
       const errorMsg = error instanceof Error ? error.message : String(error);
-      init.logger.error(`交易模块初始化失败: ${errorMsg}`);
-      init.logger.line("", "当前不会跟单任何预测消息");
+      logger.error(`交易模块初始化失败: ${errorMsg}`);
+      logger.line("", "当前不会跟单任何预测消息");
     }
   }
   telegramService.onChatIdsChanged((chatIds) => {
-    const telegram = init.configLocal.getItem("telegram");
+    const telegram = processLock.configLocal.getItem("telegram");
     if (!telegram) {
-      init.logger.error("警告: 无法保存频道 ID，telegram 配置不存在");
+      logger.error("警告: 无法保存频道 ID，telegram 配置不存在");
       return;
     }
     telegram.targetChatIds = chatIds.length > 0 ? chatIds : void 0;
-    init.configLocal.setItem("telegram", telegram);
-    init.logger.line("💾", `已保存频道 ID 列表: ${chatIds.length} 个频道`);
+    processLock.configLocal.setItem("telegram", telegram);
+    logger.line("💾", `已保存频道 ID 列表: ${chatIds.length} 个频道`);
   });
   telegramService.onSignal(async (signal) => {
-    init.logger.info(`📨 收到预测信号:`);
-    init.logger.line("", `事件: ${signal.metadata.eventId}`);
-    init.logger.line(
+    logger.info(`📨 收到预测信号:`);
+    logger.line("", `事件: ${signal.metadata.eventId}`);
+    logger.line(
       "",
       `方向: ${signal.metadata.outcome === "Up" ? "上涨 📈" : "下跌 📉"}`
     );
-    init.logger.line("", `Asset: ${signal.metadata.assetId}`);
-    init.logger.line(
+    logger.line("", `Asset: ${signal.metadata.assetId}`);
+    logger.line(
       "",
       `结束时间: ${new Date(signal.metadata.endTime).toLocaleString()}`
     );
@@ -1582,24 +1779,23 @@ async function main() {
         await trader.executeSignal(signal);
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        init.logger.error(`交易执行失败: ${errorMsg}`);
+        logger.error(`交易执行失败: ${errorMsg}`);
       }
     }
   });
-  if (process.env.POLYCOPY_DAEMON === "1") {
-    enterDaemonMode();
-    return;
-  }
   let isShuttingDown = false;
   const shutdown = async () => {
     if (isShuttingDown) return;
     isShuttingDown = true;
     process.removeAllListeners("SIGINT");
     process.removeAllListeners("SIGTERM");
-    init.logger.blank();
-    init.logger.info("正在退出...");
+    logger.blank();
+    logger.info("正在退出...");
     await Promise.all([trader.shutdown(), telegramService.stop()]);
-    await init.logger.flush();
+    await logger.flush();
+    if (process.env.POLYCOPY_DAEMON_CHILD !== "1") {
+      processLock.removePid();
+    }
     process.exit(0);
   };
   process.prependListener("SIGINT", () => {
@@ -1614,7 +1810,13 @@ async function main() {
     }
   });
 }
-main().catch((error) => {
-  init.logger.error("程序运行出错:", error);
+main().catch(async (error) => {
+  const message = error instanceof Error ? error.stack || error.message : String(error);
+  logger.error(`程序运行出错:
+${message}`);
+  await logger.flush();
+  if (process.env.POLYCOPY_DAEMON_CHILD !== "1") {
+    processLock.removePid();
+  }
   process.exit(1);
 });