docs: 添加 v1.1.7 release notes

- 将所有 Telegram 群链接统一更新为 t.me/polyhermes
- 在 README 和 README_EN.md 中添加动态 Docker 版本徽章，自动显示最新版本
- 更新 Layout.tsx、RELEASE.md 中的 Telegram 链接

README.md

@@ -2,6 +2,7 @@
 
 [![GitHub](https://img.shields.io/badge/GitHub-WrBug%2FPolyHermes-blue?logo=github)](https://github.com/WrBug/PolyHermes)
 [![Twitter](https://img.shields.io/badge/Twitter-@polyhermes-blue?logo=twitter)](https://x.com/polyhermes)
+[![Docker](https://img.shields.io/docker/v/wrbug/polyhermes?label=Docker&logo=docker)](https://hub.docker.com/r/wrbug/polyhermes)
 
 > 🌐 **Language**: [English](README_EN.md) | 中文
 
@@ -432,6 +433,7 @@ cd frontend
 
 - [GitHub 仓库](https://github.com/WrBug/PolyHermes)
 - [Twitter](https://x.com/polyhermes)
+- [Telegram 群组](https://t.me/polyhermes)
 - [Polymarket 官网](https://polymarket.com)
 - [Polymarket API 文档](https://docs.polymarket.com)
 

README_EN.md

@@ -2,6 +2,7 @@
 
 [![GitHub](https://img.shields.io/badge/GitHub-WrBug%2FPolyHermes-blue?logo=github)](https://github.com/WrBug/PolyHermes)
 [![Twitter](https://img.shields.io/badge/Twitter-@polyhermes-blue?logo=twitter)](https://x.com/polyhermes)
+[![Docker](https://img.shields.io/docker/v/wrbug/polyhermes?label=Docker&logo=docker)](https://hub.docker.com/r/wrbug/polyhermes)
 
 > 🌐 **Language**: English | [中文](README.md)
 
@@ -432,6 +433,7 @@ This project is licensed under the MIT License. See the [LICENSE](LICENSE) file
 
 - [GitHub Repository](https://github.com/WrBug/PolyHermes)
 - [Twitter](https://x.com/polyhermes)
+- [Telegram Group](https://t.me/polyhermes)
 - [Polymarket Official Website](https://polymarket.com)
 - [Polymarket API Documentation](https://docs.polymarket.com)
 

RELEASE.md

@@ -1,3 +1,151 @@
+# v1.1.7
+
+## 🚀 主要功能
+
+### 💰 Polymarket Maker Rebates Program 费率支持
+
+- **新增费率查询 API 接口** (`getFeeRate`)
+  - 支持动态查询 Maker Rebates Program 费率
+  - 修正 API 返回字段名：使用 `base_fee` 而非 `fee_rate_bps`（与 TypeScript clob-client 一致）
+  
+- **动态费率获取**
+  - 在所有订单创建处动态获取费率：
+    * 跟单买入订单 (`processBuyTrade`)
+    * 跟单卖出订单 (`matchSellOrder`)
+    * 账户卖出订单 (`sellPosition`)
+  - 费率获取失败时降级到默认值 "0"，确保系统可用性
+  - 添加详细的日志记录，便于监控和调试
+
+- **参考文档**: https://docs.polymarket.com/developers/market-makers/maker-rebates-program
+
+### 🔧 Docker 部署优化
+
+- **日志级别环境变量支持**
+  - 在 `application.properties` 中支持通过 `LOG_LEVEL_ROOT` 和 `LOG_LEVEL_APP` 环境变量配置日志级别
+  - 在 `docker-compose.yml` 和 `docker-compose.prod.yml` 中添加日志级别环境变量配置
+  - 在 `deploy.sh` 的 `.env` 模板中添加日志级别配置说明
+  - 支持通过环境变量动态配置日志级别，无需修改配置文件
+  - 默认值：`root=INFO`, `app=DEBUG`
+
+## 🐛 Bug 修复
+
+### 修复市场条件查询的 RPC 调用错误
+
+- **问题**：使用错误的函数签名 `conditions(bytes32)` 导致 RPC 调用失败（execution reverted）
+- **修复**：
+  - 将错误的 `conditions(bytes32)` 函数调用改为正确的 `getOutcomeSlotCount(bytes32)` 和 `payoutDenominator(bytes32)` 函数调用
+  - 修复 `BlockchainService.getCondition` 方法，使用正确的 ConditionalTokens 合约函数签名
+  - 改进 `MarketPriceService` 的错误处理：当链上查询出现 RPC 错误时，降级到 CLOB API 或 Gamma API 查询，而不是直接抛出异常，提高容错性
+
+### 修复 RPC 错误时误创建自动卖出记录的问题
+
+- **问题**：当链上查询市场条件出现 RPC 错误（execution reverted）时，系统会误判为市场已卖出，创建错误的自动卖出记录
+- **修复**：
+  - 修改 `getPriceFromChainCondition` 返回 `Pair<BigDecimal?, Boolean>`，第二个值表示是否发生 RPC 错误
+  - 在 `getCurrentMarketPrice` 中检测到 RPC 错误时抛出异常，`PositionCheckService` 会捕获并跳过该市场的处理
+  - 避免在市场不存在或尚未创建时误判为已卖出
+
+## 📝 文档更新
+
+### 更新 Telegram 群链接
+
+- 将所有 Telegram 群链接统一更新为 `t.me/polyhermes`
+- 更新了以下文件：
+  - `frontend/src/components/Layout.tsx` - 桌面端和移动端导航链接
+  - `RELEASE.md` - 相关链接
+  - `README.md` 和 `README_EN.md` - 相关链接部分
+
+### 添加 Docker 版本徽章
+
+- 在 README 和 README_EN.md 中添加动态 Docker 版本徽章
+- 使用 shields.io 自动显示 Docker Hub 上 `wrbug/polyhermes` 镜像的最新版本
+- 版本信息自动更新，无需手动维护
+
+## 📊 变更统计
+
+- **提交数量**：5 个提交
+- **文件变更**：16 个文件
+- **代码变更**：+205 行 / -886 行（净减少 681 行）
+
+### 详细文件变更
+
+**后端变更**：
+- `PolymarketClobApi.kt` - 添加费率查询接口（+25 行）
+- `AccountService.kt` - 在订单创建处添加动态费率获取（+11 行）
+- `BlockchainService.kt` - 修复市场条件查询的 RPC 调用错误（+84 行）
+- `MarketPriceService.kt` - 改进错误处理，支持降级到其他数据源（+36 行）
+- `PolymarketClobService.kt` - 添加费率查询服务（+32 行）
+- `CopyOrderTrackingService.kt` - 在跟单订单创建处添加费率获取（+34 行）
+- `PositionCheckService.kt` - 修复 RPC 错误处理逻辑（+2 行）
+- `application.properties` - 添加日志级别环境变量支持（+6 行）
+
+**前端变更**：
+- `Layout.tsx` - 更新 Telegram 群链接（+4 行）
+
+**配置文件变更**：
+- `docker-compose.yml` - 添加日志级别环境变量（+4 行）
+- `docker-compose.prod.yml` - 添加日志级别环境变量（+4 行）
+- `deploy.sh` - 添加日志级别配置说明（+5 行）
+
+**文档变更**：
+- `README.md` - 更新 Telegram 链接，添加 Docker 版本徽章（+2 行）
+- `README_EN.md` - 更新 Telegram 链接，添加 Docker 版本徽章（+2 行）
+- `RELEASE.md` - 更新 Telegram 链接（+4 行）
+- `docs/zh/smart-money-analysis.md` - 删除文档（-836 行）
+
+## 🔧 技术细节
+
+### API 变更
+
+- **新增接口**：
+  - `POST /api/clob/fee-rate` - 获取 Maker Rebates Program 费率（内部使用）
+- **无移除接口**
+
+### 环境变量变更
+
+- **新增环境变量**：
+  - `LOG_LEVEL_ROOT` - Root 日志级别（默认：INFO）
+  - `LOG_LEVEL_APP` - 应用日志级别（默认：DEBUG）
+
+### 合约调用修复
+
+- **修复的函数调用**：
+  - 从 `conditions(bytes32)` 改为 `getOutcomeSlotCount(bytes32)` 和 `payoutDenominator(bytes32)`
+  - 使用正确的 ConditionalTokens 合约函数签名
+  - 参考：https://polygonscan.com/address/0x4d97dcd97ec945f40cf65f87097ace5ea0476045#code
+
+## 📝 升级说明
+
+### 数据库升级
+
+- **无需数据库迁移**：本次更新不涉及数据库结构变更
+
+### 配置更新
+
+- **可选配置**：新增日志级别环境变量，如不配置将使用默认值
+  - `LOG_LEVEL_ROOT=INFO`（默认）
+  - `LOG_LEVEL_APP=DEBUG`（默认）
+
+### Docker 部署
+
+- **推荐更新**：使用 Docker Hub 镜像部署的用户，建议更新到最新版本
+  ```bash
+  docker pull wrbug/polyhermes:latest
+  docker-compose -f docker-compose.prod.yml up -d
+  ```
+
+## 🔗 相关链接
+
+- **GitHub 仓库**：https://github.com/WrBug/PolyHermes
+- **Twitter**：@polyhermes
+- **Telegram 群组**：https://t.me/polyhermes
+
+---
+
+**发布日期**：2026-01-07
+
+---
+
 # v1.1.5
 
 ## 🔧 功能优化与改进
@@ -232,7 +380,7 @@ docker pull wrbug/polyhermes:v1.1.2
 
 * **GitHub 仓库**：https://github.com/WrBug/PolyHermes
 * **Twitter**：@polyhermes
-* **Telegram 群组**：加入群组
+* **Telegram 群组**：https://t.me/polyhermes
 
 ---
 
@@ -399,7 +547,7 @@ docker pull wrbug/polyhermes:v1.1.1
 
 * **GitHub 仓库**：https://github.com/WrBug/PolyHermes
 * **Twitter**：@polyhermes
-* **Telegram 群组**：加入群组
+* **Telegram 群组**：https://t.me/polyhermes
 
 ---
 

backend/src/main/kotlin/com/wrbug/polymarketbot/api/PolymarketClobApi.kt

@@ -149,6 +149,19 @@ interface PolymarketClobApi {
     @GET("/auth/derive-api-key")
     suspend fun deriveApiKey(): Response<ApiKeyResponse>
     
+    /**
+     * 获取费率
+     * 文档: https://docs.polymarket.com/developers/market-makers/maker-rebates-program#1-fetch-the-fee-rate
+     * 端点: GET /fee-rate
+     * 
+     * @param tokenId Token ID
+     * @return 费率响应
+     */
+    @GET("/fee-rate")
+    suspend fun getFeeRate(
+        @Query("token_id") tokenId: String
+    ): Response<FeeRateResponse>
+    
     /**
      * 获取服务器时间
      * 端点: /time
@@ -357,6 +370,18 @@ data class ServerTimeResponse(
     val timestamp: Long
 )
 
+/**
+ * 费率响应
+ * 文档: https://docs.polymarket.com/developers/market-makers/maker-rebates-program#1-fetch-the-fee-rate
+ * 
+ * 注意：根据 TypeScript clob-client 源码，API 返回的字段名是 base_fee，而不是文档中的 fee_rate_bps
+ * 参考: clob-client/src/client.ts:312
+ */
+data class FeeRateResponse(
+    @SerializedName("base_fee")
+    val baseFee: Int  // 费率基点（0 表示无费率，1000 表示 10%）
+)
+
 /**
  * 最新价响应（从订单表获取）
  */

backend/src/main/kotlin/com/wrbug/polymarketbot/repository/CopyOrderTrackingRepository.kt

@@ -61,5 +61,28 @@ interface CopyOrderTrackingRepository : JpaRepository<CopyOrderTracking, Long> {
      */
     @Query("SELECT t FROM CopyOrderTracking t WHERE t.createdAt <= :beforeTime")
     fun findByCreatedAtBefore(beforeTime: Long): List<CopyOrderTracking>
+
+    /**
+     * 查询指定时间之前创建且状态不为指定状态的订单
+     */
+    fun findByCreatedAtBeforeAndStatusNot(beforeTime: Long, status: String): List<CopyOrderTracking>
+
+    /**
+     * 查询指定跟单配置下的活跃仓位数量
+     * 活跃仓位定义为 remainingQuantity > 0 的不同 (marketId, outcomeIndex) 组合
+     */
+    @Query("SELECT COUNT(DISTINCT CONCAT(t.marketId, '_', COALESCE(t.outcomeIndex, -1))) FROM CopyOrderTracking t WHERE t.copyTradingId = :copyTradingId AND t.remainingQuantity > 0")
+    fun countActivePositions(copyTradingId: Long): Int
+
+    /**
+     * 检查指定市场是否存在活跃仓位
+     */
+    fun existsByCopyTradingIdAndMarketIdAndRemainingQuantityGreaterThan(copyTradingId: Long, marketId: String, remainingQuantity: BigDecimal): Boolean
+
+    /**
+     * 计算指定跟单配置和市场下的当前持仓总价值 (成本价计算)
+     */
+    @Query("SELECT SUM(t.remainingQuantity * t.price) FROM CopyOrderTracking t WHERE t.copyTradingId = :copyTradingId AND t.marketId = :marketId AND t.remainingQuantity > 0")
+    fun sumCurrentPositionValueByMarket(copyTradingId: Long, marketId: String): BigDecimal?
 }
 

backend/src/main/kotlin/com/wrbug/polymarketbot/service/accounts/AccountService.kt

@@ -228,11 +228,12 @@ class AccountService(
 
     /**
      * 查询账户列表
+     * 列表接口只返回基本信息，不查询统计信息（统计信息只在详情接口中查询）
      */
     fun getAccountList(): Result<AccountListResponse> {
         return try {
             val accounts = accountRepository.findAllByOrderByCreatedAtAsc()
-            val accountDtos = accounts.map { toDto(it) }
+            val accountDtos = accounts.map { toBasicDto(it) }
 
             Result.success(
                 AccountListResponse(
@@ -353,7 +354,30 @@ class AccountService(
     }
 
     /**
-     * 转换为 DTO
+     * 转换为基础 DTO（列表使用，不包含统计信息）
+     * 列表接口只返回基本信息，不查询统计信息，以提高性能
+     */
+    private fun toBasicDto(account: Account): AccountDto {
+        return AccountDto(
+            id = account.id!!,
+            walletAddress = account.walletAddress,
+            proxyAddress = account.proxyAddress,
+            accountName = account.accountName,
+            isEnabled = account.isEnabled,
+            walletType = account.walletType,
+            apiKeyConfigured = account.apiKey != null,
+            apiSecretConfigured = account.apiSecret != null,
+            apiPassphraseConfigured = account.apiPassphrase != null,
+            totalOrders = null,
+            totalPnl = null,
+            activeOrders = null,
+            completedOrders = null,
+            positionCount = null
+        )
+    }
+
+    /**
+     * 转换为完整 DTO（详情使用，包含交易统计数据）
      * 包含交易统计数据（总订单数、总盈亏、活跃订单数、已完成订单数、持仓数量）
      */
     private fun toDto(account: Account): AccountDto {
@@ -839,6 +863,15 @@ class AccountService(
             // 7. 解密私钥
             val decryptedPrivateKey = decryptPrivateKey(account)
 
+            // 获取费率（根据 Polymarket Maker Rebates Program 要求）
+            val feeRateResult = clobService.getFeeRate(tokenId)
+            val feeRateBps = if (feeRateResult.isSuccess) {
+                feeRateResult.getOrNull()?.toString() ?: "0"
+            } else {
+                logger.warn("获取费率失败，使用默认值 0: tokenId=$tokenId, error=${feeRateResult.exceptionOrNull()?.message}")
+                "0"
+            }
+
             // 11. 创建并签名订单（使用计算后的卖出数量）
             val signedOrder = try {
                 orderSigningService.createAndSignOrder(
@@ -850,7 +883,7 @@ class AccountService(
                     size = sellQuantity.toPlainString(),  // 使用计算后的卖出数量
                     signatureType = 2,  // Browser Wallet（与正确订单数据一致）
                     nonce = "0",
-                    feeRateBps = "0",
+                    feeRateBps = feeRateBps,  // 使用动态获取的费率
                     expiration = expiration
                 )
             } catch (e: Exception) {

backend/src/main/kotlin/com/wrbug/polymarketbot/service/accounts/PositionCheckService.kt

@@ -382,9 +382,15 @@ class PositionCheckService(
                         
                         if (ordersToMarkAsSold.isNotEmpty()) {
                             // 有订单创建时间超过2分钟，认为仓位已被出售
+                            try {
                             val currentPrice = getCurrentMarketPrice(marketId, outcomeIndex)
                             updateOrdersAsSold(ordersToMarkAsSold, currentPrice, copyTrading.id, marketId, outcomeIndex)
                             logger.debug("仓位不存在且订单创建时间超过2分钟，标记为已卖出: marketId=$marketId, outcomeIndex=$outcomeIndex, orderCount=${ordersToMarkAsSold.size}")
+                            } catch (e: Exception) {
+                                logger.warn("无法获取市场价格，跳过标记为已卖出: marketId=$marketId, outcomeIndex=$outcomeIndex, error=${e.message}")
+                                // 无法获取价格时，跳过该市场的处理，等待下次检查时再试
+                                continue
+                            }
                         } else {
                             // 订单创建时间不足2分钟，可能是刚创建的订单，暂时不处理
                             logger.debug("仓位不存在但订单创建时间不足2分钟，暂不标记为已卖出: marketId=$marketId, outcomeIndex=$outcomeIndex, orderCount=${orders.size}, oldestOrderAge=${orders.minOfOrNull { now - it.createdAt }?.let { "${it}ms" } ?: "N/A"}")
@@ -392,7 +398,7 @@ class PositionCheckService(
                     } else {
                         // 有仓位，按订单下单顺序（FIFO）更新状态
                         // 计算逻辑：
-                        // 1. 总订单数量 = 所有未卖出订单的剩余数量总和
+                         // 1. 总订单数量 = 所有未卖出订单的剩余数量总和
                         // 2. 已成交数量 = 总订单数量 - 仓位数量（因为还有仓位，说明部分订单已卖出）
                         // 3. 如果已成交数量 = 0，说明订单还没有卖出，不修改订单状态
                         // 4. 如果已成交数量 > 0，按FIFO顺序匹配订单
@@ -413,9 +419,15 @@ class PositionCheckService(
                         }
                         
                         // 如果已成交数量 > 0，按FIFO顺序匹配订单
+                        try {
                         val currentPrice = getCurrentMarketPrice(marketId, outcomeIndex)
                         updateOrdersAsSoldByFIFO(orders, soldQuantity, currentPrice,
                             copyTrading.id, marketId, outcomeIndex)
+                        } catch (e: Exception) {
+                            logger.warn("无法获取市场价格，跳过FIFO匹配: marketId=$marketId, outcomeIndex=$outcomeIndex, error=${e.message}")
+                            // 无法获取价格时，跳过该市场的处理，等待下次检查时再试
+                            continue
+                        }
                     }
                 }
             }

backend/src/main/kotlin/com/wrbug/polymarketbot/service/common/BlockchainService.kt

@@ -715,7 +715,7 @@ class BlockchainService(
     
     /**
      * 从链上查询市场条件（Condition）的结算结果
-     * 通过调用 ConditionalTokens 合约的 getCondition 函数获取 payouts
+     * 通过调用 ConditionalTokens 合约的 conditions mapping 和 payoutNumerators mapping
      * 
      * @param conditionId 市场条件ID（bytes32，必须是 0x 开头的 66 位十六进制字符串）
      * @return Result<Pair<payoutDenominator, payouts>>
@@ -734,44 +734,131 @@ class BlockchainService(
             
             val rpcApi = polygonRpcApi
             
-            // 构建 getCondition(bytes32) 函数调用
-            // 函数签名: getCondition(bytes32)
-            val functionSelector = EthereumUtils.getFunctionSelector("getCondition(bytes32)")
+            // 1. 调用 getOutcomeSlotCount(bytes32) 获取结果槽位数量
+            // 函数签名: getOutcomeSlotCount(bytes32) returns (uint)
+            val getOutcomeSlotCountSelector = EthereumUtils.getFunctionSelector("getOutcomeSlotCount(bytes32)")
             val encodedConditionId = EthereumUtils.encodeBytes32(conditionId)
-            val data = functionSelector + encodedConditionId
+            val outcomeSlotCountData = getOutcomeSlotCountSelector + encodedConditionId
             
-            // 构建 JSON-RPC 请求
-            val rpcRequest = JsonRpcRequest(
+            val outcomeSlotCountRequest = JsonRpcRequest(
                 method = "eth_call",
                 params = listOf(
                     mapOf(
                         "to" to conditionalTokensAddress,
-                        "data" to data
+                        "data" to outcomeSlotCountData
                     ),
                     "latest"
                 )
             )
             
-            // 发送 RPC 请求
-            val response = rpcApi.call(rpcRequest)
+            val outcomeSlotCountResponse = rpcApi.call(outcomeSlotCountRequest)
             
-            if (!response.isSuccessful || response.body() == null) {
-                return Result.failure(Exception("RPC 请求失败: ${response.code()} ${response.message()}"))
+            if (!outcomeSlotCountResponse.isSuccessful || outcomeSlotCountResponse.body() == null) {
+                return Result.failure(Exception("RPC 请求失败 (getOutcomeSlotCount): ${outcomeSlotCountResponse.code()} ${outcomeSlotCountResponse.message()}"))
             }
             
-            val rpcResponse = response.body()!!
+            val outcomeSlotCountRpcResponse = outcomeSlotCountResponse.body()!!
             
-            // 检查错误
-            if (rpcResponse.error != null) {
-                return Result.failure(Exception("RPC 错误: ${rpcResponse.error.message}"))
+            if (outcomeSlotCountRpcResponse.error != null) {
+                val errorMsg = "RPC 错误 (code=${outcomeSlotCountRpcResponse.error.code}): ${outcomeSlotCountRpcResponse.error.message}, data=${outcomeSlotCountRpcResponse.error.data}"
+                logger.warn("查询市场条件(getOutcomeSlotCount)出现RPC错误: conditionId=$conditionId, $errorMsg")
+                logger.debug("RPC 请求详情: to=$conditionalTokensAddress, data=$outcomeSlotCountData")
+                return Result.failure(Exception(errorMsg))
             }
             
-            // 使用 Gson 解析 result（JsonElement）
-            val hexResult = rpcResponse.result?.asString 
+            val outcomeSlotCountHex = outcomeSlotCountRpcResponse.result?.asString 
                 ?: return Result.failure(Exception("RPC 响应格式错误: result 为空"))
             
-            // 解析 ABI 编码的返回结果
-            val (payoutDenominator, payouts) = EthereumUtils.decodeConditionResult(hexResult)
+            val outcomeSlotCount = EthereumUtils.decodeUint256(outcomeSlotCountHex).toInt()
+            
+            // 如果 outcomeSlotCount 为 0，说明市场尚未创建或不存在
+            if (outcomeSlotCount <= 0) {
+                logger.debug("市场尚未创建或不存在: conditionId=$conditionId, outcomeSlotCount=$outcomeSlotCount")
+                return Result.success(Pair(BigInteger.ZERO, emptyList()))
+            }
+            
+            // 2. 调用 payoutDenominator(bytes32) 获取分母
+            // 函数签名: payoutDenominator(bytes32) returns (uint)
+            val payoutDenominatorSelector = EthereumUtils.getFunctionSelector("payoutDenominator(bytes32)")
+            val payoutDenominatorData = payoutDenominatorSelector + encodedConditionId
+            
+            val payoutDenominatorRequest = JsonRpcRequest(
+                method = "eth_call",
+                params = listOf(
+                    mapOf(
+                        "to" to conditionalTokensAddress,
+                        "data" to payoutDenominatorData
+                    ),
+                    "latest"
+                )
+            )
+            
+            val payoutDenominatorResponse = rpcApi.call(payoutDenominatorRequest)
+            
+            if (!payoutDenominatorResponse.isSuccessful || payoutDenominatorResponse.body() == null) {
+                return Result.failure(Exception("RPC 请求失败 (payoutDenominator): ${payoutDenominatorResponse.code()} ${payoutDenominatorResponse.message()}"))
+            }
+            
+            val payoutDenominatorRpcResponse = payoutDenominatorResponse.body()!!
+            
+            if (payoutDenominatorRpcResponse.error != null) {
+                val errorMsg = "RPC 错误 (code=${payoutDenominatorRpcResponse.error.code}): ${payoutDenominatorRpcResponse.error.message}, data=${payoutDenominatorRpcResponse.error.data}"
+                logger.warn("查询市场条件(payoutDenominator)出现RPC错误: conditionId=$conditionId, $errorMsg")
+                logger.debug("RPC 请求详情: to=$conditionalTokensAddress, data=$payoutDenominatorData")
+                return Result.failure(Exception(errorMsg))
+            }
+            
+            val payoutDenominatorHex = payoutDenominatorRpcResponse.result?.asString 
+                ?: return Result.failure(Exception("RPC 响应格式错误: result 为空"))
+            
+            val payoutDenominator = EthereumUtils.decodeUint256(payoutDenominatorHex)
+            
+            // 如果 outcomeSlotCount 为 0，说明市场尚未创建或不存在
+            if (outcomeSlotCount <= 0) {
+                logger.debug("市场尚未创建或不存在: conditionId=$conditionId, outcomeSlotCount=$outcomeSlotCount")
+                return Result.success(Pair(BigInteger.ZERO, emptyList()))
+            }
+            
+            // 如果 payoutDenominator 为 0，说明市场尚未结算
+            if (payoutDenominator == BigInteger.ZERO) {
+                logger.debug("市场尚未结算: conditionId=$conditionId, payoutDenominator=$payoutDenominator")
+                return Result.success(Pair(BigInteger.ZERO, emptyList()))
+            }
+            
+            // 2. 查询每个 outcome 的 payoutNumerators
+            val payouts = mutableListOf<BigInteger>()
+            for (i in 0 until outcomeSlotCount) {
+                val payoutNumeratorsFunctionSelector = EthereumUtils.getFunctionSelector("payoutNumerators(bytes32,uint256)")
+                val encodedIndex = EthereumUtils.encodeUint256(BigInteger.valueOf(i.toLong()))
+                val payoutNumeratorsData = payoutNumeratorsFunctionSelector + encodedConditionId + encodedIndex
+                
+                val payoutRequest = JsonRpcRequest(
+                    method = "eth_call",
+                    params = listOf(
+                        mapOf(
+                            "to" to conditionalTokensAddress,
+                            "data" to payoutNumeratorsData
+                        ),
+                        "latest"
+                    )
+                )
+                
+                val payoutResponse = rpcApi.call(payoutRequest)
+                if (!payoutResponse.isSuccessful || payoutResponse.body() == null) {
+                    logger.warn("查询 payoutNumerators 失败: index=$i")
+                    continue
+                }
+                
+                val payoutRpcResponse = payoutResponse.body()!!
+                if (payoutRpcResponse.error != null) {
+                    logger.warn("查询 payoutNumerators 错误: index=$i, error=${payoutRpcResponse.error.message}")
+                    continue
+                }
+                
+                val payoutHex = payoutRpcResponse.result?.asString ?: "0x0"
+                val payout = EthereumUtils.decodeUint256(payoutHex)
+                payouts.add(payout)
+            }
             
             Result.success(Pair(payoutDenominator, payouts))
         } catch (e: Exception) {

backend/src/main/kotlin/com/wrbug/polymarketbot/service/common/MarketPriceService.kt

@@ -31,7 +31,8 @@ class MarketPriceService(
      * 获取当前市场最新价
      * 优先级：
      * 1. 链上查询市场结算结果（如果已结算，返回 1.0 或 0.0）
-     * 2. CLOB API 查询订单簿价格（最准确，使用 bestBid）
+     * 2. CLOB API 查询订单簿价格（最准确，优先使用，使用 bestBid）
+     * 3. Gamma Market API 查询市场价格（快速，作为备选）
      * 
      * 价格会被截位到 4 位小数（向下截断，不四舍五入），用于显示和后续计算
      * 
@@ -42,21 +43,35 @@ class MarketPriceService(
      */
     suspend fun getCurrentMarketPrice(marketId: String, outcomeIndex: Int): BigDecimal {
         // 1. 优先从链上查询市场结算结果
-        val chainPrice = getPriceFromChainCondition(marketId, outcomeIndex)
+        val (chainPrice, hasRpcError) = getPriceFromChainCondition(marketId, outcomeIndex)
         if (chainPrice != null) {
             // 截位到 4 位小数（向下截断，不四舍五入）
             return chainPrice.setScale(4, java.math.RoundingMode.DOWN)
         }
         
-        // 2. 从 CLOB API 查询订单簿价格（最准确）
+        // 如果链上查询出现 RPC 错误（execution reverted），说明市场可能不存在或尚未创建
+        // 在这种情况下，降级到其他数据源（CLOB API 或 Gamma API），而不是直接抛出异常
+        // 因为 marketId 可能在 API 中存在，但在链上尚未创建
+        if (hasRpcError) {
+            logger.debug("链上查询市场条件出现 RPC 错误（execution reverted），降级到 API 查询: marketId=$marketId, outcomeIndex=$outcomeIndex")
+        }
+        
+        // 2. 从 CLOB API 查询订单簿价格（最准确，优先使用）
         val orderbookPrice = getPriceFromClobOrderbook(marketId, outcomeIndex)
         if (orderbookPrice != null) {
             // 截位到 4 位小数（向下截断，不四舍五入）
             return orderbookPrice.setScale(4, java.math.RoundingMode.DOWN)
         }
         
+        // 3. 从 Gamma Market API 查询市场价格（作为备选）
+        val marketPrice = getPriceFromGammaMarket(marketId, outcomeIndex)
+        if (marketPrice != null) {
+            // 截位到 4 位小数（向下截断，不四舍五入）
+            return marketPrice.setScale(4, java.math.RoundingMode.DOWN)
+        }
+        
         // 如果所有数据源都失败，抛出异常
-        val errorMsg = "无法获取市场价格: marketId=$marketId, outcomeIndex=$outcomeIndex (链上查询和订单簿查询均失败)"
+        val errorMsg = "无法获取市场价格: marketId=$marketId, outcomeIndex=$outcomeIndex (链上查询、订单簿查询和 Market API 均失败)"
         logger.error(errorMsg)
         throw IllegalStateException(errorMsg)
     }
@@ -67,8 +82,10 @@ class MarketPriceService(
      *   - payout > 0（赢了）→ 返回 1.0
      *   - payout == 0（输了）→ 返回 0.0
      * 如果市场未结算或查询失败，返回 null
+     * 
+     * @return Pair<BigDecimal?, Boolean> 第一个值是价格（如果已结算），第二个值表示是否发生了 RPC 错误（execution reverted）
      */
-    private suspend fun getPriceFromChainCondition(marketId: String, outcomeIndex: Int): BigDecimal? {
+    private suspend fun getPriceFromChainCondition(marketId: String, outcomeIndex: Int): Pair<BigDecimal?, Boolean> {
         return try {
             val chainResult = blockchainService.getCondition(marketId)
             chainResult.fold(
@@ -79,29 +96,95 @@ class MarketPriceService(
                         when {
                             payout > BigInteger.ZERO -> {
                                 logger.info("从链上查询到市场已结算，该 outcome 赢了: marketId=$marketId, outcomeIndex=$outcomeIndex, payout=$payout")
-                                return BigDecimal.ONE
+                                return Pair(BigDecimal.ONE, false)
                             }
                             payout == BigInteger.ZERO -> {
                                 logger.info("从链上查询到市场已结算，该 outcome 输了: marketId=$marketId, outcomeIndex=$outcomeIndex, payout=$payout")
-                                return BigDecimal.ZERO
+                                return Pair(BigDecimal.ZERO, false)
                             }
                             else -> {
                                 logger.warn("从链上查询到异常的 payout 值: marketId=$marketId, outcomeIndex=$outcomeIndex, payout=$payout")
-                                null
+                                Pair(null, false)
                             }
                         }
                     } else {
                         logger.debug("从链上查询到市场尚未结算: marketId=$marketId, payouts=${payouts.size}")
-                        null
+                        Pair(null, false)
                     }
                 },
                 onFailure = { e ->
+                    // 检查是否是 execution reverted 错误
+                    val isRpcError = e.message?.contains("execution reverted", ignoreCase = true) == true
+                    if (isRpcError) {
+                        logger.warn("链上查询市场条件出现 RPC 错误（execution reverted），可能市场不存在或尚未创建: marketId=$marketId, error=${e.message}")
+                    } else {
                     logger.debug("链上查询市场条件失败，降级到 API 查询: marketId=$marketId, error=${e.message}")
-                    null
+                    }
+                    Pair(null, isRpcError)
                 }
             )
         } catch (e: Exception) {
+            val isRpcError = e.message?.contains("execution reverted", ignoreCase = true) == true
+            if (isRpcError) {
+                logger.warn("链上查询市场条件异常（execution reverted）: marketId=$marketId, outcomeIndex=$outcomeIndex, error=${e.message}")
+            } else {
             logger.debug("链上查询市场条件异常: marketId=$marketId, outcomeIndex=$outcomeIndex, error=${e.message}")
+            }
+            Pair(null, isRpcError)
+        }
+    }
+    
+    /**
+     * 从 Gamma Market API 获取价格
+     * 使用 outcomePrices 字段，格式通常为 JSON 字符串 "[\"0.5\", \"0.5\"]"
+     * 如果查询失败或 outcomePrices 为空，返回 null
+     */
+    private suspend fun getPriceFromGammaMarket(marketId: String, outcomeIndex: Int): BigDecimal? {
+        return try {
+            val gammaApi = retrofitFactory.createGammaApi()
+            val marketResponse = gammaApi.listMarkets(conditionIds = listOf(marketId))
+            
+            if (!marketResponse.isSuccessful || marketResponse.body() == null) {
+                logger.debug("Gamma Market API 查询失败: marketId=$marketId, code=${marketResponse.code()}")
+                return null
+            }
+            
+            val markets = marketResponse.body()!!
+            if (markets.isEmpty()) {
+                logger.debug("Gamma Market API 未找到市场: marketId=$marketId")
+                return null
+            }
+            
+            val market = markets.first()
+            
+            // 尝试从 outcomePrices 字段获取价格
+            val outcomePricesStr = market.outcomePrices
+            if (outcomePricesStr.isNullOrBlank()) {
+                logger.debug("Market outcomePrices 为空: marketId=$marketId")
+                return null
+            }
+            
+            // 解析 outcomePrices（通常是 JSON 数组字符串）
+            val outcomePrices = try {
+                // 移除首尾的方括号和引号，按逗号分割
+                val cleanStr = outcomePricesStr.trim().removeSurrounding("[", "]")
+                cleanStr.split(",").map { 
+                    it.trim().removeSurrounding("\"").toSafeBigDecimal() 
+                }
+            } catch (e: Exception) {
+                logger.warn("解析 outcomePrices 失败: marketId=$marketId, outcomePrices=$outcomePricesStr, error=${e.message}")
+                null
+            }
+            
+            if (outcomePrices != null && outcomeIndex < outcomePrices.size) {
+                val price = outcomePrices[outcomeIndex]
+                logger.debug("从 Gamma Market API 获取价格: marketId=$marketId, outcomeIndex=$outcomeIndex, price=$price")
+                return price
+            }
+            
+            null
+        } catch (e: Exception) {
+            logger.debug("Gamma Market API 查询异常: marketId=$marketId, outcomeIndex=$outcomeIndex, error=${e.message}")
             null
         }
     }

backend/src/main/kotlin/com/wrbug/polymarketbot/service/common/PolymarketClobService.kt

@@ -401,5 +401,37 @@ class PolymarketClobService(
             Result.failure(e)
         }
     }
+    
+    /**
+     * 获取费率
+     * 文档: https://docs.polymarket.com/developers/market-makers/maker-rebates-program#1-fetch-the-fee-rate
+     * 
+     * 注意：根据 TypeScript clob-client 源码，API 返回的字段名是 base_fee，而不是文档中的 fee_rate_bps
+     * 参考: clob-client/src/client.ts:312
+     * 
+     * @param tokenId Token ID
+     * @return 费率基点（0 表示无费率，1000 表示 10%）
+     */
+    suspend fun getFeeRate(tokenId: String): Result<Int> {
+        return try {
+            val response = clobApi.getFeeRate(tokenId)
+            if (response.isSuccessful && response.body() != null) {
+                val baseFee = response.body()!!.baseFee
+                logger.debug("获取费率成功: tokenId=$tokenId, baseFee=$baseFee")
+                Result.success(baseFee)
+            } else {
+                val errorBody = try {
+                    response.errorBody()?.string()
+                } catch (e: Exception) {
+                    null
+                }
+                logger.error("获取费率失败: tokenId=$tokenId, code=${response.code()}, errorBody=$errorBody")
+                Result.failure(Exception("获取费率失败: ${response.code()} ${response.message()}"))
+            }
+        } catch (e: Exception) {
+            logger.error("获取费率异常: tokenId=$tokenId, error=${e.message}", e)
+            Result.failure(e)
+        }
+    }
 }
 

backend/src/main/kotlin/com/wrbug/polymarketbot/service/copytrading/configs/CopyTradingFilterService.kt

@@ -9,6 +9,7 @@ import com.wrbug.polymarketbot.util.toSafeBigDecimal
 import org.slf4j.LoggerFactory
 import com.wrbug.polymarketbot.service.common.PolymarketClobService
 import com.wrbug.polymarketbot.service.accounts.AccountService
+import com.wrbug.polymarketbot.repository.CopyOrderTrackingRepository
 import org.springframework.stereotype.Service
 import java.math.BigDecimal
 
@@ -18,7 +19,8 @@ import java.math.BigDecimal
 @Service
 class CopyTradingFilterService(
     private val clobService: PolymarketClobService,
-    private val accountService: AccountService
+    private val accountService: AccountService,
+    private val copyOrderTrackingRepository: CopyOrderTrackingRepository
 ) {
     
     private val logger = LoggerFactory.getLogger(CopyTradingFilterService::class.java)
@@ -234,32 +236,46 @@ class CopyTradingFilterService(
             
             // 检查最大仓位金额（如果配置了）
             if (copyTrading.maxPositionValue != null) {
-                // 计算该市场的当前仓位总价值（累加该市场所有仓位的 currentValue）
-                val currentPositionValue = marketPositions.sumOf { position ->
-                    position.currentValue.toSafeBigDecimal()
-                }
+                // 比较数据库成本价（本地订单记录）和外部持仓市值（可能来自其他终端的操作），取最大值
+                val dbValue = copyOrderTrackingRepository.sumCurrentPositionValueByMarket(copyTrading.id!!, marketId) ?: BigDecimal.ZERO
+                val extValue = marketPositions.sumOf { it.currentValue.toSafeBigDecimal() }
+                val currentPositionValue = dbValue.max(extValue)
                 
                 // 检查：该市场的当前仓位 + 跟单金额 <= 最大仓位金额
                 val totalValueAfterOrder = currentPositionValue.add(copyOrderAmount)
                 
                 if (totalValueAfterOrder.gt(copyTrading.maxPositionValue)) {
                     return FilterResult.maxPositionValueFailed(
-                        "超过最大仓位金额限制: 当前该市场仓位=${currentPositionValue} USDC, 跟单金额=${copyOrderAmount} USDC, 总计=${totalValueAfterOrder} USDC > 最大限制=${copyTrading.maxPositionValue} USDC"
+                        "超过最大仓位金额限制: 当前该市场仓位(取最大值)=${currentPositionValue} USDC (DB=${dbValue}, Ext=${extValue}), 跟单金额=${copyOrderAmount} USDC, 总计=${totalValueAfterOrder} USDC > 最大限制=${copyTrading.maxPositionValue} USDC"
                     )
                 }
             }
             
             // 检查最大仓位数量（如果配置了）
             if (copyTrading.maxPositionCount != null) {
-                // 计算该市场的当前仓位数量（该市场不同方向的仓位算不同仓位）
-                val currentPositionCount = marketPositions.size
+                // 使用数据库中的订单记录计算活跃仓位数量（解决延迟问题）
+                val dbCount = copyOrderTrackingRepository.countActivePositions(copyTrading.id!!)
                 
-                // 检查：该市场的当前仓位数量 <= 最大仓位数量
-                // 注意：如果该市场已有仓位，跟单可能会增加新的仓位（不同方向）或增加现有仓位
-                // 为了简化，我们检查当前该市场的仓位数量是否已经达到或超过限制
-                if (currentPositionCount >= copyTrading.maxPositionCount) {
+                // 计算外部持仓中的唯一市场数量（防止遗漏非本项目创建的仓位）
+                val extCount = positions.currentPositions
+                    .filter { it.accountId == copyTrading.accountId }
+                    .map { it.marketId }
+                    .distinct()
+                    .size
+                
+                val currentPositionCount = maxOf(dbCount, extCount)
+                
+                // 检查：如果当前没有该市场的活跃仓位，且总仓位数量已达到限制，则不允许开新仓
+                // 判断当前市场是否已有活跃仓位（数据库或外部持仓）
+                val hasDbPosition = copyOrderTrackingRepository.existsByCopyTradingIdAndMarketIdAndRemainingQuantityGreaterThan(
+                    copyTrading.id, marketId, BigDecimal.ZERO
+                )
+                val hasExtPosition = marketPositions.isNotEmpty()
+                val hasCurrentMarketPosition = hasDbPosition || hasExtPosition
+                
+                if (!hasCurrentMarketPosition && currentPositionCount >= copyTrading.maxPositionCount) {
                     return FilterResult.maxPositionCountFailed(
-                        "超过最大仓位数量限制: 当前该市场仓位数量=${currentPositionCount} >= 最大限制=${copyTrading.maxPositionCount}"
+                        "超过最大仓位数量限制: 当前活跃仓位总数(取最大值)=${currentPositionCount} (DB=${dbCount}, Ext=${extCount}) >= 最大限制=${copyTrading.maxPositionCount}"
                     )
                 }
             }

backend/src/main/kotlin/com/wrbug/polymarketbot/service/copytrading/monitor/CopyTradingMonitorService.kt

@@ -14,7 +14,7 @@ import org.springframework.stereotype.Service
 /**
  * 跟单监听服务（主服务）
  * 管理所有Leader的交易监听
- * 同时运行链上 WebSocket 监听和轮询监听（并行处理）
+ * 使用链上 WebSocket 监听 Leader 的交易（实时，秒级延迟）
  * 同时监听跟单账户的卖出/赎回事件（通过链上 WebSocket）
  */
 @Service
@@ -22,7 +22,6 @@ class CopyTradingMonitorService(
     private val copyTradingRepository: CopyTradingRepository,
     private val leaderRepository: LeaderRepository,
     private val accountRepository: AccountRepository,
-    private val pollingService: CopyTradingPollingService,
     private val onChainWsService: OnChainWsService,
     private val accountOnChainMonitorService: AccountOnChainMonitorService
 ) {
@@ -51,15 +50,14 @@ class CopyTradingMonitorService(
     @PreDestroy
     fun destroy() {
         scope.cancel()
-        // 停止轮询和链上 WS 监听
-        pollingService.stop()
+        // 停止链上 WS 监听
         onChainWsService.stop()
         accountOnChainMonitorService.stop()
     }
     
     /**
      * 启动监听
-     * 同时启动链上 WebSocket 监听和轮询监听（并行运行）
+     * 启动链上 WebSocket 监听 Leader 的交易（实时，秒级延迟）
      * 同时启动跟单账户的链上 WebSocket 监听（用于检测卖出/赎回事件）
      */
     suspend fun startMonitoring() {
@@ -82,13 +80,9 @@ class CopyTradingMonitorService(
             accountRepository.findById(accountId).orElse(null)
         }
         
-        // 4. 同时启动链上 WebSocket 监听和轮询监听（并行运行）
-        // 链上 WS 监听 Leader 的交易（实时，秒级延迟）
+        // 4. 启动链上 WebSocket 监听 Leader 的交易（实时，秒级延迟）
         onChainWsService.start(leaders)
         
-        // 轮询监听 Leader 的交易（延迟，2秒间隔，作为备份）
-        pollingService.start(leaders)
-        
         // 5. 启动跟单账户的链上 WebSocket 监听（用于检测卖出/赎回事件）
         accountOnChainMonitorService.start(accounts)
     }
@@ -106,9 +100,8 @@ class CopyTradingMonitorService(
             return
         }
         
-        // 同时添加到链上 WS 监听和轮询监听（如果不在列表中才添加）
+        // 添加到链上 WS 监听（如果不在列表中才添加）
         onChainWsService.addLeader(leader)
-        pollingService.addLeader(leader)
     }
     
     /**
@@ -124,7 +117,6 @@ class CopyTradingMonitorService(
         
         // 没有启用的跟单配置了，移除监听
         onChainWsService.removeLeader(leaderId)
-        pollingService.removeLeader(leaderId)
     }
     
     /**
@@ -139,7 +131,6 @@ class CopyTradingMonitorService(
         if (copyTradings.isNotEmpty()) {
             // 有启用的跟单配置，确保在监听列表中
             onChainWsService.addLeader(leader)
-            pollingService.addLeader(leader)
             
             // 更新账户监听（添加该配置关联的账户）
             val accountIds = copyTradings.map { it.accountId }.distinct()
@@ -152,7 +143,6 @@ class CopyTradingMonitorService(
         } else {
             // 没有启用的跟单配置，移除监听
             onChainWsService.removeLeader(leaderId)
-            pollingService.removeLeader(leaderId)
         }
     }
     
@@ -182,7 +172,6 @@ class CopyTradingMonitorService(
     suspend fun restartMonitoring() {
         // 停止所有监听
         onChainWsService.stop()
-        pollingService.stop()
         delay(1000)  // 等待1秒
         startMonitoring()
     }

backend/src/main/kotlin/com/wrbug/polymarketbot/service/copytrading/monitor/CopyTradingPollingService.kt

@@ -1,279 +0,0 @@
-package com.wrbug.polymarketbot.service.copytrading.monitor
-
-import com.wrbug.polymarketbot.api.TradeResponse
-import com.wrbug.polymarketbot.api.UserActivityResponse
-import com.wrbug.polymarketbot.entity.Leader
-import com.wrbug.polymarketbot.repository.CopyTradingTemplateRepository
-import com.wrbug.polymarketbot.util.RetrofitFactory
-import jakarta.annotation.PreDestroy
-import kotlinx.coroutines.*
-import org.slf4j.LoggerFactory
-import org.springframework.beans.factory.annotation.Value
-import com.wrbug.polymarketbot.service.copytrading.statistics.CopyOrderTrackingService
-import org.springframework.stereotype.Service
-import retrofit2.Response
-import java.util.concurrent.ConcurrentHashMap
-
-/**
- * 跟单轮询监听服务
- * 通过定期轮询 Polymarket Data API 的 /activity 接口获取Leader的交易记录
- * 使用 /activity 接口可以查询用户的链上活动，包括交易
- */
-@Service
-class CopyTradingPollingService(
-    private val copyOrderTrackingService: CopyOrderTrackingService,
-    private val retrofitFactory: RetrofitFactory,
-    private val templateRepository: CopyTradingTemplateRepository
-) {
-    
-    private val logger = LoggerFactory.getLogger(CopyTradingPollingService::class.java)
-    
-    @Value("\${copy.trading.polling.interval:2000}")
-    private var pollingInterval: Long = 2000  // 轮询间隔（毫秒），默认2秒
-    
-    @Value("\${copy.trading.polling.enabled:true}")
-    private var pollingEnabled: Boolean = true  // 是否启用轮询
-    
-    private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
-    
-    // 存储需要监听的Leader：leaderId -> Leader
-    private val monitoredLeaders = ConcurrentHashMap<Long, Leader>()
-    
-    // 存储每个Leader已缓存的交易ID集合：leaderId -> Set<tradeId>
-    private val cachedTradeIds = ConcurrentHashMap<Long, MutableSet<String>>()
-    
-    // 存储每个Leader是否首次轮询：leaderId -> isFirstPoll
-    private val isFirstPoll = ConcurrentHashMap<Long, Boolean>()
-    
-    // 轮询任务
-    private var pollingJob: Job? = null
-    
-    /**
-     * 启动轮询监听
-     */
-    fun start(leaders: List<Leader>) {
-        if (!pollingEnabled) {
-            return
-        }
-        
-        leaders.forEach { leader ->
-            addLeader(leader)
-        }
-        
-        // 启动轮询任务
-        startPolling()
-    }
-    
-    /**
-     * 添加Leader监听
-     */
-    fun addLeader(leader: Leader) {
-        if (leader.id == null) {
-            logger.warn("Leader ID为空，跳过: ${leader.leaderAddress}")
-            return
-        }
-        
-        val leaderId = leader.id
-        monitoredLeaders[leaderId] = leader
-        // 初始化缓存的交易ID集合
-        cachedTradeIds[leaderId] = mutableSetOf()
-        // 首次轮询标志，用于缓存数据而不处理
-        isFirstPoll[leaderId] = true
-        
-        // 如果轮询任务没有运行，启动它
-        startPolling()
-    }
-    
-    /**
-     * 移除Leader监听
-     */
-    fun removeLeader(leaderId: Long) {
-        monitoredLeaders.remove(leaderId)
-        cachedTradeIds.remove(leaderId)
-        isFirstPoll.remove(leaderId)
-        
-        // 如果没有需要监听的Leader了，停止轮询任务
-        if (monitoredLeaders.isEmpty()) {
-            stopPolling()
-        }
-    }
-    
-    /**
-     * 停止所有监听
-     */
-    fun stop() {
-        stopPolling()
-        monitoredLeaders.clear()
-        cachedTradeIds.clear()
-        isFirstPoll.clear()
-    }
-    
-    /**
-     * 启动轮询任务
-     */
-    private fun startPolling() {
-        if (pollingJob != null && pollingJob!!.isActive) {
-            return
-        }
-        
-        if (monitoredLeaders.isEmpty()) {
-            return
-        }
-        
-        pollingJob = scope.launch {
-            
-            while (isActive) {
-                try {
-                    // 轮询所有Leader的交易
-                    pollAllLeaders()
-                    
-                    // 等待下一次轮询
-                    delay(pollingInterval)
-                } catch (e: Exception) {
-                    logger.error("轮询任务异常", e)
-                    delay(pollingInterval)  // 异常后继续等待
-                }
-            }
-        }
-    }
-    
-    /**
-     * 停止轮询任务
-     */
-    private fun stopPolling() {
-        pollingJob?.cancel()
-        pollingJob = null
-    }
-    
-    /**
-     * 轮询所有Leader的交易
-     */
-    private suspend fun pollAllLeaders() {
-        val leaders = monitoredLeaders.values.toList()
-        
-        if (leaders.isEmpty()) {
-            return
-        }
-        
-        // 并发轮询所有Leader（限制并发数）
-        leaders.chunked(10).forEach { chunk ->
-            chunk.forEach { leader ->
-                try {
-                    pollLeaderTrades(leader)
-                } catch (e: Exception) {
-                    logger.error("轮询Leader交易失败: leaderId=${leader.id}, address=${leader.leaderAddress}", e)
-                }
-            }
-            // 每个chunk之间稍作延迟，避免API限流
-            delay(100)
-        }
-    }
-    
-    /**
-     * 轮询单个Leader的交易
-     * 使用 Polymarket Data API 的 /activity 接口
-     * 通过 diff 分析增量数据，不使用 start 字段
-     */
-    private suspend fun pollLeaderTrades(leader: Leader) {
-        if (leader.id == null) {
-            return
-        }
-        
-        val leaderId = leader.id
-        val leaderAddress = leader.leaderAddress
-        
-        try {
-            val firstPoll = isFirstPoll[leaderId] == true
-            val cachedIds = cachedTradeIds[leaderId] ?: mutableSetOf()
-            
-            // 创建 Data API 客户端（不需要认证）
-            val dataApi = retrofitFactory.createDataApi()
-            
-            // 查询用户活动（只查询交易类型，不使用 start 字段）
-            // 查询最近的数据（limit=100），通过 diff 找出增量
-            val response: Response<List<UserActivityResponse>> = dataApi.getUserActivity(
-                user = leaderAddress,
-                limit = 100,  // 每次最多查询100条
-                offset = 0,
-                type = listOf("TRADE"),  // 只查询交易类型
-                start = null,  // 不使用 start 字段
-                sortBy = "TIMESTAMP",
-                sortDirection = "DESC"  // 按时间戳降序，最新的在前
-            )
-            
-            if (!response.isSuccessful || response.body() == null) {
-                logger.warn("获取Leader活动失败: leaderId=$leaderId, address=$leaderAddress, code=${response.code()}, message=${response.message()}")
-                return
-            }
-            
-            val activities = response.body()!!
-            
-            // 将 UserActivityResponse 转换为 TradeResponse
-            val allTrades = activities.mapNotNull { activity ->
-                // 只处理交易类型
-                if (activity.type != "TRADE" || activity.side == null || activity.price == null || activity.size == null) {
-                    return@mapNotNull null
-                }
-                
-                // 转换为 TradeResponse
-                TradeResponse(
-                    id = activity.transactionHash ?: "${activity.timestamp}_${activity.conditionId}",
-                    market = activity.conditionId,
-                    side = activity.side,  // BUY 或 SELL
-                    price = activity.price.toString(),
-                    size = activity.size.toString(),
-                    timestamp = activity.timestamp.toString(),  // 时间戳（秒）
-                    user = activity.proxyWallet,
-                    outcomeIndex = activity.outcomeIndex,  // 结果索引（0=YES, 1=NO）
-                    outcome = activity.outcome  // 结果名称
-                )
-            }
-            
-            if (firstPoll) {
-                // 首次轮询：缓存所有查询到的交易ID，不处理
-                val tradeIds = allTrades.map { it.id }.toSet()
-                cachedIds.addAll(tradeIds)
-                cachedTradeIds[leaderId] = cachedIds
-                
-                // 标记首次轮询完成
-                isFirstPoll[leaderId] = false
-            } else {
-                // 后续轮询：通过 diff 找出新增的交易
-                val newTradeIds = allTrades.map { it.id }.toSet()
-                val incrementalTradeIds = newTradeIds - cachedIds
-                
-                if (incrementalTradeIds.isNotEmpty()) {
-                    // 找出新增的交易
-                    val incrementalTrades = allTrades.filter { it.id in incrementalTradeIds }
-                    
-                    
-                    // 处理新增的交易
-                    incrementalTrades.forEach { trade ->
-                        try {
-                            // 检查是否已处理（去重由processTrade内部处理）
-                            copyOrderTrackingService.processTrade(leaderId, trade, "polling")
-                        } catch (e: Exception) {
-                            logger.error("处理交易失败: leaderId=$leaderId, tradeId=${trade.id}", e)
-                        }
-                    }
-                    
-                    // 更新缓存：添加新增的交易ID
-                    cachedIds.addAll(incrementalTradeIds)
-                    cachedTradeIds[leaderId] = cachedIds
-                    
-                } else {
-                }
-                
-                // 限制缓存大小，避免内存溢出（只保留最近1000条）
-                if (cachedIds.size > 1000) {
-                    // 保留最新的1000条（由于查询是按时间戳降序，保留前1000条即可）
-                    val sortedTradeIds = allTrades.map { it.id }.take(1000).toSet()
-                    cachedTradeIds[leaderId] = sortedTradeIds.toMutableSet()
-                }
-            }
-        } catch (e: Exception) {
-            logger.error("轮询Leader交易异常: leaderId=$leaderId, address=$leaderAddress", e)
-        }
-    }
-}
-

backend/src/main/kotlin/com/wrbug/polymarketbot/service/copytrading/monitor/OnChainWsService.kt

@@ -89,6 +89,8 @@ class OnChainWsService(
     private suspend fun handleLeaderTransaction(leaderId: Long, txHash: String, httpClient: OkHttpClient, rpcApi: EthereumRpcApi) {
         val leader = monitoredLeaders[leaderId] ?: return
         
+        logger.debug("开始处理 Leader 交易: leaderId=$leaderId, txHash=$txHash, leaderAddress=${leader.leaderAddress}")
+        
         try {
             // 获取交易 receipt
             val receiptRequest = JsonRpcRequest(
@@ -98,11 +100,13 @@ class OnChainWsService(
             
             val receiptResponse = rpcApi.call(receiptRequest)
             if (!receiptResponse.isSuccessful || receiptResponse.body() == null) {
+                logger.warn("获取交易 receipt 失败: leaderId=$leaderId, txHash=$txHash, code=${receiptResponse.code()}")
                 return
             }
             
             val receiptRpcResponse = receiptResponse.body()!!
             if (receiptRpcResponse.error != null || receiptRpcResponse.result == null) {
+                logger.warn("交易 receipt 错误: leaderId=$leaderId, txHash=$txHash, error=${receiptRpcResponse.error}")
                 return
             }
             
@@ -118,8 +122,12 @@ class OnChainWsService(
             }
             
             // 解析 receipt 中的 Transfer 日志
-            val logs = receiptJson.getAsJsonArray("logs") ?: return
+            val logs = receiptJson.getAsJsonArray("logs") ?: run {
+                logger.warn("交易 receipt 中没有日志: leaderId=$leaderId, txHash=$txHash")
+                return
+            }
             val (erc20Transfers, erc1155Transfers) = OnChainWsUtils.parseReceiptTransfers(logs)
+            logger.debug("解析交易日志: leaderId=$leaderId, txHash=$txHash, erc20Transfers=${erc20Transfers.size}, erc1155Transfers=${erc1155Transfers.size}")
             
             // 解析交易信息
             val trade = OnChainWsUtils.parseTradeFromTransfers(
@@ -132,12 +140,15 @@ class OnChainWsService(
             )
             
             if (trade != null) {
+                logger.info("成功解析交易: leaderId=$leaderId, txHash=$txHash, side=${trade.side}, market=${trade.market}, size=${trade.size}")
                 // 调用 processTrade 处理交易
                 copyOrderTrackingService.processTrade(
                     leaderId = leaderId,
                     trade = trade,
                     source = "onchain-ws"
                 )
+            } else {
+                logger.warn("无法解析交易（返回 null）: leaderId=$leaderId, txHash=$txHash, erc20Transfers=${erc20Transfers.size}, erc1155Transfers=${erc1155Transfers.size}")
             }
         } catch (e: Exception) {
             logger.error("处理 Leader 交易失败: leaderId=$leaderId, txHash=$txHash, ${e.message}", e)

backend/src/main/kotlin/com/wrbug/polymarketbot/service/copytrading/monitor/OnChainWsUtils.kt

@@ -207,6 +207,7 @@ object OnChainWsUtils {
             usdcRaw = usdcIn
         } else {
             // 无法判断交易方向
+            logger.debug("无法判断交易方向: txHash=$txHash, bestInId=$bestInId, bestInVal=$bestInVal, bestOutId=$bestOutId, bestOutVal=$bestOutVal, usdcOut=$usdcOut, usdcIn=$usdcIn")
             return null
         }
         

backend/src/main/kotlin/com/wrbug/polymarketbot/service/copytrading/monitor/UnifiedOnChainWsService.kt

@@ -1,6 +1,7 @@
 package com.wrbug.polymarketbot.service.copytrading.monitor
 
 import com.google.gson.Gson
+import com.google.gson.JsonArray
 import com.google.gson.JsonObject
 import com.wrbug.polymarketbot.api.*
 import com.wrbug.polymarketbot.service.system.RpcNodeService
@@ -19,6 +20,7 @@ import org.slf4j.LoggerFactory
 import org.springframework.beans.factory.annotation.Value
 import org.springframework.stereotype.Service
 import java.util.concurrent.ConcurrentHashMap
+import java.util.concurrent.atomic.AtomicInteger
 
 /**
  * 统一的链上 WebSocket 服务
@@ -38,27 +40,8 @@ class UnifiedOnChainWsService(
     
     private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
     
-    // WebSocket 连接（唯一）
-    private var webSocket: WebSocket? = null
-    @Volatile
-    private var isConnected = false
-    
-    // 订阅ID计数器（用于请求 ID）
-    private var requestIdCounter = 0
-    
-    // 连接任务（确保只有一个连接任务在运行）
-    private var connectionJob: Job? = null
-    
-    // 存储所有订阅：subscriptionId -> 订阅信息
-    private val subscriptions = ConcurrentHashMap<String, SubscriptionInfo>()
-    
-    // 存储请求 ID 到订阅 ID 的映射：requestId -> subscriptionId
-    // 用于在收到订阅响应时，将 subscription ID 关联到对应的订阅
-    private val requestIdToSubscriptionId = ConcurrentHashMap<Int, String>()
-    
-    // 存储 RPC subscriptionId 到订阅 ID 的映射：rpcSubscriptionId -> subscriptionId
-    // 用于在收到日志通知时，知道是哪个订阅
-    private val rpcSubscriptionIdToSubscriptionId = ConcurrentHashMap<String, String>()
+    // 存储所有地址的连接：address -> AddressWsConnection
+    private val addressConnections = ConcurrentHashMap<String, AddressWsConnection>()
     
     /**
      * 订阅信息
@@ -88,31 +71,24 @@ class UnifiedOnChainWsService(
         callback: suspend (String, OkHttpClient, EthereumRpcApi) -> Unit
     ): Boolean {
         try {
-            // 如果已经订阅，先取消
-            if (subscriptions.containsKey(subscriptionId)) {
-                unsubscribe(subscriptionId)
+            val lowerAddress = address.lowercase()
+            
+            // 找到或创建该地址的连接
+            val connection = addressConnections.computeIfAbsent(lowerAddress) {
+                AddressWsConnection(it).apply { start() }
             }
             
             // 创建订阅信息
             val subscription = SubscriptionInfo(
                 subscriptionId = subscriptionId,
-                address = address.lowercase(),
+                address = lowerAddress,
                 entityType = entityType,
                 entityId = entityId,
                 callback = callback
             )
             
-            subscriptions[subscriptionId] = subscription
-            
-            // 如果已连接，立即订阅
-            if (isConnected) {
-                scope.launch {
-                    subscribeAddress(subscription)
-                }
-            } else {
-                // 如果未连接，启动连接
-                startConnection()
-            }
+            // 添加订阅
+            connection.addSubscription(subscription)
             
             logger.info("订阅地址监听: subscriptionId=$subscriptionId, address=$address, entityType=$entityType, entityId=$entityId")
             return true
@@ -126,434 +102,37 @@ class UnifiedOnChainWsService(
      * 取消订阅
      */
     fun unsubscribe(subscriptionId: String) {
-        val subscription = subscriptions.remove(subscriptionId)
-        
-        if (subscription != null && isConnected) {
-            // 取消该订阅的所有 RPC 订阅
-            scope.launch {
-                // 查找该订阅的所有 RPC subscriptionId
-                val rpcSubscriptionIds = rpcSubscriptionIdToSubscriptionId.entries
-                    .filter { it.value == subscriptionId }
-                    .map { it.key }
+        // 遍历所有连接找到含有该订阅的连接
+        for (connection in addressConnections.values) {
+            if (connection.hasSubscription(subscriptionId)) {
+                connection.removeSubscription(subscriptionId)
                 
-                for (rpcSubId in rpcSubscriptionIds) {
-                    unsubscribeRpc(rpcSubId)
-                    rpcSubscriptionIdToSubscriptionId.remove(rpcSubId)
-                }
-            }
-            
-            logger.info("取消订阅: subscriptionId=$subscriptionId")
-        }
-        
-        // 如果没有订阅了，停止连接
-        if (subscriptions.isEmpty()) {
-            stop()
-        }
-    }
-    
-    /**
-     * 启动连接（如果还没有连接）
-     */
-    private fun startConnection() {
-        // 如果没有订阅，不启动连接
-        if (subscriptions.isEmpty()) {
-            return
-        }
-        
-        // 如果连接任务已经在运行，不重复启动
-        if (connectionJob != null && connectionJob!!.isActive) {
-            return
-        }
-        
-        // 启动连接任务
-        connectionJob = scope.launch {
-            startConnectionLoop()
-        }
-    }
-    
-    /**
-     * 启动连接循环
-     */
-    private suspend fun startConnectionLoop() {
-        while (scope.isActive) {
-            try {
-                // 如果没有订阅，停止连接
-                if (subscriptions.isEmpty()) {
-                    logger.info("没有订阅，停止连接")
-                    stop()
-                    break
+                // 如果该连接没有订阅了，停止并移除
+                if (connection.isSubscriptionsEmpty()) {
+                    connection.stop()
+                    addressConnections.remove(connection.address)
+                    logger.info("连接已无订阅，关闭连接: address=${connection.address}")
                 }
                 
-                // 如果已经连接，等待断开
-                if (isConnected && webSocket != null) {
-                    waitForDisconnect()
-                    continue
-                }
-                
-                // 获取可用的 RPC 节点
-                val wsUrl = rpcNodeService.getWsUrl()
-                val httpUrl = rpcNodeService.getHttpUrl()
-                
-                if (wsUrl.isBlank() || httpUrl.isBlank()) {
-                    logger.warn("没有可用的 RPC 节点，等待重试...")
-                    delay(reconnectDelay)
-                    continue
-                }
-                
-                logger.info("连接链上 WebSocket: $wsUrl (${subscriptions.size} 个订阅)")
-                
-                // 创建 HTTP 客户端（用于 RPC 调用）
-                val httpClient = createHttpClient()
-                
-                // 创建 RPC API 客户端
-                val rpcApi = retrofitFactory.createEthereumRpcApi(httpUrl)
-                
-                // 连接 WebSocket
-                connectWebSocket(wsUrl, httpClient, rpcApi)
-                
-                // 等待连接建立
-                waitForConnect()
-                
-                // 如果连接成功，订阅所有地址
-                if (isConnected) {
-                    logger.info("WebSocket 连接已建立，开始订阅")
-                    for (subscription in subscriptions.values) {
-                        subscribeAddress(subscription)
-                    }
-                    
-                    // 等待连接断开
-                    waitForDisconnect()
-                }
-                
-                // 连接断开后，如果没有订阅了，不再重连
-                if (subscriptions.isEmpty()) {
-                    logger.info("没有订阅，停止重连")
-                    break
-                }
-                
-                // 等待后重连
-                logger.info("WebSocket 连接断开，等待 ${reconnectDelay}ms 后重连")
-                delay(reconnectDelay)
-                
-            } catch (e: Exception) {
-                logger.error("连接异常: ${e.message}", e)
-                delay(reconnectDelay)
-            }
-        }
-    }
-    
-    /**
-     * 创建 HTTP 客户端
-     */
-    private fun createHttpClient(): OkHttpClient {
-        val proxy = getProxyConfig()
-        val builder = createClient()
-        
-        if (proxy != null) {
-            builder.proxy(proxy)
-        }
-        
-        return builder.build()
-    }
-    
-    /**
-     * 连接 WebSocket
-     */
-    private fun connectWebSocket(wsUrl: String, httpClient: OkHttpClient, rpcApi: EthereumRpcApi) {
-        // 先关闭旧连接
-        webSocket?.close(1000, "重新连接")
-        webSocket = null
-        isConnected = false
-        
-        val request = Request.Builder()
-            .url(wsUrl)
-            .build()
-        
-        webSocket = httpClient.newWebSocket(request, object : WebSocketListener() {
-            override fun onOpen(webSocket: WebSocket, response: okhttp3.Response) {
-                isConnected = true
-                logger.info("链上 WebSocket 连接成功")
-            }
-            
-            override fun onMessage(webSocket: WebSocket, text: String) {
-                scope.launch {
-                    handleMessage(text, httpClient, rpcApi)
-                }
-            }
-            
-            override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
-                scope.launch {
-                    handleMessage(bytes.utf8(), httpClient, rpcApi)
-                }
-            }
-            
-            override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
-                isConnected = false
-                logger.warn("链上 WebSocket 连接关闭: code=$code, reason=$reason")
-            }
-            
-            override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
-                isConnected = false
-                logger.warn("链上 WebSocket 连接已关闭: code=$code, reason=$reason")
-            }
-            
-            override fun onFailure(webSocket: WebSocket, t: Throwable, response: okhttp3.Response?) {
-                logger.error("链上 WebSocket 连接失败: ${t.message}", t)
-                isConnected = false
-            }
-        })
-    }
-    
-    /**
-     * 等待连接建立
-     */
-    private suspend fun waitForConnect() {
-        var waited = 0L
-        val timeout = 15000L  // 15秒超时
-        
-        while (!isConnected && waited < timeout) {
-            delay(100)
-            waited += 100
-        }
-        
-        if (!isConnected) {
-            logger.warn("WebSocket 连接超时，等待重连")
-        }
-    }
-    
-    /**
-     * 等待连接断开
-     */
-    private suspend fun waitForDisconnect() {
-        while (isConnected && scope.isActive) {
-            delay(1000)
-        }
-    }
-    
-    /**
-     * 订阅地址（为每个地址订阅 6 个事件）
-     */
-    private suspend fun subscribeAddress(subscription: SubscriptionInfo) {
-        if (webSocket == null || !isConnected) {
-            return
-        }
-        
-        val address = subscription.address
-        val walletTopic = OnChainWsUtils.addressToTopic32(address)
-        val subscriptionId = subscription.subscriptionId
-        
-        try {
-            // 订阅 USDC Transfer (from wallet)
-            subscribeLogs(OnChainWsUtils.USDC_CONTRACT, listOf(OnChainWsUtils.ERC20_TRANSFER_TOPIC, walletTopic), subscriptionId)
-            
-            // 订阅 USDC Transfer (to wallet)
-            subscribeLogs(OnChainWsUtils.USDC_CONTRACT, listOf(OnChainWsUtils.ERC20_TRANSFER_TOPIC, null, walletTopic), subscriptionId)
-            
-            // 订阅 ERC1155 TransferSingle (from wallet)
-            subscribeLogs(OnChainWsUtils.ERC1155_CONTRACT, listOf(OnChainWsUtils.ERC1155_TRANSFER_SINGLE_TOPIC, null, walletTopic), subscriptionId)
-            
-            // 订阅 ERC1155 TransferSingle (to wallet)
-            subscribeLogs(OnChainWsUtils.ERC1155_CONTRACT, listOf(OnChainWsUtils.ERC1155_TRANSFER_SINGLE_TOPIC, null, null, walletTopic), subscriptionId)
-            
-            // 订阅 ERC1155 TransferBatch (from wallet)
-            subscribeLogs(OnChainWsUtils.ERC1155_CONTRACT, listOf(OnChainWsUtils.ERC1155_TRANSFER_BATCH_TOPIC, null, walletTopic), subscriptionId)
-            
-            // 订阅 ERC1155 TransferBatch (to wallet)
-            subscribeLogs(OnChainWsUtils.ERC1155_CONTRACT, listOf(OnChainWsUtils.ERC1155_TRANSFER_BATCH_TOPIC, null, null, walletTopic), subscriptionId)
-            
-            logger.debug("已订阅地址: subscriptionId=$subscriptionId, address=$address")
-        } catch (e: Exception) {
-            logger.error("订阅地址失败: subscriptionId=$subscriptionId, address=$address, error=${e.message}", e)
-        }
-    }
-    
-    /**
-     * 订阅日志
-     */
-    private fun subscribeLogs(address: String, topics: List<String?>, subscriptionId: String) {
-        val ws = webSocket ?: return
-        
-        val params = mapOf(
-            "address" to address.lowercase(),
-            "topics" to topics.filterNotNull()
-        )
-        
-        val requestId = ++requestIdCounter
-        requestIdToSubscriptionId[requestId] = subscriptionId
-        
-        val request = mapOf(
-            "jsonrpc" to "2.0",
-            "id" to requestId,
-            "method" to "eth_subscribe",
-            "params" to listOf("logs", params)
-        )
-        
-        val message = gson.toJson(request)
-        ws.send(message)
-    }
-    
-    /**
-     * 取消 RPC 订阅
-     */
-    private fun unsubscribeRpc(rpcSubscriptionId: String) {
-        val ws = webSocket ?: return
-        
-        val requestId = ++requestIdCounter
-        val request = mapOf(
-            "jsonrpc" to "2.0",
-            "id" to requestId,
-            "method" to "eth_unsubscribe",
-            "params" to listOf(rpcSubscriptionId)
-        )
-        
-        val message = gson.toJson(request)
-        ws.send(message)
-    }
-    
-    /**
-     * 处理 WebSocket 消息
-     */
-    private suspend fun handleMessage(text: String, httpClient: OkHttpClient, rpcApi: EthereumRpcApi) {
-        try {
-            val message = gson.fromJson(text, JsonObject::class.java)
-            
-            // 处理订阅响应
-            if (message.has("result") && message.has("id")) {
-                val requestId = message.get("id")?.asInt
-                val rpcSubscriptionId = message.get("result")?.asString
-                
-                if (requestId != null && rpcSubscriptionId != null) {
-                    val subscriptionId = requestIdToSubscriptionId.remove(requestId)
-                    if (subscriptionId != null) {
-                        // 保存 RPC subscriptionId 到订阅的映射
-                        rpcSubscriptionIdToSubscriptionId[rpcSubscriptionId] = subscriptionId
-                        logger.debug("订阅成功: subscriptionId=$subscriptionId, rpcSubscriptionId=$rpcSubscriptionId")
-                    }
-                }
+                logger.info("取消订阅: subscriptionId=$subscriptionId")
                 return
             }
-            
-            // 处理日志通知
-            if (message.has("params")) {
-                val params = message.getAsJsonObject("params")
-                val subscriptionIdParam = params.get("subscription")?.asString
-                val result = params.getAsJsonObject("result")
-                
-                if (result != null) {
-                    val txHash = result.get("transactionHash")?.asString
-                    if (txHash != null && subscriptionIdParam != null) {
-                        // 根据 RPC subscriptionId 找到对应的订阅
-                        val subscriptionId = rpcSubscriptionIdToSubscriptionId[subscriptionIdParam]
-                        if (subscriptionId != null) {
-                            // 处理交易，分发给对应的订阅者
-                            processTransactionForSubscription(txHash, subscriptionId, httpClient, rpcApi)
-                        } else {
-                            // 如果没有找到订阅，可能是新订阅还未建立映射，尝试处理所有订阅
-                            processTransaction(txHash, httpClient, rpcApi)
-                        }
-                    }
-                }
-            }
-        } catch (e: Exception) {
-            logger.error("处理 WebSocket 消息失败: ${e.message}", e)
         }
     }
     
     /**
-     * 处理交易（为特定订阅）
-     * 直接调用订阅的回调
-     */
-    private suspend fun processTransactionForSubscription(
-        txHash: String,
-        subscriptionId: String,
-        httpClient: OkHttpClient,
-        rpcApi: EthereumRpcApi
-    ) {
-        val subscription = subscriptions[subscriptionId] ?: return
-        
-        try {
-            subscription.callback(txHash, httpClient, rpcApi)
-        } catch (e: Exception) {
-            logger.error("调用订阅回调失败: subscriptionId=$subscriptionId, txHash=$txHash, error=${e.message}", e)
-        }
-    }
-    
-    /**
-     * 处理交易（为所有订阅，用于兼容）
-     * 解析交易中的 Transfer 事件，分发给所有订阅者
-     */
-    private suspend fun processTransaction(txHash: String, httpClient: OkHttpClient, rpcApi: EthereumRpcApi) {
-        try {
-            // 获取交易 receipt
-            val receiptRequest = JsonRpcRequest(
-                method = "eth_getTransactionReceipt",
-                params = listOf(txHash)
-            )
-            
-            val receiptResponse = rpcApi.call(receiptRequest)
-            if (!receiptResponse.isSuccessful || receiptResponse.body() == null) {
-                return
-            }
-            
-            val receiptRpcResponse = receiptResponse.body()!!
-            if (receiptRpcResponse.error != null || receiptRpcResponse.result == null) {
-                return
-            }
-            
-            // 使用 Gson 解析 receipt JSON
-            val receiptJson = receiptRpcResponse.result.asJsonObject
-            
-            // 解析 receipt 中的 Transfer 日志
-            val logs = receiptJson.getAsJsonArray("logs") ?: return
-            val (erc20Transfers, erc1155Transfers) = OnChainWsUtils.parseReceiptTransfers(logs)
-            
-            // 为每个订阅检查是否匹配，如果匹配则调用回调
-            for (subscription in subscriptions.values) {
-                val address = subscription.address
-                
-                // 检查该地址是否参与了交易（通过检查 Transfer 日志）
-                val isInvolved = erc20Transfers.any { 
-                    it.from.lowercase() == address || it.to.lowercase() == address 
-                } || erc1155Transfers.any { 
-                    it.from.lowercase() == address || it.to.lowercase() == address 
-                }
-                
-                if (isInvolved) {
-                    // 该地址参与了交易，调用回调
-                    try {
-                        subscription.callback(txHash, httpClient, rpcApi)
-                    } catch (e: Exception) {
-                        logger.error("调用订阅回调失败: subscriptionId=${subscription.subscriptionId}, txHash=$txHash, error=${e.message}", e)
-                    }
-                }
-            }
-        } catch (e: Exception) {
-            logger.error("处理交易失败: txHash=$txHash, ${e.message}", e)
-        }
-    }
-    
-    /**
-     * 停止连接
+     * 停止所有服务
      */
     fun stop() {
-        connectionJob?.cancel()
-        connectionJob = null
-        
-        // 关闭 WebSocket 连接
-        webSocket?.close(1000, "停止监听")
-        webSocket = null
-        isConnected = false
-        
-        // 清空订阅信息
-        subscriptions.clear()
-        requestIdToSubscriptionId.clear()
-        rpcSubscriptionIdToSubscriptionId.clear()
+        for (connection in addressConnections.values) {
+            connection.stop()
+        }
+        addressConnections.clear()
     }
     
     @PostConstruct
     fun init() {
-        // 服务启动时不自动连接，等待有订阅时再连接
-        logger.info("统一链上 WebSocket 服务已初始化")
+        logger.info("统一链上 WebSocket 服务已初始化 (独立连接模式)")
     }
     
     @PreDestroy
@@ -561,5 +140,295 @@ class UnifiedOnChainWsService(
         stop()
         scope.cancel()
     }
+
+    /**
+     * 单个地址的 WebSocket 连接管理
+     */
+    inner class AddressWsConnection(val address: String) {
+        private var webSocket: WebSocket? = null
+        @Volatile
+        private var isConnected = false
+        
+        // 订阅ID计数器（用于请求 ID）
+        private var requestIdCounter = AtomicInteger(0)
+        
+        // 连接任务
+        private var connectionJob: Job? = null
+        
+        // 该连接下的所有订阅：subscriptionId -> SubscriptionInfo
+        // 理论上一个地址可能被多个业务订阅（如：既是被跟单者又是普通监控），虽然业务上通常只有一个
+        private val subscriptions = ConcurrentHashMap<String, SubscriptionInfo>()
+        
+        // 存储请求 ID 到订阅 ID 的映射：requestId -> subscriptionId
+        private val requestIdToSubscriptionId = ConcurrentHashMap<Int, String>()
+        
+        // 存储 RPC subscriptionId 到订阅 ID 的映射：rpcSubscriptionId -> subscriptionId
+        private val rpcSubscriptionIdToSubscriptionId = ConcurrentHashMap<String, String>()
+
+        fun start() {
+            if (connectionJob != null && connectionJob!!.isActive) return
+            connectionJob = scope.launch {
+                startConnectionLoop()
+            }
+        }
+
+        fun stop() {
+            connectionJob?.cancel()
+            connectionJob = null
+            webSocket?.close(1000, "停止监听")
+            webSocket = null
+            isConnected = false
+            subscriptions.clear()
+            requestIdToSubscriptionId.clear()
+            rpcSubscriptionIdToSubscriptionId.clear()
+        }
+
+        fun addSubscription(subscription: SubscriptionInfo) {
+            // 如果已经存在，先移除旧的
+            removeSubscription(subscription.subscriptionId)
+            subscriptions[subscription.subscriptionId] = subscription
+            
+            // 如果已经连接，立即发送链上订阅请求
+            if (isConnected) {
+                scope.launch {
+                    subscribeAddressOnChain(subscription)
+                }
+            }
+        }
+
+        fun removeSubscription(subscriptionId: String) {
+            subscriptions.remove(subscriptionId)
+            // 不需要显式发送 eth_unsubscribe，因为连接是 per-address 的，
+            // 只要只要连接还在，就保持该地址相关的所有 logs 订阅。
+            // 只有当所有 subscription 都移除了，连接才会关闭。
+        }
+
+        fun hasSubscription(subscriptionId: String): Boolean {
+            return subscriptions.containsKey(subscriptionId)
+        }
+
+        fun isSubscriptionsEmpty(): Boolean {
+            return subscriptions.isEmpty()
+        }
+
+        private suspend fun startConnectionLoop() {
+            while (scope.isActive) {
+                try {
+                    if (subscriptions.isEmpty()) {
+                        // 如果启动循环时还没订阅（不太可能，通常是先 addSubscription 再 start，或者是 start 后 addSubscription）
+                        // 或者订阅被清空了，外部应当掉 stop，但这里作为防守
+                        delay(1000) 
+                        continue
+                    }
+
+                    if (isConnected && webSocket != null) {
+                        waitForDisconnect()
+                        continue
+                    }
+
+                    // 获取可用的 RPC 节点
+                    val wsUrl = rpcNodeService.getWsUrl()
+                    val httpUrl = rpcNodeService.getHttpUrl()
+
+                    logger.info("[$address] 连接链上 WebSocket: $wsUrl")
+
+                    val httpClient = createHttpClient()
+                    val rpcApi = retrofitFactory.createEthereumRpcApi(httpUrl)
+
+                    connectWebSocket(wsUrl, httpClient, rpcApi)
+                    waitForConnect()
+
+                    if (isConnected) {
+                        logger.info("[$address] WebSocket 连接已建立，开始注册订阅")
+                        // 重新为所有订阅注册链上监听
+                        for (subscription in subscriptions.values) {
+                            subscribeAddressOnChain(subscription)
+                        }
+                        waitForDisconnect()
+                    }
+
+                    logger.info("[$address] WebSocket 连接断开，等待 ${reconnectDelay}ms 后重连")
+                    delay(reconnectDelay)
+
+                } catch (e: Exception) {
+                    logger.error("[$address] 连接异常: ${e.message}", e)
+                    delay(reconnectDelay)
+                }
+            }
+        }
+
+        private fun connectWebSocket(wsUrl: String, httpClient: OkHttpClient, rpcApi: EthereumRpcApi) {
+            webSocket?.close(1000, "重新连接")
+            webSocket = null
+            isConnected = false
+
+            val request = Request.Builder().url(wsUrl).build()
+            
+            webSocket = httpClient.newWebSocket(request, object : WebSocketListener() {
+                override fun onOpen(webSocket: WebSocket, response: okhttp3.Response) {
+                    isConnected = true
+                    logger.info("[$address] 链上 WebSocket 连接成功")
+                }
+
+                override fun onMessage(webSocket: WebSocket, text: String) {
+                    scope.launch { handleMessage(text, httpClient, rpcApi) }
+                }
+
+                override fun onMessage(webSocket: WebSocket, bytes: ByteString) {
+                    scope.launch { handleMessage(bytes.utf8(), httpClient, rpcApi) }
+                }
+
+                override fun onClosing(webSocket: WebSocket, code: Int, reason: String) {
+                    isConnected = false
+                    logger.warn("[$address] 链上 WebSocket 连接关闭: code=$code, reason=$reason")
+                }
+
+                override fun onClosed(webSocket: WebSocket, code: Int, reason: String) {
+                    isConnected = false
+                    logger.warn("[$address] 链上 WebSocket 连接已关闭: code=$code, reason=$reason")
+                }
+
+                override fun onFailure(webSocket: WebSocket, t: Throwable, response: okhttp3.Response?) {
+                    logger.error("[$address] 链上 WebSocket 连接失败: ${t.message}", t)
+                    isConnected = false
+                }
+            })
+        }
+
+        private suspend fun subscribeAddressOnChain(subscription: SubscriptionInfo) {
+            if (webSocket == null || !isConnected) return
+            
+            val walletTopic = OnChainWsUtils.addressToTopic32(address)
+            val subId = subscription.subscriptionId
+            
+            try {
+                // 订阅该地址相关的所有事件
+                // USDC Transfer (from/to)
+                subscribeLogs(OnChainWsUtils.USDC_CONTRACT, listOf(OnChainWsUtils.ERC20_TRANSFER_TOPIC, walletTopic), subId)
+                subscribeLogs(OnChainWsUtils.USDC_CONTRACT, listOf(OnChainWsUtils.ERC20_TRANSFER_TOPIC, null, walletTopic), subId)
+                
+                // ERC1155 TransferSingle (from/to)
+                subscribeLogs(OnChainWsUtils.ERC1155_CONTRACT, listOf(OnChainWsUtils.ERC1155_TRANSFER_SINGLE_TOPIC, null, walletTopic), subId)
+                subscribeLogs(OnChainWsUtils.ERC1155_CONTRACT, listOf(OnChainWsUtils.ERC1155_TRANSFER_SINGLE_TOPIC, null, null, walletTopic), subId)
+                
+                // ERC1155 TransferBatch (from/to)
+                subscribeLogs(OnChainWsUtils.ERC1155_CONTRACT, listOf(OnChainWsUtils.ERC1155_TRANSFER_BATCH_TOPIC, null, walletTopic), subId)
+                subscribeLogs(OnChainWsUtils.ERC1155_CONTRACT, listOf(OnChainWsUtils.ERC1155_TRANSFER_BATCH_TOPIC, null, null, walletTopic), subId)
+                
+                logger.debug("[$address] 已发送链上订阅请求: subscriptionId=$subId")
+            } catch (e: Exception) {
+                logger.error("[$address] 发送链上订阅请求失败: error=${e.message}", e)
+            }
+        }
+
+        private fun subscribeLogs(contractAddress: String, topics: List<String?>, subscriptionId: String) {
+            val ws = webSocket ?: return
+            
+            val topicsArray = gson.toJsonTree(topics).asJsonArray
+            val logParams = JsonObject()
+            logParams.addProperty("address", contractAddress.lowercase())
+            logParams.add("topics", topicsArray)
+            
+            val requestId = requestIdCounter.incrementAndGet()
+            requestIdToSubscriptionId[requestId] = subscriptionId
+            
+            val request = JsonObject()
+            request.addProperty("jsonrpc", "2.0")
+            request.addProperty("id", requestId)
+            request.addProperty("method", "eth_subscribe")
+            val paramsArray = JsonArray()
+            paramsArray.add("logs")
+            paramsArray.add(logParams)
+            request.add("params", paramsArray)
+            
+            ws.send(gson.toJson(request))
+        }
+
+        private suspend fun handleMessage(text: String, httpClient: OkHttpClient, rpcApi: EthereumRpcApi) {
+            try {
+                val message = gson.fromJson(text, JsonObject::class.java)
+
+                // 1. 处理订阅响应 (eth_subscribe response)
+                if (message.has("result") && message.has("id")) {
+                    val requestId = message.get("id")?.asInt
+                    val rpcSubscriptionId = message.get("result")?.asString
+                    
+                    if (requestId != null && rpcSubscriptionId != null) {
+                        val subId = requestIdToSubscriptionId.remove(requestId)
+                        if (subId != null) {
+                            rpcSubscriptionIdToSubscriptionId[rpcSubscriptionId] = subId
+                            logger.debug("[$address] 链上订阅成功: mapped connection rpcSubId=$rpcSubscriptionId to localSubId=$subId")
+                        }
+                    }
+                    return
+                }
+
+                // 2. 处理日志通知 (eth_subscription)
+                val method = message.get("method")?.asString
+                if (method == "eth_subscription") {
+                    val params = message.getAsJsonObject("params") ?: return
+                    val rpcSubParam = params.get("subscription")?.asString
+                    val result = params.getAsJsonObject("result") ?: return
+                    val txHash = result.get("transactionHash")?.asString
+
+                    if (txHash != null && rpcSubParam != null) {
+                        // 找到触发此通知的本地订阅 ID
+                        // 因为我们在这个连接里只订阅了 this.address，所以理论上所有通知都跟这个 address 有关
+                        // 但我们需要找到对应的 callback
+                        val localSubId = rpcSubscriptionIdToSubscriptionId[rpcSubParam]
+                        
+                        if (localSubId != null) {
+                            val subscription = subscriptions[localSubId]
+                            if (subscription != null) {
+                                logger.info("[$address] 收到交易通知: txHash=$txHash, subId=$localSubId")
+                                runCatching {
+                                    subscription.callback(txHash, httpClient, rpcApi)
+                                }.onFailure { e ->
+                                    logger.error("[$address] 回调执行失败: ${e.message}", e)
+                                }
+                            }
+                        } else {
+                            // 找不到具体是哪个订阅请求触发的（可能是重启后之前的订阅残留？或者映射丢失？）
+                            // 在单地址单连接模式下，只要是这个 connection 收到的，肯定是关于这个 address 的
+                            // 我们可以尝试通知所有订阅者（通常一个地址只有一个订阅者，除非此地址既是Leader又是User）
+                            logger.warn("[$address] 未找到映射的订阅ID: rpcSubId=$rpcSubParam. 广播给所有订阅者.")
+                            subscriptions.values.forEach { sub ->
+                                runCatching {
+                                    sub.callback(txHash, httpClient, rpcApi)
+                                }.onFailure { e ->
+                                    logger.error("[$address] 广播回调执行失败: ${e.message}", e)
+                                }
+                            }
+                        }
+                    }
+                }
+            } catch (e: Exception) {
+                logger.error("[$address] 处理消息失败: ${e.message}", e)
+            }
+        }
+        
+        private suspend fun waitForConnect() {
+            var waited = 0L
+            val timeout = 15000L
+            while (!isConnected && waited < timeout) {
+                delay(100)
+                waited += 100
+            }
+            if (!isConnected) logger.warn("[$address] WebSocket 连接超时")
+        }
+
+        private suspend fun waitForDisconnect() {
+            while (isConnected && scope.isActive) {
+                delay(1000)
+            }
+        }
+        
+        private fun createHttpClient(): OkHttpClient {
+            val proxy = getProxyConfig()
+            val builder = createClient()
+            if (proxy != null) builder.proxy(proxy)
+            return builder.build()
+        }
+    }
 }
 

backend/src/main/kotlin/com/wrbug/polymarketbot/service/copytrading/statistics/CopyOrderTrackingService.kt

@@ -25,6 +25,7 @@ import com.wrbug.polymarketbot.util.CryptoUtils
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
 import java.math.BigDecimal
+import kotlin.math.max
 
 /**
  * 订单跟踪服务
@@ -54,16 +55,16 @@ open class CopyOrderTrackingService(
 
     // 协程作用域（用于异步发送通知）
     private val notificationScope = CoroutineScope(Dispatchers.IO + SupervisorJob())
-    
+
     // 使用 Mutex 保证线程安全（按交易ID锁定）
     private val tradeMutexMap = ConcurrentHashMap<String, Mutex>()
-    
+
     // 订单创建重试配置
     companion object {
         private const val MAX_RETRY_ATTEMPTS = 2  // 最多重试次数（首次 + 1次重试）
         private const val RETRY_DELAY_MS = 3000L  // 重试前等待时间（毫秒，3秒）
     }
-    
+
     /**
      * 获取或创建 Mutex（按交易ID）
      */
@@ -121,85 +122,85 @@ open class CopyOrderTrackingService(
     suspend fun processTrade(leaderId: Long, trade: TradeResponse, source: String): Result<Unit> {
         // 获取该交易的 Mutex（按交易ID锁定，不同交易可以并行处理）
         val mutex = getMutex(leaderId, trade.id)
-        
+
         return mutex.withLock {
             try {
-            // 1. 检查是否已处理（去重，包括失败状态）
-            val existingProcessed = processedTradeRepository.findByLeaderIdAndLeaderTradeId(leaderId, trade.id)
+                // 1. 检查是否已处理（去重，包括失败状态）
+                val existingProcessed = processedTradeRepository.findByLeaderIdAndLeaderTradeId(leaderId, trade.id)
 
-            if (existingProcessed != null) {
-                if (existingProcessed.status == "FAILED") {
+                if (existingProcessed != null) {
+                    if (existingProcessed.status == "FAILED") {
                         return@withLock Result.success(Unit)
-                }
-                    return@withLock Result.success(Unit)
-            }
-
-            // 2. 处理交易逻辑
-            val result = when (trade.side.uppercase()) {
-                "BUY" -> processBuyTrade(leaderId, trade)
-                "SELL" -> processSellTrade(leaderId, trade)
-                else -> {
-                    logger.warn("未知的交易方向: ${trade.side}")
-                    Result.failure(IllegalArgumentException("未知的交易方向: ${trade.side}"))
-                }
-            }
-
-            if (result.isFailure) {
-                logger.error(
-                    "处理交易失败: leaderId=$leaderId, tradeId=${trade.id}, side=${trade.side}",
-                    result.exceptionOrNull()
-                )
-                    return@withLock result
-            }
-
-            // 3. 标记为已处理（成功状态）
-                // 由于使用了 Mutex，这里理论上不会出现并发冲突，但保留异常处理作为兜底
-            try {
-                val processed = ProcessedTrade(
-                    leaderId = leaderId,
-                    leaderTradeId = trade.id,
-                    tradeType = trade.side.uppercase(),
-                    source = source,
-                    status = "SUCCESS",
-                    processedAt = System.currentTimeMillis()
-                )
-                processedTradeRepository.save(processed)
-            } catch (e: Exception) {
-                    // 检查是否是唯一键冲突异常（理论上不会发生，但保留作为兜底）
-                if (isUniqueConstraintViolation(e)) {
-                    val existing = processedTradeRepository.findByLeaderIdAndLeaderTradeId(leaderId, trade.id)
-                    if (existing != null) {
-                        if (existing.status == "FAILED") {
-                            logger.debug("交易已标记为失败，跳过处理: leaderId=$leaderId, tradeId=${trade.id}")
-                                return@withLock Result.success(Unit)
-                        }
-                        logger.debug("交易已处理（并发检测）: leaderId=$leaderId, tradeId=${trade.id}, status=${existing.status}")
-                            return@withLock Result.success(Unit)
-                    } else {
-                        // 如果检查不到，可能是事务隔离级别问题，等待一下再查询
-                        delay(100)
-                        val existingAfterDelay =
-                            processedTradeRepository.findByLeaderIdAndLeaderTradeId(leaderId, trade.id)
-                        if (existingAfterDelay != null) {
-                            logger.debug("延迟查询到记录（并发检测）: leaderId=$leaderId, tradeId=${trade.id}, status=${existingAfterDelay.status}")
-                                return@withLock Result.success(Unit)
-                        }
-                        logger.warn(
-                            "保存ProcessedTrade时发生唯一约束冲突，但查询不到记录: leaderId=$leaderId, tradeId=${trade.id}",
-                            e
-                        )
-                            return@withLock Result.success(Unit)
                     }
-                } else {
-                    // 其他类型的异常，重新抛出
-                    throw e
+                    return@withLock Result.success(Unit)
                 }
-            }
 
-            Result.success(Unit)
-        } catch (e: Exception) {
-            logger.error("处理交易异常: leaderId=$leaderId, tradeId=${trade.id}", e)
-            Result.failure(e)
+                // 2. 处理交易逻辑
+                val result = when (trade.side.uppercase()) {
+                    "BUY" -> processBuyTrade(leaderId, trade)
+                    "SELL" -> processSellTrade(leaderId, trade)
+                    else -> {
+                        logger.warn("未知的交易方向: ${trade.side}")
+                        Result.failure(IllegalArgumentException("未知的交易方向: ${trade.side}"))
+                    }
+                }
+
+                if (result.isFailure) {
+                    logger.error(
+                        "处理交易失败: leaderId=$leaderId, tradeId=${trade.id}, side=${trade.side}",
+                        result.exceptionOrNull()
+                    )
+                    return@withLock result
+                }
+
+                // 3. 标记为已处理（成功状态）
+                // 由于使用了 Mutex，这里理论上不会出现并发冲突，但保留异常处理作为兜底
+                try {
+                    val processed = ProcessedTrade(
+                        leaderId = leaderId,
+                        leaderTradeId = trade.id,
+                        tradeType = trade.side.uppercase(),
+                        source = source,
+                        status = "SUCCESS",
+                        processedAt = System.currentTimeMillis()
+                    )
+                    processedTradeRepository.save(processed)
+                } catch (e: Exception) {
+                    // 检查是否是唯一键冲突异常（理论上不会发生，但保留作为兜底）
+                    if (isUniqueConstraintViolation(e)) {
+                        val existing = processedTradeRepository.findByLeaderIdAndLeaderTradeId(leaderId, trade.id)
+                        if (existing != null) {
+                            if (existing.status == "FAILED") {
+                                logger.debug("交易已标记为失败，跳过处理: leaderId=$leaderId, tradeId=${trade.id}")
+                                return@withLock Result.success(Unit)
+                            }
+                            logger.debug("交易已处理（并发检测）: leaderId=$leaderId, tradeId=${trade.id}, status=${existing.status}")
+                            return@withLock Result.success(Unit)
+                        } else {
+                            // 如果检查不到，可能是事务隔离级别问题，等待一下再查询
+                            delay(100)
+                            val existingAfterDelay =
+                                processedTradeRepository.findByLeaderIdAndLeaderTradeId(leaderId, trade.id)
+                            if (existingAfterDelay != null) {
+                                logger.debug("延迟查询到记录（并发检测）: leaderId=$leaderId, tradeId=${trade.id}, status=${existingAfterDelay.status}")
+                                return@withLock Result.success(Unit)
+                            }
+                            logger.warn(
+                                "保存ProcessedTrade时发生唯一约束冲突，但查询不到记录: leaderId=$leaderId, tradeId=${trade.id}",
+                                e
+                            )
+                            return@withLock Result.success(Unit)
+                        }
+                    } else {
+                        // 其他类型的异常，重新抛出
+                        throw e
+                    }
+                }
+
+                Result.success(Unit)
+            } catch (e: Exception) {
+                logger.error("处理交易异常: leaderId=$leaderId, tradeId=${trade.id}", e)
+                Result.failure(e)
             }
         }
     }
@@ -253,13 +254,13 @@ open class CopyOrderTrackingService(
                     // 先计算跟单金额（用于仓位检查）
                     // 注意：这里先计算金额，即使后续被过滤也会记录
                     val tradePrice = trade.price.toSafeBigDecimal()
-                    val buyQuantity = try {
+                    var buyQuantity = try {
                         calculateBuyQuantity(trade, copyTrading)
                     } catch (e: Exception) {
                         logger.warn("计算买入数量失败: ${e.message}", e)
                         continue
                     }
-                    
+
                     // 计算跟单金额（USDC）= 买入数量 × 价格
                     val copyOrderAmount = buyQuantity.multi(tradePrice)
 
@@ -268,8 +269,8 @@ open class CopyOrderTrackingService(
                     // 传入跟单金额和市场ID，用于仓位检查（按市场检查仓位）
                     // 订单簿只请求一次，返回给后续逻辑使用
                     val filterResult = filterService.checkFilters(
-                        copyTrading, 
-                        tokenId, 
+                        copyTrading,
+                        tokenId,
                         tradePrice = tradePrice,
                         copyOrderAmount = copyOrderAmount,
                         marketId = trade.market
@@ -369,53 +370,72 @@ open class CopyOrderTrackingService(
                     // 买入数量已在过滤检查前计算，这里直接使用
                     // 如果数量为0或负数，跳过
                     if (buyQuantity.lte(BigDecimal.ZERO)) {
-                        logger.warn("计算出的买入数量为0或负数，跳过: copyTradingId=${copyTrading.id}, tradeId=${trade.id}")
+                        logger.warn("计算得到的买入数量为0，跳过跟单: copyTradingId=${copyTrading.id}, tradeId=${trade.id}")
                         continue
                     }
 
+                    if (buyQuantity.lt(BigDecimal.ONE)) {
+                        logger.warn("计算得到的买入数量小于1，自动调整为1 (Polymarket 最小下单数量): copyTradingId=${copyTrading.id}, tradeId=${trade.id}, originalQuantity=$buyQuantity")
+                        buyQuantity = BigDecimal.ONE
+                    }
                     // 验证订单数量限制（仅比例模式）
                     var finalBuyQuantity = buyQuantity
                     if (copyTrading.copyMode == "RATIO") {
                         val tradePrice = trade.price.toSafeBigDecimal()
                         val rawOrderAmount = buyQuantity.multi(tradePrice)
-                        
+
                         // 对按比例计算的金额进行向上取整处理（确保满足最小限制）
                         // 向上取整到 2 位小数（USDC 精度）
                         val roundedOrderAmount = rawOrderAmount.setScale(2, java.math.RoundingMode.CEILING)
-                        
+
                         // 如果原始金额或向上取整后的金额小于最小限制，调整 buyQuantity 以满足最小限制
                         // 这样可以避免精度问题导致订单被错误地跳过
                         if (roundedOrderAmount.lt(copyTrading.minOrderSize)) {
                             logger.debug("订单金额（向上取整后）低于最小限制，调整数量以满足最小限制: copyTradingId=${copyTrading.id}, rawAmount=$rawOrderAmount, roundedAmount=$roundedOrderAmount, min=${copyTrading.minOrderSize}")
                             // 计算满足最小限制所需的数量（向上取整）
-                            val minQuantity = copyTrading.minOrderSize.div(tradePrice, 8, java.math.RoundingMode.CEILING)
+                            val minQuantity =
+                                copyTrading.minOrderSize.div(tradePrice, 8, java.math.RoundingMode.CEILING)
                             if (minQuantity.lte(BigDecimal.ZERO)) {
                                 logger.warn("计算出的最小数量为0或负数，跳过: copyTradingId=${copyTrading.id}")
                                 continue
                             }
                             // 使用调整后的数量
                             finalBuyQuantity = minQuantity
-                            logger.debug("已调整数量以满足最小限制: copyTradingId=${copyTrading.id}, originalQuantity=$buyQuantity, adjustedQuantity=$finalBuyQuantity, adjustedAmount=${finalBuyQuantity.multi(tradePrice)}")
+                            logger.debug(
+                                "已调整数量以满足最小限制: copyTradingId=${copyTrading.id}, originalQuantity=$buyQuantity, adjustedQuantity=$finalBuyQuantity, adjustedAmount=${
+                                    finalBuyQuantity.multi(
+                                        tradePrice
+                                    )
+                                }"
+                            )
                         } else if (rawOrderAmount.lt(copyTrading.minOrderSize)) {
                             // 原始金额小于最小限制，但向上取整后满足，调整数量以满足最小限制
                             logger.debug("订单金额（精度处理后）低于最小限制，调整数量以满足最小限制: copyTradingId=${copyTrading.id}, rawAmount=$rawOrderAmount, min=${copyTrading.minOrderSize}")
                             // 计算满足最小限制所需的数量（向上取整）
-                            val minQuantity = copyTrading.minOrderSize.div(tradePrice, 8, java.math.RoundingMode.CEILING)
+                            val minQuantity =
+                                copyTrading.minOrderSize.div(tradePrice, 8, java.math.RoundingMode.CEILING)
                             if (minQuantity.lte(BigDecimal.ZERO)) {
                                 logger.warn("计算出的最小数量为0或负数，跳过: copyTradingId=${copyTrading.id}")
                                 continue
                             }
                             // 使用调整后的数量
                             finalBuyQuantity = minQuantity
-                            logger.debug("已调整数量以满足最小限制: copyTradingId=${copyTrading.id}, originalQuantity=$buyQuantity, adjustedQuantity=$finalBuyQuantity, adjustedAmount=${finalBuyQuantity.multi(tradePrice)}")
+                            logger.debug(
+                                "已调整数量以满足最小限制: copyTradingId=${copyTrading.id}, originalQuantity=$buyQuantity, adjustedQuantity=$finalBuyQuantity, adjustedAmount=${
+                                    finalBuyQuantity.multi(
+                                        tradePrice
+                                    )
+                                }"
+                            )
                         }
-                        
+
                         // 检查最大限制（使用调整后的数量）
                         val finalOrderAmount = finalBuyQuantity.multi(tradePrice)
                         if (finalOrderAmount.gt(copyTrading.maxOrderSize)) {
                             logger.warn("订单金额超过最大限制，调整数量: copyTradingId=${copyTrading.id}, amount=$finalOrderAmount, max=${copyTrading.maxOrderSize}")
                             // 调整数量到最大值
-                            val adjustedQuantity = copyTrading.maxOrderSize.div(tradePrice, 8, java.math.RoundingMode.DOWN)
+                            val adjustedQuantity =
+                                copyTrading.maxOrderSize.div(tradePrice, 8, java.math.RoundingMode.DOWN)
                             if (adjustedQuantity.lte(BigDecimal.ZERO)) {
                                 logger.warn("调整后的数量为0或负数，跳过: copyTradingId=${copyTrading.id}")
                                 continue
@@ -440,7 +460,7 @@ open class CopyOrderTrackingService(
 
                     // 计算价格（应用价格容忍度）
                     val buyPrice = calculateAdjustedPrice(trade.price.toSafeBigDecimal(), copyTrading, isBuy = true)
-
+                    logger.debug("计算价格结果：$buyPrice")
                     // 在创建订单前，检查订单簿中是否有可匹配的订单（避免 FAK 订单失败）
                     // 如果过滤检查时已经获取了订单簿，直接使用；否则重新获取
                     val orderbookForCheck = orderbook ?: run {
@@ -451,21 +471,21 @@ open class CopyOrderTrackingService(
                             null
                         }
                     }
-                    
+
                     // 检查是否有可匹配的卖单（asks）
                     if (orderbookForCheck != null) {
                         val bestAsk = orderbookForCheck.asks
                             .mapNotNull { it.price.toSafeBigDecimal() }
                             .minOrNull()
-                        
+
                         if (bestAsk == null) {
                             logger.warn("订单簿中没有卖单，跳过创建订单: copyTradingId=${copyTrading.id}, tradeId=${trade.id}")
                             continue
                         }
-                        
+
                         // 如果调整后的买入价格低于最佳卖单价格，无法匹配
                         if (buyPrice.lt(bestAsk)) {
-                            logger.warn("调整后的买入价格 ($buyPrice) 低于最佳卖单价格 ($bestAsk)，无法匹配，跳过创建订单: copyTradingId=${copyTrading.id}, tradeId=${trade.id}, leaderPrice=${trade.price}, tolerance=${copyTrading.priceTolerance}")
+                            logger.info("调整后的买入价格 ($buyPrice) 低于最佳卖单价格 ($bestAsk)，无法匹配，跳过创建订单: copyTradingId=${copyTrading.id}, tradeId=${trade.id}, leaderPrice=${trade.price}, tolerance=${copyTrading.priceTolerance}")
                             continue
                         }
                     }
@@ -495,6 +515,17 @@ open class CopyOrderTrackingService(
                     // 解密私钥
                     val decryptedPrivateKey = decryptPrivateKey(account)
 
+                    // 获取费率（根据 Polymarket Maker Rebates Program 要求）
+                    val feeRateResult = clobService.getFeeRate(tokenId)
+                    val feeRateBps = if (feeRateResult.isSuccess) {
+                        feeRateResult.getOrNull()?.toString() ?: "0"
+                    } else {
+                        logger.warn("获取费率失败，使用默认值 0: tokenId=$tokenId, error=${feeRateResult.exceptionOrNull()?.message}")
+                        "0"
+                    }
+
+                    logger.info("准备创建买入订单: copyTradingId=${copyTrading.id}, tradeId=${trade.id}, leaderPrice=${trade.price}, tolerance=${copyTrading.priceTolerance}, calculatedPrice=$buyPrice, quantity=$finalBuyQuantity, baseFee=$feeRateBps")
+
                     // 调用API创建订单（带重试机制）
                     // 重试策略：最多重试 MAX_RETRY_ATTEMPTS 次，每次重试前等待 RETRY_DELAY_MS 毫秒
                     // 每次重试都会重新生成salt并重新签名，确保签名唯一性
@@ -508,13 +539,15 @@ open class CopyOrderTrackingService(
                         size = finalBuyQuantity.toString(),
                         owner = account.apiKey,
                         copyTradingId = copyTrading.id!!,
-                        tradeId = trade.id
+                        tradeId = trade.id,
+                        feeRateBps = feeRateBps
                     )
 
                     // 处理订单创建失败
                     if (createOrderResult.isFailure) {
                         // 提取错误信息（只保留 code 和 errorBody）
                         val exception = createOrderResult.exceptionOrNull()
+                        logger.error("创建买入订单失败: copyTradingId=${copyTrading.id}, tradeId=${trade.id}, leaderPrice=${trade.price}, myPrice=$buyPrice, error=${exception?.message}")
 
                         // 发送订单失败通知（异步，不阻塞，仅在 pushFailedOrders 为 true 时发送）
                         if (copyTrading.pushFailedOrders) {
@@ -570,7 +603,7 @@ open class CopyOrderTrackingService(
                     }
 
                     val realOrderId = createOrderResult.getOrNull() ?: continue
-                    
+
                     // 验证 orderId 格式（必须以 0x 开头的 16 进制）
                     if (!isValidOrderId(realOrderId)) {
                         logger.warn("买入订单ID格式无效，跳过保存: orderId=$realOrderId")
@@ -656,8 +689,8 @@ open class CopyOrderTrackingService(
     private fun calculateBuyQuantity(trade: TradeResponse, copyTrading: CopyTrading): BigDecimal {
         return when (copyTrading.copyMode) {
             "RATIO" -> {
-                // 比例模式：Leader 数量 × 比例
-                trade.size.toSafeBigDecimal().multi(copyTrading.copyRatio)
+                // 比例模式：Leader 数量 × (比例 / 100)
+                trade.size.toSafeBigDecimal().multi(copyTrading.copyRatio.div(100))
             }
 
             "FIXED" -> {
@@ -689,7 +722,7 @@ open class CopyOrderTrackingService(
         val leader = leaderRepository.findById(copyTrading.leaderId).orElse(null)
             ?: run {
                 logger.warn("Leader 不存在，使用默认比例: leaderId=${copyTrading.leaderId}")
-                return leaderSellQuantity.multi(copyTrading.copyRatio)
+                return leaderSellQuantity.multi(copyTrading.copyRatio.div(100))
             }
 
         // 创建不需要认证的 CLOB API 客户端（用于查询公开的交易数据）
@@ -708,7 +741,7 @@ open class CopyOrderTrackingService(
         for (order in unmatchedOrders) {
             val copyQty = order.quantity.toSafeBigDecimal()
             var leaderQty: BigDecimal? = null
-            
+
             // 优先使用存储的 leaderBuyQuantity
             if (order.leaderBuyQuantity != null) {
                 leaderQty = order.leaderBuyQuantity.toSafeBigDecimal()
@@ -719,7 +752,7 @@ open class CopyOrderTrackingService(
                 logger.debug("Leader 买入数量未存储，尝试查询 API: leaderBuyTradeId=${order.leaderBuyTradeId}, copyOrderId=${order.buyOrderId}")
                 try {
                     val tradesResponse = clobApi.getTrades(id = order.leaderBuyTradeId)
-                    
+
                     if (tradesResponse.isSuccessful && tradesResponse.body() != null) {
                         val tradesData = tradesResponse.body()!!.data
                         if (tradesData.isNotEmpty()) {
@@ -745,7 +778,7 @@ open class CopyOrderTrackingService(
                     failCount++
                 }
             }
-            
+
             // 如果成功获取到 Leader 买入数量，累加
             if (leaderQty != null && leaderQty.gt(BigDecimal.ZERO)) {
                 totalCopyQuantity = totalCopyQuantity.add(copyQty)
@@ -754,23 +787,23 @@ open class CopyOrderTrackingService(
                 logger.warn("无法获取 Leader 买入数量，跳过该订单: copyOrderId=${order.buyOrderId}, leaderBuyTradeId=${order.leaderBuyTradeId}")
             }
         }
-        
+
         logger.info("固定金额模式计算结果汇总: copyTradingId=${copyTrading.id}, successCount=$successCount, failCount=$failCount, totalCopyQuantity=$totalCopyQuantity, totalLeaderQuantity=$totalLeaderQuantity")
 
         // 如果无法计算总比例（查询失败），使用默认比例
         if (totalLeaderQuantity.lte(BigDecimal.ZERO)) {
             logger.warn("无法计算总比例（Leader 买入数量为 0），使用默认比例: copyTradingId=${copyTrading.id}")
-            return leaderSellQuantity.multi(copyTrading.copyRatio)
+            return leaderSellQuantity.multi(copyTrading.copyRatio.div(100))
         }
 
         // 计算实际比例：跟单买入数量 / Leader 买入数量
         val actualRatio = totalCopyQuantity.div(totalLeaderQuantity)
-        
+
         // 计算需要卖出的数量：Leader 卖出数量 × 实际比例
         val needMatch = leaderSellQuantity.multi(actualRatio)
-        
+
         logger.debug("固定金额模式卖出数量计算: copyTradingId=${copyTrading.id}, leaderSellQuantity=$leaderSellQuantity, totalCopyQuantity=$totalCopyQuantity, totalLeaderQuantity=$totalLeaderQuantity, actualRatio=$actualRatio, needMatch=$needMatch")
-        
+
         return needMatch
     }
 
@@ -834,16 +867,26 @@ open class CopyOrderTrackingService(
                     copyTrading = copyTrading
                 )
             }
+
             "RATIO" -> {
-                // 比例模式：直接使用配置的 copyRatio
-                leaderSellTrade.size.toSafeBigDecimal().multi(copyTrading.copyRatio)
+                // 比例模式：直接使用配置的 copyRatio (需要除以100)
+                leaderSellTrade.size.toSafeBigDecimal().multi(copyTrading.copyRatio.div(100))
             }
+
             else -> {
                 logger.warn("不支持的 copyMode: ${copyTrading.copyMode}，使用默认比例模式")
-                leaderSellTrade.size.toSafeBigDecimal().multi(copyTrading.copyRatio)
+                leaderSellTrade.size.toSafeBigDecimal().multi(copyTrading.copyRatio.div(100))
             }
         }
 
+        // 如果需要卖出的数量小于1（但大于0），自动调整为1（Polymarket 最小下单数量）
+        // 注意：如果实际持有数量不足1，后续的 totalMatched 检查会拦截
+        var finalNeedMatch = needMatch
+        if (finalNeedMatch.gt(BigDecimal.ZERO) && finalNeedMatch.lt(BigDecimal.ONE)) {
+            logger.warn("计算得到的卖出数量小于1，自动调整为1: copyTradingId=${copyTrading.id}, original=$needMatch")
+            finalNeedMatch = BigDecimal.ONE
+        }
+
         // 4. 获取tokenId（直接使用outcomeIndex，支持多元市场）
         val tokenIdResult = blockchainService.getTokenId(leaderSellTrade.market, leaderSellTrade.outcomeIndex)
         if (tokenIdResult.isFailure) {
@@ -867,7 +910,7 @@ open class CopyOrderTrackingService(
         // 6. 按FIFO顺序匹配，计算实际可以卖出的数量
         // 使用计算出的实际卖出价格（而不是 Leader 价格）来创建匹配明细
         var totalMatched = BigDecimal.ZERO
-        var remaining = needMatch
+        var remaining = finalNeedMatch
         val matchDetails = mutableListOf<SellMatchDetail>()
 
         for (order in unmatchedOrders) {
@@ -904,6 +947,11 @@ open class CopyOrderTrackingService(
             return
         }
 
+        if (totalMatched.lt(BigDecimal.ONE)) {
+            logger.warn("卖出数量小于1，跳过卖出 (Polymarket 最小下单数量为 1): copyTradingId=${copyTrading.id}, tradeId=${leaderSellTrade.id}, quantity=$totalMatched")
+            return
+        }
+
         // 7. 解密 API 凭证
         val apiSecret = try {
             decryptApiSecret(account)
@@ -920,7 +968,16 @@ open class CopyOrderTrackingService(
 
         // 8. 解密私钥（在方法开始时解密一次，后续复用）
         val decryptedPrivateKey = decryptPrivateKey(account)
-        
+
+        // 获取费率（根据 Polymarket Maker Rebates Program 要求）
+        val feeRateResult = clobService.getFeeRate(tokenId)
+        val feeRateBps = if (feeRateResult.isSuccess) {
+            feeRateResult.getOrNull()?.toString() ?: "0"
+        } else {
+            logger.warn("获取费率失败，使用默认值 0: tokenId=$tokenId, error=${feeRateResult.exceptionOrNull()?.message}")
+            "0"
+        }
+
         // 9. 创建并签名卖出订单
         val signedOrder = try {
             orderSigningService.createAndSignOrder(
@@ -932,7 +989,7 @@ open class CopyOrderTrackingService(
                 size = totalMatched.toString(),
                 signatureType = 2,  // Browser Wallet
                 nonce = "0",
-                feeRateBps = "0",
+                feeRateBps = feeRateBps,  // 使用动态获取的费率
                 expiration = "0"
             )
         } catch (e: Exception) {
@@ -970,7 +1027,8 @@ open class CopyOrderTrackingService(
             size = totalMatched.toString(),
             owner = account.apiKey,
             copyTradingId = copyTrading.id,
-            tradeId = leaderSellTrade.id
+            tradeId = leaderSellTrade.id,
+            feeRateBps = feeRateBps
         )
 
         if (createOrderResult.isFailure) {
@@ -990,7 +1048,7 @@ open class CopyOrderTrackingService(
         } else {
             logger.debug("卖出订单ID为0x开头，等待定时任务更新价格: orderId=$realSellOrderId")
         }
-        
+
         // 使用下单价格，等待定时任务更新实际成交价
         val actualSellPrice = sellPrice
 
@@ -1039,19 +1097,19 @@ open class CopyOrderTrackingService(
             val savedDetail = detail.copy(matchRecordId = savedRecord.id!!)
             sellMatchDetailRepository.save(savedDetail)
         }
-        
+
         logger.info("卖出订单已保存，等待轮询任务获取实际数据后发送通知: orderId=$realSellOrderId, copyTradingId=${copyTrading.id}")
 
     }
 
     /**
      * 创建订单（带重试机制）
-     * 
+     *
      * 重试策略：
      * - 最多重试 MAX_RETRY_ATTEMPTS 次（首次尝试 + 重试）
      * - 每次重试前等待 RETRY_DELAY_MS 毫秒
      * - 每次重试都重新生成salt并重新签名，确保签名唯一性
-     * 
+     *
      * @param clobApi CLOB API 客户端
      * @param privateKey 私钥（用于签名）
      * @param makerAddress 代理钱包地址
@@ -1062,6 +1120,7 @@ open class CopyOrderTrackingService(
      * @param owner API Key（用于owner字段）
      * @param copyTradingId 跟单配置ID（用于日志）
      * @param tradeId Leader 交易ID（用于日志）
+     * @param feeRateBps 费率基点（从API动态获取）
      * @return 成功返回订单ID，失败返回异常
      */
     private suspend fun createOrderWithRetry(
@@ -1074,7 +1133,8 @@ open class CopyOrderTrackingService(
         size: String,
         owner: String,
         copyTradingId: Long,
-        tradeId: String
+        tradeId: String,
+        feeRateBps: String
     ): Result<String> {
         var lastError: Exception? = null
 
@@ -1091,7 +1151,7 @@ open class CopyOrderTrackingService(
                     size = size,
                     signatureType = 2,  // Browser Wallet
                     nonce = "0",
-                    feeRateBps = "0",
+                    feeRateBps = feeRateBps,  // 使用动态获取的费率
                     expiration = "0"
                 )
 
@@ -1117,10 +1177,10 @@ open class CopyOrderTrackingService(
                     }
                     val errorMsg = "code=${orderResponse.code()}, errorBody=${errorBody ?: "null"}"
                     lastError = Exception(errorMsg)
-                    
+
                     // 记录错误日志
                     logger.error("创建订单失败 (尝试 $attempt/$MAX_RETRY_ATTEMPTS): copyTradingId=$copyTradingId, tradeId=$tradeId, $errorMsg")
-                    
+
                     // 如果不是最后一次尝试，等待后重试
                     if (attempt < MAX_RETRY_ATTEMPTS) {
                         delay(RETRY_DELAY_MS)
@@ -1134,10 +1194,10 @@ open class CopyOrderTrackingService(
                 if (!response.success || response.orderId == null) {
                     val errorMsg = "errorMsg=${response.errorMsg}"
                     lastError = Exception(errorMsg)
-                    
+
                     // 记录错误日志
                     logger.error("创建订单失败 (尝试 $attempt/$MAX_RETRY_ATTEMPTS): copyTradingId=$copyTradingId, tradeId=$tradeId, $errorMsg")
-                    
+
                     // 如果不是最后一次尝试，等待后重试
                     if (attempt < MAX_RETRY_ATTEMPTS) {
                         delay(RETRY_DELAY_MS)
@@ -1149,14 +1209,17 @@ open class CopyOrderTrackingService(
                 // 创建订单成功
                 logger.info("创建订单成功: copyTradingId=$copyTradingId, tradeId=$tradeId, orderId=${response.orderId}, attempt=$attempt")
                 return Result.success(response.orderId)
-                
+
             } catch (e: Exception) {
                 val errorMsg = "error=${e.message}"
                 lastError = Exception(errorMsg, e)
-                
+
                 // 记录错误日志（包含堆栈）
-                logger.error("创建订单异常 (尝试 $attempt/$MAX_RETRY_ATTEMPTS): copyTradingId=$copyTradingId, tradeId=$tradeId, $errorMsg", e)
-                
+                logger.error(
+                    "创建订单异常 (尝试 $attempt/$MAX_RETRY_ATTEMPTS): copyTradingId=$copyTradingId, tradeId=$tradeId, $errorMsg",
+                    e
+                )
+
                 // 如果不是最后一次尝试，等待后重试
                 if (attempt < MAX_RETRY_ATTEMPTS) {
                     delay(RETRY_DELAY_MS)
@@ -1168,7 +1231,10 @@ open class CopyOrderTrackingService(
 
         // 所有重试都失败
         val finalError = lastError ?: Exception("error=未知错误")
-        logger.error("创建订单失败（所有重试都失败）: copyTradingId=$copyTradingId, tradeId=$tradeId, side=$side, price=$price, size=$size", finalError)
+        logger.error(
+            "创建订单失败（所有重试都失败）: copyTradingId=$copyTradingId, tradeId=$tradeId, side=$side, price=$price, size=$size",
+            finalError
+        )
         return Result.failure(finalError)
     }
 
@@ -1303,7 +1369,7 @@ open class CopyOrderTrackingService(
 
         // 计算价格调整范围（百分比）
         val tolerancePercent = tolerance.div(100)
-        val adjustment = originalPrice.multi(tolerancePercent)
+        val adjustment = originalPrice.multi(tolerancePercent).max(0.01.toSafeBigDecimal())
 
         return if (isBuy) {
             // 买入：可以稍微加价以确保成交（在原价格基础上加容忍度）
@@ -1356,7 +1422,7 @@ open class CopyOrderTrackingService(
     /**
      * 验证订单ID格式
      * 订单ID必须以 0x 开头，且是有效的 16 进制字符串
-     * 
+     *
      * @param orderId 订单ID
      * @return 如果格式有效返回 true，否则返回 false
      */
@@ -1372,11 +1438,11 @@ open class CopyOrderTrackingService(
         // 检查是否只包含 0-9, a-f, A-F
         return hexPart.all { it in '0'..'9' || it in 'a'..'f' || it in 'A'..'F' }
     }
-    
+
     /**
      * 获取订单的实际成交价
      * 通过查询订单详情和关联的交易记录，计算加权平均成交价
-     * 
+     *
      * @param orderId 订单ID
      * @param clobApi CLOB API 客户端（已认证）
      * @param fallbackPrice 如果查询失败，使用此价格作为默认值
@@ -1395,14 +1461,14 @@ open class CopyOrderTrackingService(
                 logger.warn("查询订单详情失败: orderId=$orderId, code=${orderResponse.code()}, errorBody=$errorBody")
                 return fallbackPrice
             }
-            
+
             val order = orderResponse.body()
             if (order == null) {
                 // 响应体为空，可能是订单不存在或已过期
                 logger.warn("查询订单详情失败: 响应体为空, orderId=$orderId, code=${orderResponse.code()}")
                 return fallbackPrice
             }
-            
+
             // 2. 如果订单未成交，使用下单价格
             if (order.status != "FILLED" && order.sizeMatched.toSafeBigDecimal() <= BigDecimal.ZERO) {
                 logger.debug("订单未成交，使用下单价格: orderId=$orderId, status=${order.status}")
@@ -1443,7 +1509,7 @@ open class CopyOrderTrackingService(
             for (trade in trades) {
                 val tradePrice = trade.price.toSafeBigDecimal()
                 val tradeSize = trade.size.toSafeBigDecimal()
-                
+
                 if (tradeSize > BigDecimal.ZERO) {
                     totalAmount = totalAmount.add(tradePrice.multiply(tradeSize))
                     totalSize = totalSize.add(tradeSize)

backend/src/main/kotlin/com/wrbug/polymarketbot/service/copytrading/statistics/OrderStatusUpdateService.kt

@@ -143,8 +143,13 @@ class OrderStatusUpdateService(
             // 计算30秒前的时间戳
             val thirtySecondsAgo = System.currentTimeMillis() - 30000
             
-            // 查询30秒前创建的订单
-            val ordersToCheck = copyOrderTrackingRepository.findByCreatedAtBefore(thirtySecondsAgo)
+            // 查询30秒前创建的订单,并过滤掉已经完全匹配的订单
+            // 已经完全匹配的订单(status = "fully_matched")不需要再检查
+            // 使用数据库查询过滤，避免加载过多数据
+            val ordersToCheck = copyOrderTrackingRepository.findByCreatedAtBeforeAndStatusNot(
+                thirtySecondsAgo, 
+                "fully_matched"
+            )
             
             if (ordersToCheck.isEmpty()) {
                 return

backend/src/main/kotlin/com/wrbug/polymarketbot/service/system/TelegramNotificationService.kt

@@ -43,6 +43,25 @@ class TelegramNotificationService(
     // 协程作用域
     private val scope = CoroutineScope(Dispatchers.IO + SupervisorJob())
 
+    /**
+     * 发送订单成功通知
+     * @param orderId 订单ID（用于查询订单详情获取实际价格和数量）
+     * @param marketTitle 市场标题
+     * @param marketId 市场ID（conditionId），用于生成链接
+     * @param marketSlug 市场slug，用于生成链接
+     * @param side 订单方向（BUY/SELL），用于多语言显示
+     * @param accountName 账户名称
+     * @param walletAddress 钱包地址
+     * @param clobApi CLOB API 客户端（可选，如果提供则查询订单详情获取实际价格和数量）
+     * @param apiKey API Key（可选，用于查询订单详情）
+     * @param apiSecret API Secret（可选，用于查询订单详情）
+     * @param apiPassphrase API Passphrase（可选，用于查询订单详情）
+     * @param walletAddressForApi 钱包地址（可选，用于查询订单详情）
+     * @param locale 语言设置（可选，如果提供则使用，否则使用 LocaleContextHolder 获取）
+     */
+    // 已发送通知的订单ID缓存（key: orderId, value: timestamp）
+    private val sentOrderIds = java.util.concurrent.ConcurrentHashMap<String, Long>()
+
     /**
      * 发送订单成功通知
      * @param orderId 订单ID（用于查询订单详情获取实际价格和数量）
@@ -79,6 +98,26 @@ class TelegramNotificationService(
         leaderName: String? = null,  // Leader 名称（备注）
         configName: String? = null  // 跟单配置名
     ) {
+        // 1. 如果提供了 orderId，检查是否已发送过通知（去重）
+        if (orderId != null) {
+            val lastSentTime = sentOrderIds[orderId]
+            if (lastSentTime != null) {
+                // 如果5分钟内已发送过，跳过
+                if (System.currentTimeMillis() - lastSentTime < 5 * 60 * 1000) {
+                    logger.info("订单通知已发送过（5分钟内），跳过: orderId=$orderId")
+                    return
+                }
+            }
+            // 记录发送时间
+            sentOrderIds[orderId] = System.currentTimeMillis()
+            
+            // 简单的清理逻辑：如果缓存过大，清理过期的
+            if (sentOrderIds.size > 1000) {
+                val expiryTime = System.currentTimeMillis() - 5 * 60 * 1000
+                sentOrderIds.entries.removeIf { it.value < expiryTime }
+            }
+        }
+
         // 获取语言设置（优先使用传入的 locale，否则从 LocaleContextHolder 获取）
         val currentLocale = locale ?: try {
             LocaleContextHolder.getLocale()
@@ -686,6 +725,13 @@ class TelegramNotificationService(
             else -> side
         }
         
+        // 获取图标
+        val icon = when (side.uppercase()) {
+            "BUY" -> "🚀"
+            "SELL" -> "💰"
+            else -> "📣"
+        }
+        
         // 构建账户信息（格式：账户名(钱包地址)）
         val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
 
@@ -761,7 +807,7 @@ class TelegramNotificationService(
         val priceDisplay = formatPrice(price)
         val sizeDisplay = formatQuantity(size)
 
-        return """✅ <b>$orderCreatedSuccess</b>
+        return """$icon <b>$orderCreatedSuccess</b>
 
 📊 <b>$orderInfo：</b>
 • $orderIdLabel: <code>${orderId ?: unknown}</code>
@@ -989,7 +1035,7 @@ class TelegramNotificationService(
             "  • ${position.marketId.substring(0, 8)}... (${position.side}): $quantityDisplay shares = $valueDisplay USDC"
         }
         
-        return """✅ <b>$redeemSuccess</b>
+        return """💸 <b>$redeemSuccess</b>
 
 📊 <b>$redeemInfo：</b>
 • $accountLabel: $escapedAccountInfo

backend/src/main/resources/application.properties

@@ -29,9 +29,9 @@ server.port=${SERVER_PORT:8000}
 # 默认使用 dev 环境，可通过 --spring.profiles.active=prod 切换
 spring.profiles.active=${SPRING_PROFILES_ACTIVE:dev}
 
-# 日志配置
-logging.level.root=INFO
-logging.level.com.wrbug.polyhermes=DEBUG
+# 日志配置（支持通过环境变量配置）
+logging.level.root=${LOG_LEVEL_ROOT:INFO}
+logging.level.com.wrbug.polymarketbot=${LOG_LEVEL_APP:DEBUG}
 logging.pattern.console=%d{yyyy-MM-dd HH:mm:ss} - %msg%n
 
 # Polymarket API 配置

deploy.sh

@@ -76,6 +76,11 @@ JWT_SECRET=${JWT_SECRET}
 
 # 管理员密码重置密钥（已自动生成随机值，生产环境建议修改）
 ADMIN_RESET_PASSWORD_KEY=${ADMIN_RESET_KEY}
+
+# 日志级别配置（可选，默认值：root=INFO, app=DEBUG）
+# 可选值：TRACE, DEBUG, INFO, WARN, ERROR, OFF
+# LOG_LEVEL_ROOT=INFO
+# LOG_LEVEL_APP=DEBUG
 EOF
         info ".env 文件已创建，已自动生成随机密码和密钥"
         warn "生产环境建议修改以下参数："

docker-compose.prod.yml

@@ -29,6 +29,10 @@ services:
       # 生成随机密钥：openssl rand -hex 32 (ADMIN_RESET_PASSWORD_KEY) 或 openssl rand -hex 64 (JWT_SECRET)
       - JWT_SECRET=${JWT_SECRET:-change-me-in-production}
       - ADMIN_RESET_PASSWORD_KEY=${ADMIN_RESET_PASSWORD_KEY:-change-me-in-production}
+      # 日志级别配置（可选，默认值：root=INFO, app=DEBUG）
+      # 可选值：TRACE, DEBUG, INFO, WARN, ERROR, OFF
+      - LOG_LEVEL_ROOT=${LOG_LEVEL_ROOT:-INFO}
+      - LOG_LEVEL_APP=${LOG_LEVEL_APP:-DEBUG}
     depends_on:
       mysql:
         condition: service_healthy

docker-compose.yml

@@ -27,6 +27,10 @@ services:
       # 生成随机密钥：openssl rand -hex 32 (ADMIN_RESET_PASSWORD_KEY) 或 openssl rand -hex 64 (JWT_SECRET)
       - JWT_SECRET=${JWT_SECRET:-change-me-in-production}
       - ADMIN_RESET_PASSWORD_KEY=${ADMIN_RESET_PASSWORD_KEY:-change-me-in-production}
+      # 日志级别配置（可选，默认值：root=INFO, app=DEBUG）
+      # 可选值：TRACE, DEBUG, INFO, WARN, ERROR, OFF
+      - LOG_LEVEL_ROOT=${LOG_LEVEL_ROOT:-INFO}
+      - LOG_LEVEL_APP=${LOG_LEVEL_APP:-DEBUG}
     depends_on:
       mysql:
         condition: service_healthy

docs/zh/smart-money-analysis.md

@@ -1,835 +0,0 @@
-# Polymarket 聪明钱分析方案
-
-## 1. 概述
-
-聪明钱（Smart Money）分析是指识别和跟踪在 Polymarket 平台上表现优异的交易者，通过分析他们的交易行为、持仓和盈亏表现，来辅助投资决策。
-
-## 2. 核心分析维度
-
-### 2.1 交易表现指标
-
-#### 2.1.1 胜率（Win Rate）
-- **定义**：盈利交易数 / 总交易数
-- **计算方式**：
-  - 通过 `getUserActivity` API 获取用户历史交易
-  - 筛选 `type = "TRADE"` 的活动
-  - 计算每笔交易的盈亏（通过买入价和卖出价）
-  - 统计盈利交易数和总交易数
-
-#### 2.1.2 平均盈亏比（Average PnL Ratio）
-- **定义**：平均盈利金额 / 平均亏损金额
-- **计算方式**：
-  - 分别计算盈利交易和亏损交易的平均金额
-  - 计算比值
-
-#### 2.1.3 总盈亏（Total PnL）
-- **定义**：所有已实现盈亏的总和
-- **数据来源**：
-  - 通过 `getPositions` API 获取 `realizedPnl`
-  - 或通过 `getUserActivity` API 计算历史交易的累计盈亏
-
-#### 2.1.4 未实现盈亏（Unrealized PnL）
-- **定义**：当前持仓的浮动盈亏
-- **数据来源**：
-  - 通过 `getPositions` API 获取 `cashPnl`（当前盈亏）
-  - 或通过 `currentValue - initialValue` 计算
-
-#### 2.1.5 收益率（Return Rate）
-- **定义**：总盈亏 / 总投入
-- **计算方式**：
-  - 总投入 = 所有买入交易的总金额
-  - 总盈亏 = 已实现盈亏 + 未实现盈亏
-  - 收益率 = 总盈亏 / 总投入
-
-### 2.2 交易行为指标
-
-#### 2.2.1 交易频率（Trading Frequency）
-- **定义**：单位时间内的交易次数
-- **计算方式**：
-  - 通过 `getUserActivity` API 获取指定时间范围内的交易数
-  - 计算日均/周均交易次数
-
-#### 2.2.2 持仓周期（Holding Period）
-- **定义**：平均持仓时间
-- **计算方式**：
-  - 跟踪每笔买入和对应的卖出时间
-  - 计算平均持仓天数
-
-#### 2.2.3 市场偏好（Market Preference）
-- **定义**：交易者偏好的市场类型
-- **计算方式**：
-  - 统计交易者在不同分类（sports、crypto）的交易分布
-  - 统计交易者偏好的市场主题
-
-#### 2.2.4 仓位规模（Position Size）
-- **定义**：平均单笔交易金额
-- **计算方式**：
-  - 通过 `getUserActivity` API 获取 `usdcSize`
-  - 计算平均交易金额
-
-### 2.3 风险指标
-
-#### 2.3.1 最大回撤（Maximum Drawdown）
-- **定义**：从峰值到谷值的最大跌幅
-- **计算方式**：
-  - 跟踪账户价值的时序变化
-  - 计算每个峰值的回撤幅度
-  - 取最大值
-
-#### 2.3.2 夏普比率（Sharpe Ratio）
-- **定义**：风险调整后的收益率
-- **计算方式**：
-  - 收益率标准差 / 平均收益率
-  - 需要足够的历史数据
-
-#### 2.3.3 胜率稳定性（Win Rate Stability）
-- **定义**：不同时间段胜率的一致性
-- **计算方式**：
-  - 按时间段（如每月）计算胜率
-  - 计算胜率的方差或标准差
-
-## 3. 数据收集方法
-
-### 3.1 使用 Polymarket Data API
-
-#### 3.1.1 获取用户仓位
-```kotlin
-// 接口：GET /positions
-// 参数：
-// - user: 用户钱包地址（必需）
-// - market: 市场ID（可选）
-// - limit: 限制数量（可选）
-// - offset: 偏移量（可选）
-// - sortBy: 排序字段（可选，如 "currentValue"）
-// - sortDirection: 排序方向（可选，如 "desc"）
-
-val positions = dataApi.getPositions(
-    user = walletAddress,
-    limit = 100,
-    sortBy = "currentValue",
-    sortDirection = "desc"
-)
-```
-
-**返回数据包含**：
-- `currentValue`: 当前仓位价值
-- `cashPnl`: 当前盈亏（未实现）
-- `realizedPnl`: 已实现盈亏
-- `percentPnl`: 盈亏百分比
-- `avgPrice`: 平均买入价
-- `curPrice`: 当前价格
-
-#### 3.1.2 获取用户活动（交易历史）
-```kotlin
-// 接口：GET /activity
-// 参数：
-// - user: 用户钱包地址（必需）
-// - type: 活动类型（可选，如 ["TRADE"]）
-// - side: 交易方向（可选，如 "BUY" 或 "SELL"）
-// - start: 开始时间戳（可选）
-// - end: 结束时间戳（可选）
-// - limit: 限制数量（可选）
-// - offset: 偏移量（可选）
-
-val activities = dataApi.getUserActivity(
-    user = walletAddress,
-    type = listOf("TRADE"),
-    side = "BUY",
-    start = startTimestamp,
-    end = endTimestamp,
-    limit = 1000
-)
-```
-
-**返回数据包含**：
-- `type`: 活动类型（TRADE、SPLIT、MERGE、REDEEM等）
-- `side`: 交易方向（BUY、SELL）
-- `size`: 交易数量
-- `usdcSize`: 交易金额（USDC）
-- `price`: 交易价格
-- `timestamp`: 交易时间戳
-- `title`: 市场标题
-- `slug`: 市场标识
-
-#### 3.1.3 获取仓位总价值
-```kotlin
-// 接口：GET /value
-// 参数：
-// - user: 用户钱包地址（必需）
-// - market: 市场ID列表（可选）
-
-val totalValue = dataApi.getTotalValue(
-    user = walletAddress,
-    market = listOf("market1", "market2")
-)
-```
-
-### 3.2 使用 Polymarket CLOB API
-
-#### 3.2.1 获取交易记录
-```kotlin
-// 接口：GET /data/trades
-// 参数：
-// - maker_address: 交易者地址（可选）
-// - market: 市场ID（可选）
-// - before: 之前的时间戳（可选，用于分页）
-// - after: 之后的时间戳（可选，用于分页）
-// - next_cursor: 分页游标（可选）
-
-val trades = clobApi.getTrades(
-    maker_address = walletAddress,
-    market = marketId,
-    after = startTimestamp.toString()
-)
-```
-
-**返回数据包含**：
-- `id`: 交易ID
-- `market`: 市场ID
-- `side`: 交易方向（BUY、SELL）
-- `price`: 交易价格
-- `size`: 交易数量
-- `timestamp`: 交易时间戳
-- `user`: 交易者地址
-
-## 4. 聪明钱识别算法
-
-### 4.1 基础筛选条件
-
-#### 4.1.1 最低交易次数
-- **条件**：总交易数 >= 50
-- **目的**：确保有足够的数据进行统计分析
-
-#### 4.1.2 最低胜率
-- **条件**：胜率 >= 55%
-- **目的**：筛选出表现优于随机交易者
-
-#### 4.1.3 最低总盈亏
-- **条件**：总盈亏 >= 1000 USDC
-- **目的**：筛选出有实际盈利能力的交易者
-
-#### 4.1.4 最低收益率
-- **条件**：收益率 >= 20%
-- **目的**：筛选出有良好回报的交易者
-
-### 4.2 综合评分算法
-
-```kotlin
-// 聪明钱评分算法
-fun calculateSmartMoneyScore(
-    winRate: Double,           // 胜率（0-1）
-    totalPnl: Double,         // 总盈亏（USDC）
-    returnRate: Double,        // 收益率（0-1）
-    tradeCount: Int,           // 交易次数
-    avgPnlRatio: Double        // 平均盈亏比
-): Double {
-    // 权重配置
-    val winRateWeight = 0.3
-    val totalPnlWeight = 0.25
-    val returnRateWeight = 0.25
-    val tradeCountWeight = 0.1
-    val avgPnlRatioWeight = 0.1
-    
-    // 归一化处理
-    val normalizedWinRate = winRate * 100  // 转换为百分比
-    val normalizedTotalPnl = min(totalPnl / 10000, 1.0) * 100  // 归一化到0-100
-    val normalizedReturnRate = returnRate * 100  // 转换为百分比
-    val normalizedTradeCount = min(tradeCount / 200, 1.0) * 100  // 归一化到0-100
-    val normalizedAvgPnlRatio = min(avgPnlRatio / 3.0, 1.0) * 100  // 归一化到0-100
-    
-    // 加权求和
-    val score = normalizedWinRate * winRateWeight +
-                normalizedTotalPnl * totalPnlWeight +
-                normalizedReturnRate * returnRateWeight +
-                normalizedTradeCount * tradeCountWeight +
-                normalizedAvgPnlRatio * avgPnlRatioWeight
-    
-    return score
-}
-```
-
-### 4.3 排名算法
-
-1. **按综合评分排序**：计算所有候选交易者的综合评分，按降序排列
-2. **按分类排名**：分别计算 sports 和 crypto 分类的排名
-3. **按时间段排名**：分别计算最近7天、30天、90天的排名
-
-## 5. 实时监控方案
-
-### 5.1 监控目标
-
-1. **新交易**：监控聪明钱交易者的新买入/卖出交易
-2. **持仓变化**：监控聪明钱交易者的持仓变化
-3. **市场关注**：监控聪明钱交易者关注的新市场
-
-### 5.2 实现方式
-
-#### 5.2.1 使用 WebSocket（推荐）
-- 订阅 Polymarket WebSocket 的 User Channel
-- 监听 `event_type = "trade"` 事件
-- 过滤出聪明钱交易者的交易
-
-#### 5.2.2 使用轮询
-- 定期调用 `getUserActivity` API（如每5分钟）
-- 比较时间戳，识别新交易
-- 使用 `after` 参数只获取新数据
-
-### 5.3 跟单集成
-
-聪明钱分析可以与现有的跟单系统集成：
-
-1. **自动添加 Leader**：识别到聪明钱交易者后，自动添加到 Leader 列表
-2. **智能跟单**：根据聪明钱交易者的表现，动态调整跟单比例
-3. **风险控制**：根据聪明钱交易者的风险指标，设置跟单限制
-
-## 6. 实现示例
-
-### 6.1 聪明钱分析服务
-
-```kotlin
-@Service
-class SmartMoneyAnalysisService(
-    private val retrofitFactory: RetrofitFactory,
-    private val blockchainService: BlockchainService
-) {
-    private val logger = LoggerFactory.getLogger(SmartMoneyAnalysisService::class.java)
-    private val dataApi = retrofitFactory.createDataApi()
-    
-    /**
-     * 分析单个交易者的表现
-     */
-    suspend fun analyzeTrader(walletAddress: String, days: Int = 90): Result<TraderAnalysis> {
-        return try {
-            val endTime = System.currentTimeMillis()
-            val startTime = endTime - (days * 24 * 60 * 60 * 1000L)
-            
-            // 1. 获取交易历史
-            val activitiesResult = getTradeActivities(walletAddress, startTime, endTime)
-            if (activitiesResult.isFailure) {
-                return Result.failure(activitiesResult.exceptionOrNull() ?: Exception("获取交易历史失败"))
-            }
-            val activities = activitiesResult.getOrNull() ?: emptyList()
-            
-            // 2. 获取当前仓位
-            val positionsResult = blockchainService.getPositions(walletAddress)
-            val positions = if (positionsResult.isSuccess) {
-                positionsResult.getOrNull() ?: emptyList()
-            } else {
-                emptyList()
-            }
-            
-            // 3. 计算指标
-            val metrics = calculateMetrics(activities, positions)
-            
-            // 4. 计算综合评分
-            val score = calculateSmartMoneyScore(
-                winRate = metrics.winRate,
-                totalPnl = metrics.totalPnl,
-                returnRate = metrics.returnRate,
-                tradeCount = metrics.tradeCount,
-                avgPnlRatio = metrics.avgPnlRatio
-            )
-            
-            Result.success(
-                TraderAnalysis(
-                    walletAddress = walletAddress,
-                    metrics = metrics,
-                    score = score,
-                    positions = positions.size,
-                    lastTradeTime = activities.maxByOrNull { it.timestamp }?.timestamp
-                )
-            )
-        } catch (e: Exception) {
-            logger.error("分析交易者失败: ${e.message}", e)
-            Result.failure(e)
-        }
-    }
-    
-    /**
-     * 获取交易活动
-     */
-    private suspend fun getTradeActivities(
-        walletAddress: String,
-        startTime: Long,
-        endTime: Long
-    ): Result<List<UserActivityResponse>> {
-        return try {
-            val response = dataApi.getUserActivity(
-                user = walletAddress,
-                type = listOf("TRADE"),
-                start = startTime,
-                end = endTime,
-                limit = 1000,
-                sortBy = "timestamp",
-                sortDirection = "desc"
-            )
-            
-            if (response.isSuccessful && response.body() != null) {
-                Result.success(response.body()!!)
-            } else {
-                Result.failure(Exception("获取交易活动失败: ${response.code()} ${response.message()}"))
-            }
-        } catch (e: Exception) {
-            logger.error("获取交易活动异常: ${e.message}", e)
-            Result.failure(e)
-        }
-    }
-    
-    /**
-     * 计算交易指标
-     */
-    private fun calculateMetrics(
-        activities: List<UserActivityResponse>,
-        positions: List<PositionResponse>
-    ): TraderMetrics {
-        // 分离买入和卖出交易
-        val buyTrades = activities.filter { it.side == "BUY" }
-        val sellTrades = activities.filter { it.side == "SELL" }
-        
-        // 计算总交易数
-        val tradeCount = activities.size
-        
-        // 计算总投入（买入金额总和）
-        val totalInvested = buyTrades.sumOf { it.usdcSize ?: 0.0 }
-        
-        // 计算已实现盈亏（从仓位数据）
-        val realizedPnl = positions.sumOf { it.realizedPnl ?: 0.0 }
-        
-        // 计算未实现盈亏（从仓位数据）
-        val unrealizedPnl = positions.sumOf { it.cashPnl ?: 0.0 }
-        
-        // 计算总盈亏
-        val totalPnl = realizedPnl + unrealizedPnl
-        
-        // 计算收益率
-        val returnRate = if (totalInvested > 0) {
-            totalPnl / totalInvested
-        } else {
-            0.0
-        }
-        
-        // 计算胜率（需要匹配买入和卖出交易）
-        val winRate = calculateWinRate(buyTrades, sellTrades)
-        
-        // 计算平均盈亏比
-        val avgPnlRatio = calculateAvgPnlRatio(buyTrades, sellTrades)
-        
-        return TraderMetrics(
-            tradeCount = tradeCount,
-            totalInvested = totalInvested,
-            totalPnl = totalPnl,
-            realizedPnl = realizedPnl,
-            unrealizedPnl = unrealizedPnl,
-            returnRate = returnRate,
-            winRate = winRate,
-            avgPnlRatio = avgPnlRatio
-        )
-    }
-    
-    /**
-     * 计算胜率
-     * 通过匹配买入和卖出交易来计算
-     */
-    private fun calculateWinRate(
-        buyTrades: List<UserActivityResponse>,
-        sellTrades: List<UserActivityResponse>
-    ): Double {
-        // 按市场分组买入和卖出交易
-        val buyByMarket = buyTrades.groupBy { it.conditionId }
-        val sellByMarket = sellTrades.groupBy { it.conditionId }
-        
-        var winCount = 0
-        var totalCount = 0
-        
-        // 遍历每个市场
-        buyByMarket.forEach { (marketId, buys) ->
-            val sells = sellByMarket[marketId] ?: emptyList()
-            
-            // 简单匹配：按时间顺序匹配买入和卖出
-            // 实际应该使用更精确的匹配算法（如 FIFO）
-            var buyIndex = 0
-            var sellIndex = 0
-            
-            while (buyIndex < buys.size && sellIndex < sells.size) {
-                val buy = buys[buyIndex]
-                val sell = sells[sellIndex]
-                
-                // 计算盈亏
-                val buyPrice = buy.price ?: 0.0
-                val sellPrice = sell.price ?: 0.0
-                val pnl = (sellPrice - buyPrice) * (buy.size ?: 0.0)
-                
-                if (pnl > 0) {
-                    winCount++
-                }
-                totalCount++
-                
-                buyIndex++
-                sellIndex++
-            }
-        }
-        
-        return if (totalCount > 0) {
-            winCount.toDouble() / totalCount
-        } else {
-            0.0
-        }
-    }
-    
-    /**
-     * 计算平均盈亏比
-     */
-    private fun calculateAvgPnlRatio(
-        buyTrades: List<UserActivityResponse>,
-        sellTrades: List<UserActivityResponse>
-    ): Double {
-        // 类似胜率计算，分别计算盈利和亏损的平均金额
-        val buyByMarket = buyTrades.groupBy { it.conditionId }
-        val sellByMarket = sellTrades.groupBy { it.conditionId }
-        
-        val profits = mutableListOf<Double>()
-        val losses = mutableListOf<Double>()
-        
-        buyByMarket.forEach { (marketId, buys) ->
-            val sells = sellByMarket[marketId] ?: emptyList()
-            
-            var buyIndex = 0
-            var sellIndex = 0
-            
-            while (buyIndex < buys.size && sellIndex < sells.size) {
-                val buy = buys[buyIndex]
-                val sell = sells[sellIndex]
-                
-                val buyPrice = buy.price ?: 0.0
-                val sellPrice = sell.price ?: 0.0
-                val pnl = (sellPrice - buyPrice) * (buy.size ?: 0.0)
-                
-                if (pnl > 0) {
-                    profits.add(pnl)
-                } else if (pnl < 0) {
-                    losses.add(-pnl)
-                }
-                
-                buyIndex++
-                sellIndex++
-            }
-        }
-        
-        val avgProfit = if (profits.isNotEmpty()) {
-            profits.average()
-        } else {
-            0.0
-        }
-        
-        val avgLoss = if (losses.isNotEmpty()) {
-            losses.average()
-        } else {
-            0.0
-        }
-        
-        return if (avgLoss > 0) {
-            avgProfit / avgLoss
-        } else {
-            if (avgProfit > 0) Double.MAX_VALUE else 0.0
-        }
-    }
-    
-    /**
-     * 计算聪明钱评分
-     */
-    private fun calculateSmartMoneyScore(
-        winRate: Double,
-        totalPnl: Double,
-        returnRate: Double,
-        tradeCount: Int,
-        avgPnlRatio: Double
-    ): Double {
-        val winRateWeight = 0.3
-        val totalPnlWeight = 0.25
-        val returnRateWeight = 0.25
-        val tradeCountWeight = 0.1
-        val avgPnlRatioWeight = 0.1
-        
-        val normalizedWinRate = winRate * 100
-        val normalizedTotalPnl = min(totalPnl / 10000, 1.0) * 100
-        val normalizedReturnRate = returnRate * 100
-        val normalizedTradeCount = min(tradeCount / 200.0, 1.0) * 100
-        val normalizedAvgPnlRatio = min(avgPnlRatio / 3.0, 1.0) * 100
-        
-        val score = normalizedWinRate * winRateWeight +
-                    normalizedTotalPnl * totalPnlWeight +
-                    normalizedReturnRate * returnRateWeight +
-                    normalizedTradeCount * tradeCountWeight +
-                    normalizedAvgPnlRatio * avgPnlRatioWeight
-        
-        return score
-    }
-    
-    /**
-     * 批量分析交易者
-     */
-    suspend fun analyzeTraders(
-        walletAddresses: List<String>,
-        days: Int = 90
-    ): Result<List<TraderAnalysis>> {
-        return try {
-            val analyses = walletAddresses.mapNotNull { address ->
-                analyzeTrader(address, days).getOrNull()
-            }
-            Result.success(analyses.sortedByDescending { it.score })
-        } catch (e: Exception) {
-            logger.error("批量分析交易者失败: ${e.message}", e)
-            Result.failure(e)
-        }
-    }
-}
-
-/**
- * 交易者分析结果
- */
-data class TraderAnalysis(
-    val walletAddress: String,
-    val metrics: TraderMetrics,
-    val score: Double,
-    val positions: Int,
-    val lastTradeTime: Long?
-)
-
-/**
- * 交易者指标
- */
-data class TraderMetrics(
-    val tradeCount: Int,
-    val totalInvested: Double,
-    val totalPnl: Double,
-    val realizedPnl: Double,
-    val unrealizedPnl: Double,
-    val returnRate: Double,
-    val winRate: Double,
-    val avgPnlRatio: Double
-)
-```
-
-### 6.2 聪明钱排名服务
-
-```kotlin
-@Service
-class SmartMoneyRankingService(
-    private val smartMoneyAnalysisService: SmartMoneyAnalysisService
-) {
-    private val logger = LoggerFactory.getLogger(SmartMoneyRankingService::class.java)
-    
-    /**
-     * 获取聪明钱排名
-     */
-    suspend fun getRankings(
-        category: String? = null,  // sports 或 crypto
-        days: Int = 90,
-        limit: Int = 100
-    ): Result<List<TraderRanking>> {
-        return try {
-            // 1. 获取候选交易者列表
-            // 这里需要从某个数据源获取（如数据库、API等）
-            val candidates = getCandidateTraders(category)
-            
-            // 2. 批量分析交易者
-            val analysesResult = smartMoneyAnalysisService.analyzeTraders(candidates, days)
-            if (analysesResult.isFailure) {
-                return Result.failure(analysesResult.exceptionOrNull() ?: Exception("分析失败"))
-            }
-            val analyses = analysesResult.getOrNull() ?: emptyList()
-            
-            // 3. 筛选和排序
-            val rankings = analyses
-                .filter { it.metrics.tradeCount >= 50 }  // 最低交易次数
-                .filter { it.metrics.winRate >= 0.55 }  // 最低胜率
-                .filter { it.metrics.totalPnl >= 1000 }  // 最低总盈亏
-                .sortedByDescending { it.score }
-                .take(limit)
-                .mapIndexed { index, analysis ->
-                    TraderRanking(
-                        rank = index + 1,
-                        walletAddress = analysis.walletAddress,
-                        score = analysis.score,
-                        metrics = analysis.metrics,
-                        positions = analysis.positions,
-                        lastTradeTime = analysis.lastTradeTime
-                    )
-                }
-            
-            Result.success(rankings)
-        } catch (e: Exception) {
-            logger.error("获取排名失败: ${e.message}", e)
-            Result.failure(e)
-        }
-    }
-    
-    /**
-     * 获取候选交易者列表
-     * 这里需要实现具体的获取逻辑（如从数据库、API等）
-     */
-    private suspend fun getCandidateTraders(category: String?): List<String> {
-        // TODO: 实现获取候选交易者的逻辑
-        // 可以从以下来源获取：
-        // 1. 数据库中的 Leader 列表
-        // 2. Polymarket 的公开数据
-        // 3. 用户提交的交易者地址
-        return emptyList()
-    }
-}
-
-/**
- * 交易者排名
- */
-data class TraderRanking(
-    val rank: Int,
-    val walletAddress: String,
-    val score: Double,
-    val metrics: TraderMetrics,
-    val positions: Int,
-    val lastTradeTime: Long?
-)
-```
-
-## 7. 数据存储建议
-
-### 7.1 数据库表设计
-
-```sql
--- 聪明钱交易者表
-CREATE TABLE smart_money_traders (
-    id BIGINT AUTO_INCREMENT PRIMARY KEY,
-    wallet_address VARCHAR(42) NOT NULL UNIQUE,
-    score DOUBLE NOT NULL,
-    win_rate DOUBLE NOT NULL,
-    total_pnl DECIMAL(20, 8) NOT NULL,
-    return_rate DOUBLE NOT NULL,
-    trade_count INT NOT NULL,
-    category VARCHAR(20),  -- sports 或 crypto
-    last_analysis_time BIGINT NOT NULL,
-    created_at BIGINT NOT NULL,
-    updated_at BIGINT NOT NULL,
-    INDEX idx_score (score DESC),
-    INDEX idx_category (category),
-    INDEX idx_last_analysis_time (last_analysis_time)
-);
-
--- 交易者历史指标表（用于追踪指标变化）
-CREATE TABLE trader_metrics_history (
-    id BIGINT AUTO_INCREMENT PRIMARY KEY,
-    wallet_address VARCHAR(42) NOT NULL,
-    win_rate DOUBLE NOT NULL,
-    total_pnl DECIMAL(20, 8) NOT NULL,
-    return_rate DOUBLE NOT NULL,
-    trade_count INT NOT NULL,
-    recorded_at BIGINT NOT NULL,
-    INDEX idx_wallet_address (wallet_address),
-    INDEX idx_recorded_at (recorded_at)
-);
-```
-
-### 7.2 缓存策略
-
-- **Redis 缓存**：缓存聪明钱排名列表，减少数据库查询
-- **缓存过期时间**：建议 1 小时
-- **缓存键**：`smart_money:rankings:{category}:{days}`
-
-## 8. API 接口设计
-
-### 8.1 获取聪明钱排名
-
-```kotlin
-@PostMapping("/smart-money/rankings")
-fun getRankings(@RequestBody request: SmartMoneyRankingsRequest): ResponseEntity<ApiResponse<SmartMoneyRankingsResponse>> {
-    // 实现逻辑
-}
-```
-
-**请求参数**：
-```json
-{
-  "category": "sports",  // 可选：sports 或 crypto
-  "days": 90,           // 可选：分析时间范围（天）
-  "limit": 100,         // 可选：返回数量
-  "minScore": 50        // 可选：最低评分
-}
-```
-
-**响应数据**：
-```json
-{
-  "code": 0,
-  "data": {
-    "rankings": [
-      {
-        "rank": 1,
-        "walletAddress": "0x...",
-        "score": 85.5,
-        "metrics": {
-          "tradeCount": 150,
-          "winRate": 0.65,
-          "totalPnl": 5000.0,
-          "returnRate": 0.35,
-          "avgPnlRatio": 2.5
-        },
-        "positions": 10,
-        "lastTradeTime": 1234567890
-      }
-    ],
-    "total": 100
-  },
-  "msg": ""
-}
-```
-
-### 8.2 分析单个交易者
-
-```kotlin
-@PostMapping("/smart-money/analyze")
-fun analyzeTrader(@RequestBody request: SmartMoneyAnalyzeRequest): ResponseEntity<ApiResponse<TraderAnalysisDto>> {
-    // 实现逻辑
-}
-```
-
-**请求参数**：
-```json
-{
-  "walletAddress": "0x...",
-  "days": 90
-}
-```
-
-## 9. 注意事项
-
-### 9.1 API 限制
-
-- **Data API 速率限制**：注意 API 调用频率，避免触发限流
-- **数据延迟**：Data API 的数据可能有延迟，不是实时的
-- **数据完整性**：某些历史数据可能不完整，需要处理缺失数据
-
-### 9.2 计算精度
-
-- **价格精度**：Polymarket 使用 0.01-0.99 的价格范围，注意精度问题
-- **金额精度**：使用 `BigDecimal` 进行金额计算，避免浮点数误差
-- **时间精度**：注意时间戳的精度（毫秒 vs 秒）
-
-### 9.3 性能优化
-
-- **批量查询**：尽量批量查询多个交易者的数据
-- **缓存策略**：缓存分析结果，避免重复计算
-- **异步处理**：使用异步任务处理大量数据分析
-
-### 9.4 数据质量
-
-- **数据验证**：验证 API 返回的数据完整性
-- **异常处理**：处理 API 调用失败的情况
-- **数据清洗**：清洗异常数据（如价格为 0、数量为负数等）
-
-## 10. 后续优化方向
-
-1. **机器学习模型**：使用机器学习模型预测交易者未来表现
-2. **实时监控**：集成 WebSocket 实现实时监控聪明钱交易
-3. **跟单推荐**：根据聪明钱分析结果，推荐适合跟单的交易者
-4. **风险预警**：监控聪明钱交易者的风险指标，及时预警
-5. **多维度分析**：增加更多分析维度（如市场类型、时间分布等）
-

frontend/src/components/Layout.tsx

@@ -252,7 +252,7 @@ const Layout: React.FC<LayoutProps> = ({ children }) => {
               <TwitterOutlined />
             </a>
             <a
-              href="https://t.me/+5BwdYvvvuf9iZGZl"
+              href="https://t.me/polyhermes"
               target="_blank"
               rel="noopener noreferrer"
               style={{ color: '#fff', fontSize: '16px', display: 'flex', alignItems: 'center' }}
@@ -376,7 +376,7 @@ const Layout: React.FC<LayoutProps> = ({ children }) => {
               <TwitterOutlined />
             </a>
             <a
-              href="https://t.me/+5BwdYvvvuf9iZGZl"
+              href="https://t.me/polyhermes"
               target="_blank"
               rel="noopener noreferrer"
               style={{ color: '#fff', fontSize: '18px', display: 'flex', alignItems: 'center' }}

frontend/src/locales/zh-CN/common.json

@@ -1026,7 +1026,7 @@
     "remainingQuantity": "剩余",
     "sellStatus": "卖出状态",
     "status": "状态",
-    "statusFilled": "已完成",
+    "statusFilled": "未成交",
     "statusPartiallySold": "部分成交",
     "statusFullySold": "全部成交",
     "realizedPnl": "已实现盈亏",

frontend/src/pages/CopyTradingOrders/BuyOrdersTab.tsx

@@ -8,11 +8,14 @@ import type { BuyOrderInfo, OrderTrackingRequest, OrderTrackingListResponse } fr
 
 const { Option } = Select
 
+import { ReloadOutlined } from '@ant-design/icons'
+
 interface BuyOrdersTabProps {
   copyTradingId: string
+  active?: boolean
 }
 
-const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
+const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId, active = false }) => {
   const { t } = useTranslation()
   const isMobile = useMediaQuery({ maxWidth: 768 })
   const [loading, setLoading] = useState(false)
@@ -25,16 +28,16 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
     side?: string
     status?: string
   }>({})
-  
+
   useEffect(() => {
-    if (copyTradingId) {
+    if (copyTradingId && active) {
       fetchOrders()
     }
-  }, [copyTradingId, page, limit, filters])
-  
+  }, [copyTradingId, active, page, limit, filters])
+
   const fetchOrders = async () => {
     if (!copyTradingId) return
-    
+
     setLoading(true)
     try {
       const request: OrderTrackingRequest = {
@@ -44,7 +47,7 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
         limit,
         ...filters
       }
-      
+
       const response = await apiService.orderTracking.list(request)
       if (response.data.code === 0 && response.data.data) {
         const data = response.data.data as OrderTrackingListResponse
@@ -57,17 +60,17 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
       setLoading(false)
     }
   }
-  
+
   const getStatusTag = (status: string) => {
     const statusMap: Record<string, { color: string; text: string }> = {
-      filled: { color: 'processing', text: t('copyTradingOrders.statusFilled') || '已完成' },
+      filled: { color: 'processing', text: t('copyTradingOrders.statusFilled') || '未成交' },
       partially_matched: { color: 'warning', text: t('copyTradingOrders.statusPartiallySold') || '部分成交' },
       fully_matched: { color: 'success', text: t('copyTradingOrders.statusFullySold') || '全部成交' }
     }
     const config = statusMap[status] || { color: 'default', text: status }
     return <Tag color={config.color}>{config.text}</Tag>
   }
-  
+
   const columns = [
     {
       title: t('copyTradingOrders.orderId') || '订单ID',
@@ -76,7 +79,7 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
       width: isMobile ? 100 : 150,
       render: (text: string) => (
         <span style={{ fontFamily: 'monospace', fontSize: isMobile ? 11 : 12 }}>
-          {isMobile 
+          {isMobile
             ? `${text.slice(0, 6)}...${text.slice(-4)}`
             : `${text.slice(0, 8)}...${text.slice(-6)}`
           }
@@ -90,7 +93,7 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
       width: isMobile ? 100 : 150,
       render: (text: string) => (
         <span style={{ fontFamily: 'monospace', fontSize: isMobile ? 11 : 12 }}>
-          {isMobile 
+          {isMobile
             ? `${text.slice(0, 6)}...${text.slice(-4)}`
             : `${text.slice(0, 8)}...${text.slice(-6)}`
           }
@@ -104,7 +107,7 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
       width: isMobile ? 100 : 150,
       render: (text: string) => (
         <span style={{ fontFamily: 'monospace', fontSize: isMobile ? 11 : 12 }}>
-          {isMobile 
+          {isMobile
             ? `${text.slice(0, 6)}...${text.slice(-4)}`
             : `${text.slice(0, 8)}...${text.slice(-6)}`
           }
@@ -184,7 +187,7 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
       width: isMobile ? 120 : 160,
       render: (timestamp: number) => (
         <span style={{ fontSize: isMobile ? 11 : 12 }}>
-          {isMobile 
+          {isMobile
             ? new Date(timestamp).toLocaleDateString('zh-CN')
             : new Date(timestamp).toLocaleString('zh-CN')
           }
@@ -192,7 +195,7 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
       )
     }
   ]
-  
+
   return (
     <div>
       <div style={{ marginBottom: 16, display: 'flex', gap: 16, flexWrap: 'wrap' }}>
@@ -203,7 +206,7 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
           value={filters.marketId}
           onChange={(e) => setFilters({ ...filters, marketId: e.target.value || undefined })}
         />
-        
+
         <Select
           placeholder={t('copyTradingOrders.filterSide') || '筛选方向'}
           allowClear
@@ -213,10 +216,8 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
         >
           <Option value="0">YES</Option>
           <Option value="1">NO</Option>
-          <Option value="YES">YES</Option>
-          <Option value="NO">NO</Option>
         </Select>
-        
+
         <Select
           placeholder={t('copyTradingOrders.filterStatus') || '筛选状态'}
           allowClear
@@ -224,14 +225,14 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
           value={filters.status}
           onChange={(value) => setFilters({ ...filters, status: value || undefined })}
         >
-          <Option value="filled">{t('copyTradingOrders.statusFilled') || '已完成'}</Option>
+          <Option value="filled">{t('copyTradingOrders.statusFilled') || '未成交'}</Option>
           <Option value="partially_matched">{t('copyTradingOrders.statusPartiallySold') || '部分成交'}</Option>
           <Option value="fully_matched">{t('copyTradingOrders.statusFullySold') || '全部成交'}</Option>
         </Select>
-        
-        <Button onClick={fetchOrders}>{t('common.search') || '查询'}</Button>
+
+        <Button type="primary" onClick={fetchOrders} icon={<ReloadOutlined />}>{t('common.refresh') || '刷新'}</Button>
       </div>
-      
+
       {isMobile ? (
         <div>
           {loading ? (
@@ -255,7 +256,7 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
                 })
                 const amount = (parseFloat(order.quantity) * parseFloat(order.price)).toString()
                 const displaySide = order.side === '0' ? 'YES' : order.side === '1' ? 'NO' : order.side
-                
+
                 return (
                   <Card
                     key={order.orderId}
@@ -267,9 +268,9 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
                     bodyStyle={{ padding: '16px' }}
                   >
                     <div style={{ marginBottom: '12px' }}>
-                      <div style={{ 
-                        fontSize: '14px', 
-                        fontWeight: 'bold', 
+                      <div style={{
+                        fontSize: '14px',
+                        fontWeight: 'bold',
                         marginBottom: '8px',
                         fontFamily: 'monospace'
                       }}>
@@ -280,9 +281,9 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
                         {getStatusTag(order.status)}
                       </div>
                     </div>
-                    
+
                     <Divider style={{ margin: '12px 0' }} />
-                    
+
                     <div style={{ marginBottom: '12px' }}>
                       <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('copyTradingOrders.buyInfo') || '买入信息'}</div>
                       <div style={{ fontSize: '14px', fontWeight: '500' }}>
@@ -292,28 +293,28 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId }) => {
                         {t('copyTradingOrders.amount') || '金额'}: {formatUSDC(amount)} USDC
                       </div>
                     </div>
-                    
+
                     <div style={{ marginBottom: '12px' }}>
                       <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('copyTradingOrders.matchInfo') || '匹配信息'}</div>
                       <div style={{ fontSize: '13px', color: '#333' }}>
                         {t('copyTradingOrders.matched') || '已匹配'}: {formatUSDC(order.matchedQuantity)} | {t('copyTradingOrders.remaining') || '剩余'}: {formatUSDC(order.remainingQuantity)}
                       </div>
                     </div>
-                    
+
                     <div style={{ marginBottom: '12px' }}>
                       <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('copyTradingOrders.leaderTradeId') || 'Leader 交易ID'}</div>
                       <div style={{ fontSize: '12px', color: '#999', fontFamily: 'monospace' }}>
                         {order.leaderTradeId.slice(0, 8)}...{order.leaderTradeId.slice(-6)}
                       </div>
                     </div>
-                    
+
                     <div style={{ marginBottom: '16px' }}>
                       <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('copyTradingOrders.marketId') || '市场ID'}</div>
                       <div style={{ fontSize: '12px', color: '#999', fontFamily: 'monospace' }}>
                         {order.marketId.slice(0, 8)}...{order.marketId.slice(-6)}
                       </div>
                     </div>
-                    
+
                     <div style={{ marginBottom: '16px' }}>
                       <div style={{ fontSize: '12px', color: '#999' }}>
                         {t('copyTradingOrders.createdAt') || '创建时间'}: {formattedDate}

frontend/src/pages/CopyTradingOrders/MatchedOrdersTab.tsx

@@ -6,11 +6,14 @@ import { useMediaQuery } from 'react-responsive'
 import { useTranslation } from 'react-i18next'
 import type { MatchedOrderInfo, OrderTrackingRequest, OrderTrackingListResponse } from '../../types'
 
+import { ReloadOutlined } from '@ant-design/icons'
+
 interface MatchedOrdersTabProps {
   copyTradingId: string
+  active?: boolean
 }
 
-const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) => {
+const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId, active = false }) => {
   const { t } = useTranslation()
   const isMobile = useMediaQuery({ maxWidth: 768 })
   const [loading, setLoading] = useState(false)
@@ -22,16 +25,16 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) =>
     sellOrderId?: string
     buyOrderId?: string
   }>({})
-  
+
   useEffect(() => {
-    if (copyTradingId) {
+    if (copyTradingId && active) {
       fetchOrders()
     }
-  }, [copyTradingId, page, limit, filters])
-  
+  }, [copyTradingId, active, page, limit, filters])
+
   const fetchOrders = async () => {
     if (!copyTradingId) return
-    
+
     setLoading(true)
     try {
       const request: OrderTrackingRequest = {
@@ -41,7 +44,7 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) =>
         limit,
         ...filters
       }
-      
+
       const response = await apiService.orderTracking.list(request)
       if (response.data.code === 0 && response.data.data) {
         const data = response.data.data as OrderTrackingListResponse
@@ -54,13 +57,13 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) =>
       setLoading(false)
     }
   }
-  
+
   const getPnlColor = (value: string): string => {
     const num = parseFloat(value)
     if (isNaN(num)) return '#666'
     return num >= 0 ? '#3f8600' : '#cf1322'
   }
-  
+
   const columns = [
     {
       title: t('copyTradingOrders.sellOrderId') || '卖出订单ID',
@@ -69,7 +72,7 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) =>
       width: isMobile ? 100 : 150,
       render: (text: string) => (
         <span style={{ fontFamily: 'monospace', fontSize: isMobile ? 11 : 12 }}>
-          {isMobile 
+          {isMobile
             ? `${text.slice(0, 6)}...${text.slice(-4)}`
             : `${text.slice(0, 8)}...${text.slice(-6)}`
           }
@@ -83,7 +86,7 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) =>
       width: isMobile ? 100 : 150,
       render: (text: string) => (
         <span style={{ fontFamily: 'monospace', fontSize: isMobile ? 11 : 12 }}>
-          {isMobile 
+          {isMobile
             ? `${text.slice(0, 6)}...${text.slice(-4)}`
             : `${text.slice(0, 8)}...${text.slice(-6)}`
           }
@@ -123,8 +126,8 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) =>
       key: 'realizedPnl',
       width: isMobile ? 100 : 120,
       render: (value: string) => (
-        <span style={{ 
-          color: getPnlColor(value), 
+        <span style={{
+          color: getPnlColor(value),
           fontWeight: 500,
           fontSize: isMobile ? 12 : 14
         }}>
@@ -139,7 +142,7 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) =>
       width: isMobile ? 120 : 160,
       render: (timestamp: number) => (
         <span style={{ fontSize: isMobile ? 11 : 12 }}>
-          {isMobile 
+          {isMobile
             ? new Date(timestamp).toLocaleDateString('zh-CN')
             : new Date(timestamp).toLocaleString('zh-CN')
           }
@@ -147,7 +150,7 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) =>
       )
     }
   ]
-  
+
   return (
     <div>
       <div style={{ marginBottom: 16, display: 'flex', gap: 16, flexWrap: 'wrap' }}>
@@ -158,7 +161,7 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) =>
           value={filters.sellOrderId}
           onChange={(e) => setFilters({ ...filters, sellOrderId: e.target.value || undefined })}
         />
-        
+
         <Input
           placeholder={t('copyTradingOrders.filterBuyOrderId') || '筛选买入订单ID'}
           allowClear
@@ -166,10 +169,10 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) =>
           value={filters.buyOrderId}
           onChange={(e) => setFilters({ ...filters, buyOrderId: e.target.value || undefined })}
         />
-        
-        <Button onClick={fetchOrders}>{t('common.search') || '查询'}</Button>
+
+        <Button type="primary" onClick={fetchOrders} icon={<ReloadOutlined />}>{t('common.search') || '查询'}</Button>
       </div>
-      
+
       {isMobile ? (
         <div>
           {loading ? (
@@ -191,7 +194,7 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) =>
                   hour: '2-digit',
                   minute: '2-digit'
                 })
-                
+
                 return (
                   <Card
                     key={`${order.sellOrderId}-${order.buyOrderId}-${order.matchedAt}`}
@@ -204,8 +207,8 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) =>
                   >
                     <div style={{ marginBottom: '12px' }}>
                       <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('copyTradingOrders.sellOrderId') || '卖出订单ID'}</div>
-                      <div style={{ 
-                        fontSize: '13px', 
+                      <div style={{
+                        fontSize: '13px',
                         fontWeight: '500',
                         fontFamily: 'monospace',
                         marginBottom: '8px'
@@ -213,42 +216,42 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId }) =>
                         {order.sellOrderId.slice(0, 8)}...{order.sellOrderId.slice(-6)}
                       </div>
                       <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('copyTradingOrders.buyOrderId') || '买入订单ID'}</div>
-                      <div style={{ 
-                        fontSize: '13px', 
+                      <div style={{
+                        fontSize: '13px',
                         fontWeight: '500',
                         fontFamily: 'monospace'
                       }}>
                         {order.buyOrderId.slice(0, 8)}...{order.buyOrderId.slice(-6)}
                       </div>
                     </div>
-                    
+
                     <Divider style={{ margin: '12px 0' }} />
-                    
+
                     <div style={{ marginBottom: '12px' }}>
                       <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('copyTradingOrders.matchedQuantity') || '匹配数量'}</div>
                       <div style={{ fontSize: '14px', fontWeight: '500' }}>
                         {formatUSDC(order.matchedQuantity)}
                       </div>
                     </div>
-                    
+
                     <div style={{ marginBottom: '12px' }}>
                       <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('copyTradingOrders.priceInfo') || '价格信息'}</div>
                       <div style={{ fontSize: '13px', color: '#333' }}>
                         {t('copyTradingOrders.buy') || '买入'}: {formatUSDC(order.buyPrice)} | {t('copyTradingOrders.sell') || '卖出'}: {formatUSDC(order.sellPrice)}
                       </div>
                     </div>
-                    
+
                     <div style={{ marginBottom: '16px' }}>
                       <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('copyTradingOrders.realizedPnl') || '盈亏'}</div>
-                      <div style={{ 
-                        fontSize: '16px', 
+                      <div style={{
+                        fontSize: '16px',
                         fontWeight: 'bold',
                         color: getPnlColor(order.realizedPnl)
                       }}>
                         {formatUSDC(order.realizedPnl)} USDC
                       </div>
                     </div>
-                    
+
                     <div style={{ marginBottom: '16px' }}>
                       <div style={{ fontSize: '12px', color: '#999' }}>
                         {t('copyTradingOrders.matchedAt') || '匹配时间'}: {formattedDate}

frontend/src/pages/CopyTradingOrders/SellOrdersTab.tsx

@@ -8,11 +8,14 @@ import type { SellOrderInfo, OrderTrackingRequest, OrderTrackingListResponse } f
 
 const { Option } = Select
 
+import { ReloadOutlined } from '@ant-design/icons'
+
 interface SellOrdersTabProps {
   copyTradingId: string
+  active?: boolean
 }
 
-const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
+const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId, active = false }) => {
   const { t } = useTranslation()
   const isMobile = useMediaQuery({ maxWidth: 768 })
   const [loading, setLoading] = useState(false)
@@ -24,16 +27,16 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
     marketId?: string
     side?: string
   }>({})
-  
+
   useEffect(() => {
-    if (copyTradingId) {
+    if (copyTradingId && active) {
       fetchOrders()
     }
-  }, [copyTradingId, page, limit, filters])
-  
+  }, [copyTradingId, active, page, limit, filters])
+
   const fetchOrders = async () => {
     if (!copyTradingId) return
-    
+
     setLoading(true)
     try {
       const request: OrderTrackingRequest = {
@@ -43,7 +46,7 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
         limit,
         ...filters
       }
-      
+
       const response = await apiService.orderTracking.list(request)
       if (response.data.code === 0 && response.data.data) {
         const data = response.data.data as OrderTrackingListResponse
@@ -56,13 +59,13 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
       setLoading(false)
     }
   }
-  
+
   const getPnlColor = (value: string): string => {
     const num = parseFloat(value)
     if (isNaN(num)) return '#666'
     return num >= 0 ? '#3f8600' : '#cf1322'
   }
-  
+
   const columns = [
     {
       title: t('copyTradingOrders.orderId') || '订单ID',
@@ -71,7 +74,7 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
       width: isMobile ? 100 : 150,
       render: (text: string) => (
         <span style={{ fontFamily: 'monospace', fontSize: isMobile ? 11 : 12 }}>
-          {isMobile 
+          {isMobile
             ? `${text.slice(0, 6)}...${text.slice(-4)}`
             : `${text.slice(0, 8)}...${text.slice(-6)}`
           }
@@ -85,7 +88,7 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
       width: isMobile ? 100 : 150,
       render: (text: string) => (
         <span style={{ fontFamily: 'monospace', fontSize: isMobile ? 11 : 12 }}>
-          {isMobile 
+          {isMobile
             ? `${text.slice(0, 6)}...${text.slice(-4)}`
             : `${text.slice(0, 8)}...${text.slice(-6)}`
           }
@@ -99,7 +102,7 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
       width: isMobile ? 100 : 150,
       render: (text: string) => (
         <span style={{ fontFamily: 'monospace', fontSize: isMobile ? 11 : 12 }}>
-          {isMobile 
+          {isMobile
             ? `${text.slice(0, 6)}...${text.slice(-4)}`
             : `${text.slice(0, 8)}...${text.slice(-6)}`
           }
@@ -153,8 +156,8 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
       key: 'realizedPnl',
       width: isMobile ? 100 : 120,
       render: (value: string) => (
-        <span style={{ 
-          color: getPnlColor(value), 
+        <span style={{
+          color: getPnlColor(value),
           fontWeight: 500,
           fontSize: isMobile ? 12 : 14
         }}>
@@ -169,7 +172,7 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
       width: isMobile ? 120 : 160,
       render: (timestamp: number) => (
         <span style={{ fontSize: isMobile ? 11 : 12 }}>
-          {isMobile 
+          {isMobile
             ? new Date(timestamp).toLocaleDateString('zh-CN')
             : new Date(timestamp).toLocaleString('zh-CN')
           }
@@ -177,7 +180,7 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
       )
     }
   ]
-  
+
   return (
     <div>
       <div style={{ marginBottom: 16, display: 'flex', gap: 16, flexWrap: 'wrap' }}>
@@ -188,7 +191,7 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
           value={filters.marketId}
           onChange={(e) => setFilters({ ...filters, marketId: e.target.value || undefined })}
         />
-        
+
         <Select
           placeholder={t('copyTradingOrders.filterSide') || '筛选方向'}
           allowClear
@@ -201,10 +204,10 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
           <Option value="YES">YES</Option>
           <Option value="NO">NO</Option>
         </Select>
-        
-        <Button onClick={fetchOrders}>{t('common.search') || '查询'}</Button>
+
+        <Button type="primary" onClick={fetchOrders} icon={<ReloadOutlined />}>{t('common.refresh') || '刷新'}</Button>
       </div>
-      
+
       {isMobile ? (
         <div>
           {loading ? (
@@ -228,7 +231,7 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
                 })
                 const amount = (parseFloat(order.quantity) * parseFloat(order.price)).toString()
                 const displaySide = order.side === '0' ? 'YES' : order.side === '1' ? 'NO' : order.side
-                
+
                 return (
                   <Card
                     key={order.orderId}
@@ -240,9 +243,9 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
                     bodyStyle={{ padding: '16px' }}
                   >
                     <div style={{ marginBottom: '12px' }}>
-                      <div style={{ 
-                        fontSize: '14px', 
-                        fontWeight: 'bold', 
+                      <div style={{
+                        fontSize: '14px',
+                        fontWeight: 'bold',
                         marginBottom: '8px',
                         fontFamily: 'monospace'
                       }}>
@@ -252,9 +255,9 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
                         <Tag>{displaySide}</Tag>
                       </div>
                     </div>
-                    
+
                     <Divider style={{ margin: '12px 0' }} />
-                    
+
                     <div style={{ marginBottom: '12px' }}>
                       <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('copyTradingOrders.sellInfo') || '卖出信息'}</div>
                       <div style={{ fontSize: '14px', fontWeight: '500' }}>
@@ -264,32 +267,32 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId }) => {
                         {t('copyTradingOrders.amount') || '金额'}: {formatUSDC(amount)} USDC
                       </div>
                     </div>
-                    
+
                     <div style={{ marginBottom: '12px' }}>
                       <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('copyTradingOrders.realizedPnl') || '已实现盈亏'}</div>
-                      <div style={{ 
-                        fontSize: '16px', 
+                      <div style={{
+                        fontSize: '16px',
                         fontWeight: 'bold',
                         color: getPnlColor(order.realizedPnl)
                       }}>
                         {formatUSDC(order.realizedPnl)} USDC
                       </div>
                     </div>
-                    
+
                     <div style={{ marginBottom: '12px' }}>
                       <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('copyTradingOrders.leaderTradeId') || 'Leader 交易ID'}</div>
                       <div style={{ fontSize: '12px', color: '#999', fontFamily: 'monospace' }}>
                         {order.leaderTradeId.slice(0, 8)}...{order.leaderTradeId.slice(-6)}
                       </div>
                     </div>
-                    
+
                     <div style={{ marginBottom: '16px' }}>
                       <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('copyTradingOrders.marketId') || '市场ID'}</div>
                       <div style={{ fontSize: '12px', color: '#999', fontFamily: 'monospace' }}>
                         {order.marketId.slice(0, 8)}...{order.marketId.slice(-6)}
                       </div>
                     </div>
-                    
+
                     <div style={{ marginBottom: '16px' }}>
                       <div style={{ fontSize: '12px', color: '#999' }}>
                         {t('copyTradingOrders.createdAt') || '创建时间'}: {formattedDate}

frontend/src/pages/CopyTradingOrders/index.tsx

@@ -22,13 +22,13 @@ const CopyTradingOrdersModal: React.FC<CopyTradingOrdersModalProps> = ({
 }) => {
   const { t } = useTranslation()
   const [activeTab, setActiveTab] = useState<TabType>(defaultTab)
-  
+
   useEffect(() => {
     if (open) {
       setActiveTab(defaultTab)
     }
   }, [open, defaultTab])
-  
+
   return (
     <Modal
       title={t('copyTradingOrders.title') || '订单列表'}
@@ -38,25 +38,26 @@ const CopyTradingOrdersModal: React.FC<CopyTradingOrdersModalProps> = ({
       width="90%"
       style={{ top: 20 }}
       bodyStyle={{ padding: '24px', maxHeight: 'calc(100vh - 100px)', overflow: 'auto' }}
+      destroyOnClose
     >
-      <Tabs 
-        activeKey={activeTab} 
+      <Tabs
+        activeKey={activeTab}
         onChange={(key) => setActiveTab(key as TabType)}
         items={[
           {
             key: 'buy',
             label: t('copyTradingOrders.buyOrders') || '买入订单',
-            children: <BuyOrdersTab copyTradingId={copyTradingId} />
+            children: <BuyOrdersTab copyTradingId={copyTradingId} active={activeTab === 'buy'} />
           },
           {
             key: 'sell',
             label: t('copyTradingOrders.sellOrders') || '卖出订单',
-            children: <SellOrdersTab copyTradingId={copyTradingId} />
+            children: <SellOrdersTab copyTradingId={copyTradingId} active={activeTab === 'sell'} />
           },
           {
             key: 'matched',
             label: t('copyTradingOrders.matchedOrders') || '匹配关系',
-            children: <MatchedOrdersTab copyTradingId={copyTradingId} />
+            children: <MatchedOrdersTab copyTradingId={copyTradingId} active={activeTab === 'matched'} />
           }
         ]}
       />