feat: 优化 Telegram 通知功能

- 简化消息内容，仅保留标题、版本号等关键信息
- Docker 构建前发送构建中通知
- Docker 构建成功后添加部署文档链接
- PR 合并消息标题改为 'main 分支代码更新'

.github/workflows/docker-build.yml

@@ -36,6 +36,49 @@ jobs:
           echo "Extracted version: $VERSION"
           echo "Full tag: $TAG_NAME"
       
+      - name: Send Telegram notification (build started)
+        env:
+          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
+          TELEGRAM_CHAT_ID: ${{ secrets.TELEGRAM_CHAT_ID }}
+        run: |
+          # 检查必要的环境变量
+          if [ -z "$TELEGRAM_BOT_TOKEN" ] || [ -z "$TELEGRAM_CHAT_ID" ]; then
+            echo "⚠️  Telegram Bot Token 或 Chat ID 未配置，跳过通知"
+            exit 0
+          fi
+          
+          # 获取构建信息
+          VERSION="${{ steps.extract_version.outputs.VERSION }}"
+          TAG="${{ steps.extract_version.outputs.TAG }}"
+          RELEASE_URL="${{ github.event.release.html_url }}"
+          
+          # 构建消息内容（仅包含关键信息）
+          MESSAGE="🔨 <b>Docker 镜像构建中</b>"$'\n'$'\n'"📦 <b>版本:</b> ${VERSION}"$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔗 <a href=\"${RELEASE_URL}\">查看 Release</a>"
+          
+          # 发送 Telegram 消息（使用 jq 转义 JSON）
+          curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
+            -H "Content-Type: application/json" \
+            -d "$(jq -n \
+              --arg chat_id "$TELEGRAM_CHAT_ID" \
+              --arg text "$MESSAGE" \
+              '{chat_id: $chat_id, text: $text, parse_mode: "HTML", disable_web_page_preview: false}')" > /tmp/telegram_response.json
+          
+          # 检查发送结果
+          if [ $? -eq 0 ]; then
+            RESPONSE=$(cat /tmp/telegram_response.json)
+            if echo "$RESPONSE" | grep -q '"ok":true'; then
+              echo "✅ Telegram 通知发送成功"
+            else
+              echo "❌ Telegram 通知发送失败: $RESPONSE"
+              # 通知失败不应该导致整个 job 失败
+              exit 0
+            fi
+          else
+            echo "❌ 发送 Telegram 消息时发生错误"
+            # 通知失败不应该导致整个 job 失败
+            exit 0
+          fi
+      
       - name: Set up Docker Buildx
         uses: docker/setup-buildx-action@v3
         with:
@@ -65,3 +108,49 @@ jobs:
             GITHUB_REPO_URL=https://github.com/WrBug/PolyHermes
           cache-from: type=registry,ref=wrbug/polyhermes:latest
           cache-to: type=inline
+
+      - name: Send Telegram notification
+        env:
+          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
+          TELEGRAM_CHAT_ID: ${{ secrets.TELEGRAM_CHAT_ID }}
+        run: |
+          # 检查必要的环境变量
+          if [ -z "$TELEGRAM_BOT_TOKEN" ] || [ -z "$TELEGRAM_CHAT_ID" ]; then
+            echo "⚠️  Telegram Bot Token 或 Chat ID 未配置，跳过通知"
+            exit 0
+          fi
+          
+          # 获取构建信息
+          VERSION="${{ steps.extract_version.outputs.VERSION }}"
+          TAG="${{ steps.extract_version.outputs.TAG }}"
+          RELEASE_NAME="${{ github.event.release.name }}"
+          RELEASE_URL="${{ github.event.release.html_url }}"
+          REPO_NAME="${{ github.repository }}"
+          
+          # 构建消息内容（仅包含关键信息）
+          DEPLOY_DOC_URL="https://github.com/WrBug/PolyHermes/blob/main/docs/zh/DEPLOYMENT.md"
+          MESSAGE="✅ <b>Docker 镜像构建成功</b>"$'\n'$'\n'"📦 <b>版本:</b> ${VERSION}"$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔗 <a href=\"${RELEASE_URL}\">查看 Release</a>"$'\n'"📚 <a href=\"${DEPLOY_DOC_URL}\">Docker 部署文档</a>"
+          
+          # 发送 Telegram 消息（使用 jq 转义 JSON）
+          curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
+            -H "Content-Type: application/json" \
+            -d "$(jq -n \
+              --arg chat_id "$TELEGRAM_CHAT_ID" \
+              --arg text "$MESSAGE" \
+              '{chat_id: $chat_id, text: $text, parse_mode: "HTML", disable_web_page_preview: false}')" > /tmp/telegram_response.json
+          
+          # 检查发送结果
+          if [ $? -eq 0 ]; then
+            RESPONSE=$(cat /tmp/telegram_response.json)
+            if echo "$RESPONSE" | grep -q '"ok":true'; then
+              echo "✅ Telegram 通知发送成功"
+            else
+              echo "❌ Telegram 通知发送失败: $RESPONSE"
+              # 构建成功，通知失败不应该导致整个 job 失败
+              exit 0
+            fi
+          else
+            echo "❌ 发送 Telegram 消息时发生错误"
+            # 构建成功，通知失败不应该导致整个 job 失败
+            exit 0
+          fi

.github/workflows/telegram-notify.yml

@@ -0,0 +1,103 @@
+name: Telegram Notification on PR Merge
+
+on:
+  pull_request:
+    types:
+      - closed  # 当 PR 被关闭（合并或关闭）时触发
+
+jobs:
+  notify:
+    runs-on: ubuntu-latest
+    
+    # 只在 PR 被合并到 main 分支时执行
+    if: github.event.pull_request.merged == true && github.event.pull_request.base.ref == 'main'
+    
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+      
+      - name: Get PR details
+        id: pr_details
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          PR_NUMBER="${{ github.event.pull_request.number }}"
+          REPO="${{ github.repository }}"
+          
+          # 获取 PR 详细信息
+          PR_RESPONSE=$(curl -s -H "Authorization: token ${GITHUB_TOKEN}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            "https://api.github.com/repos/${REPO}/pulls/${PR_NUMBER}")
+          
+          # 获取 PR 变更的文件列表
+          FILES_RESPONSE=$(curl -s -H "Authorization: token ${GITHUB_TOKEN}" \
+            -H "Accept: application/vnd.github.v3+json" \
+            "https://api.github.com/repos/${REPO}/pulls/${PR_NUMBER}/files")
+          
+          # 提取 PR 描述（body），保留换行，限制长度
+          PR_BODY=$(echo "$PR_RESPONSE" | jq -r '.body // ""')
+          if [ ${#PR_BODY} -gt 500 ]; then
+            PR_BODY="${PR_BODY:0:500}..."
+          fi
+          
+          # 保存到输出变量（使用 base64 编码避免特殊字符问题）
+          echo "pr_body<<EOF" >> $GITHUB_OUTPUT
+          echo "$PR_BODY" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+      
+      - name: Send Telegram notification
+        env:
+          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
+          TELEGRAM_CHAT_ID: ${{ secrets.TELEGRAM_CHAT_ID }}
+        run: |
+          # 检查 PR 是否被合并（而不是仅关闭）
+          PR_MERGED="${{ github.event.pull_request.merged }}"
+          if [ "$PR_MERGED" != "true" ]; then
+            echo "ℹ️  PR 仅关闭，未合并，跳过通知"
+            exit 0
+          fi
+          
+          # 检查必要的环境变量
+          # 注意：TELEGRAM_CHAT_ID 可以是个人聊天 ID（正数）或群组 ID（负数，如 -1001234567890）
+          if [ -z "$TELEGRAM_BOT_TOKEN" ] || [ -z "$TELEGRAM_CHAT_ID" ]; then
+            echo "⚠️  Telegram Bot Token 或 Chat ID 未配置，跳过通知"
+            exit 0
+          fi
+          
+          # 获取 PR 基本信息
+          PR_NUMBER="${{ github.event.pull_request.number }}"
+          PR_TITLE="${{ github.event.pull_request.title }}"
+          PR_URL="${{ github.event.pull_request.html_url }}"
+          PR_MERGE_COMMIT="${{ github.event.pull_request.merge_commit_sha }}"
+          
+          # 获取 PR 详细信息
+          PR_BODY="${{ steps.pr_details.outputs.pr_body }}"
+          
+          # 转义 PR 标题中的 HTML 特殊字符
+          PR_TITLE_ESCAPED=$(echo "$PR_TITLE" | sed 's/&/\&amp;/g' | sed 's/</\&lt;/g' | sed 's/>/\&gt;/g')
+          
+          # 构建消息内容（仅包含关键信息）
+          MESSAGE="🚀 <b>main 分支代码更新</b>"$'\n'$'\n'"📝 <b>PR #${PR_NUMBER}:</b> ${PR_TITLE_ESCAPED}"$'\n'"🔗 <a href=\"${PR_URL}\">查看 PR</a>"
+          
+          # 发送 Telegram 消息（使用 jq 转义 JSON）
+          curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
+            -H "Content-Type: application/json" \
+            -d "$(jq -n \
+              --arg chat_id "$TELEGRAM_CHAT_ID" \
+              --arg text "$MESSAGE" \
+              '{chat_id: $chat_id, text: $text, parse_mode: "HTML", disable_web_page_preview: false}')" > /tmp/telegram_response.json
+          
+          # 检查发送结果
+          if [ $? -eq 0 ]; then
+            RESPONSE=$(cat /tmp/telegram_response.json)
+            if echo "$RESPONSE" | grep -q '"ok":true'; then
+              echo "✅ Telegram 通知发送成功"
+            else
+              echo "❌ Telegram 通知发送失败: $RESPONSE"
+              exit 1
+            fi
+          else
+            echo "❌ 发送 Telegram 消息时发生错误"
+            exit 1
+          fi
+

RELEASE.md

@@ -1,3 +1,115 @@
+# v1.1.2
+
+## 🚀 主要功能
+
+### 🐛 修复内存泄漏问题
+- 修复 Retrofit/OkHttpClient 实例重复创建导致的内存泄漏问题
+- 为不需要认证的 API 创建共享的 OkHttpClient 实例（Gamma API、Data API、GitHub API 等）
+- 带认证的 CLOB API 按钱包地址缓存（每个账户一个客户端）
+- RPC API 按 RPC URL 缓存，Builder Relayer API 按 relayerUrl 缓存
+- 添加 `@PreDestroy` 方法清理缓存，确保资源正确释放
+- **效果**：内存占用从运行几小时后从 400MB 涨到 1GB+ 变为保持稳定，大幅减少内存占用
+
+### 📊 市场价格服务优化
+- 移除降级查询逻辑，仅保留链上 RPC 查询和 CLOB 订单簿查询
+- 移除 CLOB Trades、Gamma Market Status、Gamma Market Price 查询逻辑
+- 如果所有数据源都失败，抛出明确的异常信息
+- 价格截位到 4 位小数（向下截断，不四舍五入）
+- 简化代码逻辑，提高查询效率和准确性
+
+### 🔧 代码架构优化
+- 统一 Gson 使用，改为依赖注入方式
+- 在 `GsonConfig` 中统一配置 Gson Bean（lenient 模式）
+- 所有 Service 类通过构造函数注入 Gson 实例
+- 移除所有 `GsonConverterFactory.create()` 无参调用，统一使用注入的 Gson
+- 提高代码一致性和可维护性
+
+### 🗑️ 功能清理
+- 移除下单失败存储数据库的功能
+- 删除 `FailedTrade` 实体类和 `FailedTradeRepository`
+- 从 `CopyOrderTrackingService` 中移除失败交易存储逻辑
+- 创建 Flyway migration V16 删除 `failed_trade` 表
+- 下单失败时仅记录日志，不再存储到数据库，简化数据模型
+
+### 🚀 部署优化
+- 自动使用当前分支名作为 Docker 版本号
+- 分支名中的 `/` 自动替换为 `-`（Docker tag 不支持 `/）
+- `docker-compose.yml` 启用 build args，从环境变量读取版本号
+- 前端页面将显示当前分支名作为版本号
+- 如果没有 Git 仓库或获取失败，使用默认值 `dev`
+
+## 🐛 Bug 修复
+
+### 修复 Flyway Migration 问题
+- 恢复 V1 migration 文件，避免 checksum 不匹配
+- 保持 `V1__init_database.sql` 的原有内容不变
+- `failed_trade` 表的删除通过 V16 migration 处理
+- 确保已有数据库的 migration checksum 保持一致
+
+### 修复前端编译错误
+- 修复 `PositionList.tsx` 中引用不存在的 `bestBid` 属性导致的编译错误
+- 使用 `currentPrice` 替代 `bestBid`，确保前端代码可以正常编译
+
+## 📚 文档更新
+
+- 新增智能资金分析文档（`docs/zh/smart-money-analysis.md`）
+- 详细说明智能资金分析功能的使用方法和策略
+
+## 🔧 技术改进
+
+- 优化 `RetrofitFactory`，实现客户端实例缓存和复用
+- 优化 `CopyOrderTrackingService`，移除失败交易相关逻辑
+- 优化 `OrderStatusUpdateService`，增强订单状态更新功能
+- 优化 `TelegramNotificationService`，改进通知逻辑
+- 优化 `PositionCheckService`，简化代码结构
+- 优化 `PolymarketClobService`，改进 API 调用逻辑
+
+## 📦 数据库变更
+
+- 删除 `failed_trade` 表（Migration: V16）
+
+## 🔗 相关链接
+
+- **GitHub Release**: https://github.com/WrBug/PolyHermes/releases/tag/v1.1.2
+- **完整更新日志**: https://github.com/WrBug/PolyHermes/compare/v1.1.1...v1.1.2
+- **Docker Hub**: https://hub.docker.com/r/wrbug/polyhermes
+
+## 📊 统计信息
+
+- **文件变更**: 29 个文件
+- **代码变更**: +1597 行 / -678 行
+- **主要提交**: 8 个提交
+
+## ⚠️ 重要提醒
+
+**请务必使用官方 Docker 镜像源，避免财产损失！**
+
+### ✅ 官方 Docker Hub 镜像
+
+**官方镜像地址**：`wrbug/polyhermes`
+
+```bash
+# ✅ 正确：使用官方镜像
+docker pull wrbug/polyhermes:v1.1.2
+
+# ❌ 错误：不要使用其他来源的镜像
+# 任何非官方来源的镜像都可能包含恶意代码，导致您的私钥和资产被盗
+```
+
+### 🔗 官方渠道
+
+请通过以下**唯一官方渠道**获取 PolyHermes：
+
+* **GitHub 仓库**：https://github.com/WrBug/PolyHermes
+* **Twitter**：@polyhermes
+* **Telegram 群组**：加入群组
+
+---
+
+**⭐ 如果这个项目对您有帮助，请给个 Star 支持一下！**
+
+---
+
 # v1.1.1
 
 ## 🚀 主要功能

backend/src/main/kotlin/com/wrbug/polymarketbot/config/GsonConfig.kt

@@ -0,0 +1,26 @@
+package com.wrbug.polymarketbot.config
+
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
+import org.springframework.context.annotation.Bean
+import org.springframework.context.annotation.Configuration
+
+/**
+ * Gson 配置类
+ * 统一配置 Gson 实例，使用 lenient 模式允许解析格式不严格的 JSON
+ */
+@Configuration
+class GsonConfig {
+    
+    /**
+     * 创建 Gson Bean
+     * 使用 lenient 模式，允许解析格式不严格的 JSON
+     */
+    @Bean
+    fun gson(): Gson {
+        return GsonBuilder()
+            .setLenient()
+            .create()
+    }
+}
+

backend/src/main/kotlin/com/wrbug/polymarketbot/config/RetrofitConfig.kt

@@ -1,5 +1,6 @@
 package com.wrbug.polymarketbot.config
 
+import com.google.gson.Gson
 import com.wrbug.polymarketbot.api.PolymarketClobApi
 import com.wrbug.polymarketbot.util.createClient
 import org.springframework.beans.factory.annotation.Value
@@ -18,7 +19,9 @@ import retrofit2.converter.gson.GsonConverterFactory
  * - 账户 API Key 在调用时动态设置，不在此处配置
  */
 @Configuration
-class RetrofitConfig {
+class RetrofitConfig(
+    private val gson: Gson
+) {
     
     @Value("\${polymarket.clob.base-url}")
     private lateinit var clobBaseUrl: String
@@ -37,7 +40,7 @@ class RetrofitConfig {
         return Retrofit.Builder()
             .baseUrl(clobBaseUrl)
             .client(okHttpClient)
-            .addConverterFactory(GsonConverterFactory.create())
+            .addConverterFactory(GsonConverterFactory.create(gson))
             .build()
             .create(PolymarketClobApi::class.java)
     }

backend/src/main/kotlin/com/wrbug/polymarketbot/controller/markets/MarketController.kt

@@ -4,8 +4,10 @@ import com.wrbug.polymarketbot.api.LatestPriceResponse
 import com.wrbug.polymarketbot.dto.*
 import com.wrbug.polymarketbot.enums.ErrorCode
 import com.wrbug.polymarketbot.service.accounts.AccountService
+import com.wrbug.polymarketbot.service.common.MarketPriceService
 import com.wrbug.polymarketbot.service.common.PolymarketClobService
 import kotlinx.coroutines.runBlocking
+import java.math.BigDecimal
 import org.slf4j.LoggerFactory
 import org.springframework.context.MessageSource
 import org.springframework.http.ResponseEntity
@@ -20,14 +22,16 @@ import org.springframework.web.bind.annotation.*
 class MarketController(
     private val accountService: AccountService,
     private val clobService: PolymarketClobService,
+    private val marketPriceService: MarketPriceService,
     private val messageSource: MessageSource
 ) {
     
     private val logger = LoggerFactory.getLogger(MarketController::class.java)
     
     /**
-     * 获取市场价格（通过 Gamma API）
-     * 使用 Gamma API 获取价格信息，因为 Gamma API 支持 condition_ids 参数
+     * 获取市场价格
+     * 使用 MarketPriceService 获取当前市场价格（支持多数据源降级）
+     * 返回当前价格，前端接收后自行填充到 bestBid 字段
      */
     @PostMapping("/price")
     fun getMarketPrice(@RequestBody request: MarketPriceRequest): ResponseEntity<ApiResponse<MarketPriceResponse>> {
@@ -36,16 +40,16 @@ class MarketController(
                 return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_MARKET_ID_EMPTY, messageSource = messageSource))
             }
             
-            val result = runBlocking { accountService.getMarketPrice(request.marketId, request.outcomeIndex) }
-            result.fold(
-                onSuccess = { response ->
-                    ResponseEntity.ok(ApiResponse.success(response))
-                },
-                onFailure = { e ->
-                    logger.error("获取市场价格失败: ${e.message}", e)
-                    ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_MARKET_PRICE_FETCH_FAILED, e.message, messageSource))
-                }
+            val outcomeIndex = request.outcomeIndex ?: 0
+            val price = runBlocking { 
+                marketPriceService.getCurrentMarketPrice(request.marketId, outcomeIndex) 
+            }
+            
+            val response = MarketPriceResponse(
+                marketId = request.marketId,
+                currentPrice = price.toString()
             )
+            ResponseEntity.ok(ApiResponse.success(response))
         } catch (e: Exception) {
             logger.error("获取市场价格异常: ${e.message}", e)
             ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_MARKET_PRICE_FETCH_FAILED, e.message, messageSource))

backend/src/main/kotlin/com/wrbug/polymarketbot/dto/AccountDto.kt

@@ -195,14 +195,11 @@ data class LatestPriceRequest(
 )
 
 /**
- * 市场价格响应
+ * 市场当前价格响应
  */
 data class MarketPriceResponse(
     val marketId: String,
-    val lastPrice: String?,    // 最新成交价
-    val bestBid: String?,      // 最优买价（用于卖出参考）
-    val bestAsk: String?,      // 最优卖价（用于买入参考）
-    val midpoint: String?      // 中间价
+    val currentPrice: String   // 当前价格（通过 MarketPriceService 获取，支持多数据源降级）
 )
 
 /**

backend/src/main/kotlin/com/wrbug/polymarketbot/entity/FailedTrade.kt

@@ -1,55 +0,0 @@
-package com.wrbug.polymarketbot.entity
-
-import jakarta.persistence.*
-
-/**
- * 失败交易实体
- * 记录处理失败的交易信息
- */
-@Entity
-@Table(name = "failed_trade")
-data class FailedTrade(
-    @Id
-    @GeneratedValue(strategy = GenerationType.IDENTITY)
-    val id: Long? = null,
-    
-    @Column(name = "leader_id", nullable = false)
-    val leaderId: Long,
-    
-    @Column(name = "leader_trade_id", nullable = false, length = 100)
-    val leaderTradeId: String,  // Leader 的交易ID
-    
-    @Column(name = "trade_type", nullable = false, length = 10)
-    val tradeType: String,  // BUY 或 SELL
-    
-    @Column(name = "copy_trading_id", nullable = false)
-    val copyTradingId: Long,
-    
-    @Column(name = "account_id", nullable = false)
-    val accountId: Long,
-    
-    @Column(name = "market_id", nullable = false, length = 100)
-    val marketId: String,
-    
-    @Column(name = "side", nullable = false, length = 10)
-    val side: String,  // YES/NO
-    
-    @Column(name = "price", nullable = false, length = 50)
-    val price: String,  // 价格（字符串格式）
-    
-    @Column(name = "size", nullable = false, length = 50)
-    val size: String,  // 数量（字符串格式）
-    
-    @Column(name = "error_message", columnDefinition = "TEXT")
-    val errorMessage: String? = null,  // 错误信息
-    
-    @Column(name = "retry_count", nullable = false)
-    val retryCount: Int = 0,  // 重试次数
-    
-    @Column(name = "failed_at", nullable = false)
-    val failedAt: Long = System.currentTimeMillis(),
-    
-    @Column(name = "created_at", nullable = false)
-    val createdAt: Long = System.currentTimeMillis()
-)
-

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

@@ -55,5 +55,11 @@ interface CopyOrderTrackingRepository : JpaRepository<CopyOrderTracking, Long> {
      * 查询未发送通知的买入订单（用于轮询更新）
      */
     fun findByNotificationSentFalse(): List<CopyOrderTracking>
+    
+    /**
+     * 查询指定时间之前创建的订单（用于检查30秒后未成交的订单）
+     */
+    @Query("SELECT t FROM CopyOrderTracking t WHERE t.createdAt <= :beforeTime")
+    fun findByCreatedAtBefore(beforeTime: Long): List<CopyOrderTracking>
 }
 

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

@@ -1,23 +0,0 @@
-package com.wrbug.polymarketbot.repository
-
-import com.wrbug.polymarketbot.entity.FailedTrade
-import org.springframework.data.jpa.repository.JpaRepository
-import org.springframework.stereotype.Repository
-
-/**
- * 失败交易Repository
- */
-@Repository
-interface FailedTradeRepository : JpaRepository<FailedTrade, Long> {
-    
-    /**
-     * 根据Leader ID和交易ID查询
-     */
-    fun findByLeaderIdAndLeaderTradeId(leaderId: Long, leaderTradeId: String): FailedTrade?
-    
-    /**
-     * 检查是否存在失败的交易
-     */
-    fun existsByLeaderIdAndLeaderTradeId(leaderId: Long, leaderTradeId: String): Boolean
-}
-

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

@@ -37,7 +37,8 @@ class AccountService(
     private val orderSigningService: OrderSigningService,
     private val cryptoUtils: CryptoUtils,
     private val telegramNotificationService: TelegramNotificationService? = null,  // 可选，避免循环依赖
-    private val relayClientService: RelayClientService
+    private val relayClientService: RelayClientService,
+    private val jsonUtils: JsonUtils
 ) {
 
     private val logger = LoggerFactory.getLogger(AccountService::class.java)
@@ -1121,7 +1122,7 @@ class AccountService(
                     // 如果目标 outcome 不是第一个（index != 0），需要转换价格
                     // 对于二元市场：第二个 outcome 的价格 = 1 - 第一个 outcome 的价格
                     if (outcomeIndex != null && outcomeIndex > 0) {
-                        val outcomes = JsonUtils.parseStringArray(market.outcomes)
+                        val outcomes = jsonUtils.parseStringArray(market.outcomes)
                         // 只对二元市场进行价格转换
                         if (outcomes.size == 2) {
                             // 保存原始第一个 outcome 的价格
@@ -1153,13 +1154,13 @@ class AccountService(
                         null
                     }
 
+                    // 优先使用 lastPrice（最近成交价），如果没有则使用 bestBid，最后使用 midpoint
+                    val currentPrice = lastPrice ?: bestBid ?: midpoint ?: "0"
+
                     Result.success(
                         MarketPriceResponse(
                             marketId = marketId,
-                            lastPrice = lastPrice,
-                            bestBid = bestBid,
-                            bestAsk = bestAsk,
-                            midpoint = midpoint
+                            currentPrice = currentPrice
                         )
                     )
                 } else {

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

@@ -21,12 +21,9 @@ import org.springframework.context.i18n.LocaleContextHolder
 import com.wrbug.polymarketbot.service.system.SystemConfigService
 import com.wrbug.polymarketbot.service.system.RelayClientService
 import com.wrbug.polymarketbot.service.system.TelegramNotificationService
-import com.wrbug.polymarketbot.util.RetrofitFactory
-import com.wrbug.polymarketbot.util.JsonUtils
-import com.wrbug.polymarketbot.service.common.BlockchainService
+import com.wrbug.polymarketbot.service.common.MarketPriceService
 import org.springframework.stereotype.Service
 import java.math.BigDecimal
-import java.math.BigInteger
 import java.util.concurrent.ConcurrentHashMap
 
 /**
@@ -47,8 +44,7 @@ class PositionCheckService(
     private val telegramNotificationService: TelegramNotificationService?,
     private val accountRepository: AccountRepository,
     private val messageSource: MessageSource,
-    private val retrofitFactory: RetrofitFactory,
-    private val blockchainService: BlockchainService
+    private val marketPriceService: MarketPriceService
 ) {
     
     private val logger = LoggerFactory.getLogger(PositionCheckService::class.java)
@@ -430,200 +426,10 @@ class PositionCheckService(
     
     /**
      * 获取当前市场最新价（用于更新订单卖出价）
-     * 优先使用链上查询获取市场结算结果，如果未结算则使用 API 查询
-     * 如果市场已关闭：
-     *   - 该 outcome 赢了，返回 1
-     *   - 该 outcome 输了，返回 0
+     * 委托给 MarketPriceService 处理
      */
     private suspend fun getCurrentMarketPrice(marketId: String, outcomeIndex: Int): BigDecimal {
-        return try {
-            // 优先从链上查询市场结算结果（实时性高）
-            val chainResult = blockchainService.getCondition(marketId)
-            chainResult.fold(
-                onSuccess = { (payoutDenominator, payouts) ->
-                    // 如果 payouts 不为空，说明市场已结算
-                    if (payouts.isNotEmpty() && outcomeIndex < payouts.size) {
-                        val payout = payouts[outcomeIndex]
-                        when {
-                            payout > BigInteger.ZERO -> {
-                                // payout > 0 表示赢了
-                                logger.info("从链上查询到市场已结算，该 outcome 赢了: marketId=$marketId, outcomeIndex=$outcomeIndex, payout=$payout")
-                                return BigDecimal.ONE
-                            }
-                            payout == BigInteger.ZERO -> {
-                                // payout == 0 表示输了
-                                logger.info("从链上查询到市场已结算，该 outcome 输了: marketId=$marketId, outcomeIndex=$outcomeIndex, payout=$payout")
-                                return BigDecimal.ZERO
-                            }
-                            else -> {
-                                logger.warn("从链上查询到异常的 payout 值: marketId=$marketId, outcomeIndex=$outcomeIndex, payout=$payout")
-                            }
-                        }
-                    } else {
-                        logger.debug("从链上查询到市场尚未结算: marketId=$marketId, payouts=${payouts.size}")
-                    }
-                },
-                onFailure = { e ->
-                    logger.debug("链上查询市场条件失败，降级到 API 查询: marketId=$marketId, error=${e.message}")
-                }
-            )
-            
-            // 链上查询失败或市场未结算，降级到 API 查询
-            val gammaApi = retrofitFactory.createGammaApi()
-            val marketResponse = gammaApi.listMarkets(conditionIds = listOf(marketId))
-            
-            if (marketResponse.isSuccessful && marketResponse.body() != null) {
-                val markets = marketResponse.body()!!
-                val market = markets.firstOrNull()
-                
-                if (market != null) {
-                    // 检查市场是否已结束：1) closed == true 或 2) endDate 已过
-                    val isMarketEnded = checkIfMarketEnded(market)
-                    
-                    if (isMarketEnded) {
-                        logger.debug("市场已结束: marketId=$marketId, closed=${market.closed}, endDate=${market.endDate}")
-                        // 市场已结束，检查该 outcome 是赢了还是输了
-                    val outcomeResult = checkOutcomeResult(market, outcomeIndex)
-                    when (outcomeResult) {
-                        OutcomeResult.WON -> {
-                                logger.info("市场已结束且该 outcome 赢了，返回价格为 1: marketId=$marketId, outcomeIndex=$outcomeIndex")
-                            return BigDecimal.ONE
-                        }
-                        OutcomeResult.LOST -> {
-                                logger.info("市场已结束且该 outcome 输了，返回价格为 0: marketId=$marketId, outcomeIndex=$outcomeIndex")
-                            return BigDecimal.ZERO
-                        }
-                        OutcomeResult.UNKNOWN -> {
-                                // 无法判断，记录警告并继续使用正常价格逻辑
-                                logger.warn("市场已结束但无法判断 outcome 结果，使用正常价格: marketId=$marketId, outcomeIndex=$outcomeIndex, closed=${market.closed}, endDate=${market.endDate}, outcomePrices=${market.outcomePrices}, bestBid=${market.bestBid}, bestAsk=${market.bestAsk}")
-                            }
-                        }
-                    }
-                }
-            }
-            
-            // 如果市场未关闭或无法判断输赢，获取正常价格
-            val priceResult = accountService.getMarketPrice(marketId, outcomeIndex)
-            val marketPrice = priceResult.getOrNull()
-            if (marketPrice != null) {
-                // 优先使用 bestBid（最优买价，用于卖出参考），如果没有则使用 midpoint
-                val priceStr = marketPrice.bestBid ?: marketPrice.midpoint ?: marketPrice.lastPrice
-                priceStr?.toSafeBigDecimal() ?: BigDecimal.ZERO
-            } else {
-                BigDecimal.ZERO
-            }
-        } catch (e: Exception) {
-            logger.error("获取市场最新价失败: marketId=$marketId, outcomeIndex=$outcomeIndex, error=${e.message}", e)
-            BigDecimal.ZERO
-        }
-    }
-    
-    /**
-     * 检查市场是否已结束
-     * 判断条件：
-     * 1. closed == true
-     * 2. 或 endDate 已过（如果 endDate 不为空）
-     */
-    private fun checkIfMarketEnded(market: com.wrbug.polymarketbot.api.MarketResponse): Boolean {
-        // 1. 检查 closed 字段
-        if (market.closed == true) {
-            return true
-        }
-        
-        // 2. 检查 endDate 是否已过
-        val endDateStr = market.endDate
-        if (endDateStr != null && endDateStr.isNotBlank()) {
-            try {
-                // endDate 可能是 ISO 8601 格式字符串或时间戳
-                val endDate = if (endDateStr.matches(Regex("^\\d+$"))) {
-                    // 时间戳（秒或毫秒）
-                    val timestamp = endDateStr.toLong()
-                    // 判断是秒还是毫秒（如果小于 10^10，认为是秒）
-                    if (timestamp < 10000000000L) {
-                        timestamp * 1000  // 转换为毫秒
-                    } else {
-                        timestamp
-                    }
-                } else {
-                    // ISO 8601 格式，尝试解析
-                    java.time.Instant.parse(endDateStr).toEpochMilli()
-                }
-                
-                val now = System.currentTimeMillis()
-                if (now >= endDate) {
-                    logger.debug("市场 endDate 已过: marketId=${market.conditionId}, endDate=$endDateStr, now=$now")
-                    return true
-                }
-            } catch (e: Exception) {
-                logger.warn("解析 endDate 失败: marketId=${market.conditionId}, endDate=$endDateStr, error=${e.message}")
-            }
-        }
-        
-        return false
-    }
-    
-    /**
-     * Outcome 结果枚举
-     */
-    private enum class OutcomeResult {
-        WON,    // 赢了
-        LOST,   // 输了
-        UNKNOWN // 无法判断
-    }
-    
-    /**
-     * 检查该 outcome 的结果（赢了、输了或无法判断）
-     * @param market 市场信息
-     * @param outcomeIndex outcome 索引
-     * @return OutcomeResult
-     */
-    private fun checkOutcomeResult(market: com.wrbug.polymarketbot.api.MarketResponse, outcomeIndex: Int): OutcomeResult {
-        return try {
-            // 优先使用 outcomePrices（结算价格数组）
-            val outcomePrices = market.outcomePrices
-            if (outcomePrices != null && outcomePrices.isNotBlank()) {
-                val prices = JsonUtils.parseStringArray(outcomePrices)
-                if (outcomeIndex < prices.size) {
-                    val price = prices[outcomeIndex].toSafeBigDecimal()
-                    // 如果价格 >= 0.99，认为赢了
-                    if (price >= BigDecimal("0.99")) {
-                        return OutcomeResult.WON
-                    }
-                    // 如果价格 <= 0.01，认为输了
-                    if (price <= BigDecimal("0.01")) {
-                        return OutcomeResult.LOST
-                    }
-                    // 其他情况，无法判断
-                    return OutcomeResult.UNKNOWN
-                }
-            }
-            
-            // 如果没有 outcomePrices，使用 bestBid 和 bestAsk 判断
-            val bestBid = market.bestBid ?: 0.0
-            val bestAsk = market.bestAsk ?: 0.0
-            
-            // 如果目标 outcome 不是第一个（index != 0），需要转换价格
-            val targetBid = if (outcomeIndex > 0) {
-                // 第二个 outcome 的 bestBid = 1 - 第一个 outcome 的 bestAsk
-                BigDecimal.ONE.subtract(BigDecimal.valueOf(bestAsk))
-            } else {
-                BigDecimal.valueOf(bestBid)
-            }
-            
-            // 如果 bestBid >= 0.99，认为赢了
-            if (targetBid >= BigDecimal("0.99")) {
-                return OutcomeResult.WON
-            }
-            // 如果 bestBid <= 0.01，认为输了
-            if (targetBid <= BigDecimal("0.01")) {
-                return OutcomeResult.LOST
-            }
-            // 其他情况，无法判断
-            OutcomeResult.UNKNOWN
-        } catch (e: Exception) {
-            logger.warn("检查 outcome 结果失败: marketId=${market.conditionId}, outcomeIndex=$outcomeIndex, error=${e.message}", e)
-            OutcomeResult.UNKNOWN
-        }
+        return marketPriceService.getCurrentMarketPrice(marketId, outcomeIndex)
     }
     
     

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

@@ -1,5 +1,6 @@
 package com.wrbug.polymarketbot.service.common
 
+import com.google.gson.Gson
 import com.wrbug.polymarketbot.api.EthereumRpcApi
 import com.wrbug.polymarketbot.api.JsonRpcRequest
 import com.wrbug.polymarketbot.api.JsonRpcResponse
@@ -29,7 +30,8 @@ class BlockchainService(
     private val dataApiBaseUrl: String,
     private val retrofitFactory: RetrofitFactory,
     private val relayClientService: RelayClientService,
-    private val rpcNodeService: RpcNodeService
+    private val rpcNodeService: RpcNodeService,
+    private val gson: Gson
 ) {
     
     private val logger = LoggerFactory.getLogger(BlockchainService::class.java)
@@ -64,7 +66,7 @@ class BlockchainService(
         Retrofit.Builder()
             .baseUrl("$baseUrl/")
             .client(okHttpClient)
-            .addConverterFactory(GsonConverterFactory.create())
+            .addConverterFactory(GsonConverterFactory.create(gson))
             .build()
             .create(PolymarketDataApi::class.java)
     }

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

@@ -0,0 +1,211 @@
+package com.wrbug.polymarketbot.service.common
+
+import com.wrbug.polymarketbot.api.PolymarketClobApi
+import com.wrbug.polymarketbot.repository.AccountRepository
+import com.wrbug.polymarketbot.util.CryptoUtils
+import com.wrbug.polymarketbot.util.RetrofitFactory
+import com.wrbug.polymarketbot.util.toSafeBigDecimal
+import org.slf4j.LoggerFactory
+import org.springframework.stereotype.Service
+import java.math.BigDecimal
+import java.math.BigInteger
+
+/**
+ * 市场价格服务
+ * 统一封装从不同数据源获取市场价格的逻辑
+ * 数据源包括：
+ * 1. 链上 RPC 查询（市场结算结果）
+ * 2. CLOB API（订单簿价格）
+ */
+@Service
+class MarketPriceService(
+    private val blockchainService: BlockchainService,
+    private val retrofitFactory: RetrofitFactory,
+    private val accountRepository: AccountRepository,
+    private val cryptoUtils: CryptoUtils
+) {
+    
+    private val logger = LoggerFactory.getLogger(MarketPriceService::class.java)
+    
+    /**
+     * 获取当前市场最新价
+     * 优先级：
+     * 1. 链上查询市场结算结果（如果已结算，返回 1.0 或 0.0）
+     * 2. CLOB API 查询订单簿价格（最准确，使用 bestBid）
+     * 
+     * 价格会被截位到 4 位小数（向下截断，不四舍五入），用于显示和后续计算
+     * 
+     * @param marketId 市场ID
+     * @param outcomeIndex 结果索引
+     * @return 市场价格（已截位到 4 位小数）
+     * @throws IllegalStateException 如果所有数据源都失败
+     */
+    suspend fun getCurrentMarketPrice(marketId: String, outcomeIndex: Int): BigDecimal {
+        // 1. 优先从链上查询市场结算结果
+        val chainPrice = getPriceFromChainCondition(marketId, outcomeIndex)
+        if (chainPrice != null) {
+            // 截位到 4 位小数（向下截断，不四舍五入）
+            return chainPrice.setScale(4, java.math.RoundingMode.DOWN)
+        }
+        
+        // 2. 从 CLOB API 查询订单簿价格（最准确）
+        val orderbookPrice = getPriceFromClobOrderbook(marketId, outcomeIndex)
+        if (orderbookPrice != null) {
+            // 截位到 4 位小数（向下截断，不四舍五入）
+            return orderbookPrice.setScale(4, java.math.RoundingMode.DOWN)
+        }
+        
+        // 如果所有数据源都失败，抛出异常
+        val errorMsg = "无法获取市场价格: marketId=$marketId, outcomeIndex=$outcomeIndex (链上查询和订单簿查询均失败)"
+        logger.error(errorMsg)
+        throw IllegalStateException(errorMsg)
+    }
+    
+    /**
+     * 从链上查询市场结算结果获取价格
+     * 如果市场已结算：
+     *   - payout > 0（赢了）→ 返回 1.0
+     *   - payout == 0（输了）→ 返回 0.0
+     * 如果市场未结算或查询失败，返回 null
+     */
+    private suspend fun getPriceFromChainCondition(marketId: String, outcomeIndex: Int): BigDecimal? {
+        return try {
+            val chainResult = blockchainService.getCondition(marketId)
+            chainResult.fold(
+                onSuccess = { (_, payouts) ->
+                    // 如果 payouts 不为空，说明市场已结算
+                    if (payouts.isNotEmpty() && outcomeIndex < payouts.size) {
+                        val payout = payouts[outcomeIndex]
+                        when {
+                            payout > BigInteger.ZERO -> {
+                                logger.info("从链上查询到市场已结算，该 outcome 赢了: marketId=$marketId, outcomeIndex=$outcomeIndex, payout=$payout")
+                                return BigDecimal.ONE
+                            }
+                            payout == BigInteger.ZERO -> {
+                                logger.info("从链上查询到市场已结算，该 outcome 输了: marketId=$marketId, outcomeIndex=$outcomeIndex, payout=$payout")
+                                return BigDecimal.ZERO
+                            }
+                            else -> {
+                                logger.warn("从链上查询到异常的 payout 值: marketId=$marketId, outcomeIndex=$outcomeIndex, payout=$payout")
+                                null
+                            }
+                        }
+                    } else {
+                        logger.debug("从链上查询到市场尚未结算: marketId=$marketId, payouts=${payouts.size}")
+                        null
+                    }
+                },
+                onFailure = { e ->
+                    logger.debug("链上查询市场条件失败，降级到 API 查询: marketId=$marketId, error=${e.message}")
+                    null
+                }
+            )
+        } catch (e: Exception) {
+            logger.debug("链上查询市场条件异常: marketId=$marketId, outcomeIndex=$outcomeIndex, error=${e.message}")
+            null
+        }
+    }
+    
+    
+    /**
+     * 从 CLOB API 查询订单簿价格
+     * 获取订单簿的 bestBid 和 bestAsk，计算 midpoint = (bestBid + bestAsk) / 2
+     * 订单簿数据最准确，反映当前市场真实价格
+     * 如果查询失败，返回 null
+     */
+    private suspend fun getPriceFromClobOrderbook(marketId: String, outcomeIndex: Int): BigDecimal? {
+        return try {
+            // 获取 tokenId（用于查询特定 outcome 的订单簿）
+            val tokenIdResult = blockchainService.getTokenId(marketId, outcomeIndex)
+            if (!tokenIdResult.isSuccess) {
+                return null
+            }
+            
+            val tokenId = tokenIdResult.getOrNull() ?: return null
+            
+            // 尝试使用带鉴权的 CLOB API，如果没有则使用不带鉴权的 API
+            val clobApi = try {
+                getAuthenticatedClobApi() ?: retrofitFactory.createClobApiWithoutAuth()
+            } catch (e: Exception) {
+                logger.debug("获取带鉴权的 CLOB API 失败，使用不带鉴权的 API: ${e.message}")
+                retrofitFactory.createClobApiWithoutAuth()
+            }
+            
+            val orderbookResponse = clobApi.getOrderbook(tokenId = tokenId, market = null)
+            
+            if (!orderbookResponse.isSuccessful || orderbookResponse.body() == null) {
+                return null
+            }
+            
+            val orderbook = orderbookResponse.body()!!
+            
+            // 获取 bestBid（最高买入价）：从 bids 中找到价格最大的
+            // bids 表示买入订单列表，价格越高表示愿意出的价格越高
+            val bestBid = orderbook.bids
+                .mapNotNull { it.price.toSafeBigDecimal() }
+                .maxOrNull()
+            
+            // 获取 bestAsk（最低卖出价）：从 asks 中找到价格最小的
+            // asks 表示卖出订单列表，价格越低表示愿意卖的价格越低
+            val bestAsk = orderbook.asks
+                .mapNotNull { it.price.toSafeBigDecimal() }
+                .minOrNull()
+            
+            // 由于主要用于卖出场景，优先使用 bestBid（最高买入价，卖给愿意买入的人）
+            // 如果没有 bestBid，则使用 midpoint 或 bestAsk
+            if (bestBid != null) {
+                logger.debug("从订单簿获取价格（bestBid）: marketId=$marketId, outcomeIndex=$outcomeIndex, bestBid=$bestBid, bestAsk=$bestAsk")
+                return bestBid
+            } else if (bestAsk != null && bestAsk > BigDecimal.ZERO) {
+                // 如果没有 bestBid，使用 bestAsk 作为备选
+                logger.debug("从订单簿获取价格（bestAsk）: marketId=$marketId, outcomeIndex=$outcomeIndex, bestAsk=$bestAsk")
+                return bestAsk
+            }
+            
+            null
+        } catch (e: Exception) {
+            logger.debug("CLOB API 查询订单簿失败: marketId=$marketId, outcomeIndex=$outcomeIndex, error=${e.message}")
+            null
+        }
+    }
+    
+    /**
+     * 获取带鉴权的 CLOB API 客户端
+     * 使用第一个有 API 凭证的账户
+     * 如果都没有，返回 null
+     */
+    private fun getAuthenticatedClobApi(): PolymarketClobApi? {
+        return try {
+            // 使用第一个有 API 凭证的账户
+            val account = accountRepository.findAllByOrderByCreatedAtAsc()
+                .firstOrNull { it.apiKey != null && it.apiSecret != null && it.apiPassphrase != null }
+            
+            if (account == null || account.apiKey == null || account.apiSecret == null || account.apiPassphrase == null) {
+                return null
+            }
+            
+            // 解密 API 凭证
+            val apiKey = account.apiKey
+            val apiSecret = try {
+                cryptoUtils.decrypt(account.apiSecret)
+            } catch (e: Exception) {
+                logger.debug("解密 API Secret 失败: ${e.message}")
+                return null
+            }
+            val apiPassphrase = try {
+                cryptoUtils.decrypt(account.apiPassphrase)
+            } catch (e: Exception) {
+                logger.debug("解密 API Passphrase 失败: ${e.message}")
+                return null
+            }
+            
+            // 创建带鉴权的 CLOB API 客户端
+            retrofitFactory.createClobApi(apiKey, apiSecret, apiPassphrase, account.walletAddress)
+        } catch (e: Exception) {
+            logger.debug("获取带鉴权的 CLOB API 失败: ${e.message}")
+            null
+        }
+    }
+    
+}
+

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

@@ -1,5 +1,6 @@
 package com.wrbug.polymarketbot.service.common
 
+import com.google.gson.Gson
 import com.wrbug.polymarketbot.api.ApiKeyResponse
 import com.wrbug.polymarketbot.api.PolymarketClobApi
 import com.wrbug.polymarketbot.util.PolymarketL1AuthInterceptor
@@ -19,7 +20,8 @@ import retrofit2.converter.gson.GsonConverterFactory
 @Service
 class PolymarketApiKeyService(
     @Value("\${polymarket.clob.base-url}")
-    private val clobBaseUrl: String
+    private val clobBaseUrl: String,
+    private val gson: Gson
 ) {
     
     private val logger = LoggerFactory.getLogger(PolymarketApiKeyService::class.java)
@@ -222,7 +224,7 @@ class PolymarketApiKeyService(
         return Retrofit.Builder()
             .baseUrl(clobBaseUrl)
             .client(okHttpClient)
-            .addConverterFactory(GsonConverterFactory.create())
+            .addConverterFactory(GsonConverterFactory.create(gson))
             .build()
             .create(PolymarketClobApi::class.java)
     }
@@ -236,7 +238,7 @@ class PolymarketApiKeyService(
         return Retrofit.Builder()
             .baseUrl(clobBaseUrl)
             .client(okHttpClient)
-            .addConverterFactory(GsonConverterFactory.create())
+            .addConverterFactory(GsonConverterFactory.create(gson))
             .build()
             .create(PolymarketClobApi::class.java)
     }

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

@@ -300,13 +300,23 @@ class PolymarketClobService(
             )
             
             val response = authenticatedClobApi.getOrder(orderId)
-            if (response.isSuccessful && response.body() != null) {
-                Result.success(response.body()!!)
+            if (response.isSuccessful) {
+                val body = response.body()
+                if (body != null) {
+                    Result.success(body)
+                } else {
+                    // 响应体为空，可能是订单不存在或已过期
+                    logger.warn("获取订单详情失败: 响应体为空, orderId=$orderId, code=${response.code()}")
+                    Result.failure(Exception("订单不存在或已过期: orderId=$orderId"))
+                }
             } else {
-                Result.failure(Exception("获取订单详情失败: ${response.code()} ${response.message()}"))
+                // HTTP 状态码不是 2xx
+                val errorBody = response.errorBody()?.string()?.take(200) ?: "无错误详情"
+                logger.warn("获取订单详情失败: HTTP ${response.code()}, orderId=$orderId, errorBody=$errorBody")
+                Result.failure(Exception("获取订单详情失败: HTTP ${response.code()} ${response.message()}"))
             }
         } catch (e: Exception) {
-            logger.error("获取订单详情异常: ${e.message}", e)
+            logger.error("获取订单详情异常: orderId=$orderId, ${e.message}", e)
             Result.failure(e)
         }
     }

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

@@ -22,15 +22,14 @@ import java.util.concurrent.ConcurrentHashMap
 @Service
 class CopyTradingWebSocketService(
     private val copyOrderTrackingService: CopyOrderTrackingService,
-    private val templateRepository: CopyTradingTemplateRepository
+    private val templateRepository: CopyTradingTemplateRepository,
+    private val gson: Gson
 ) {
     
     private val logger = LoggerFactory.getLogger(CopyTradingWebSocketService::class.java)
     
     @Value("\${polymarket.websocket.url:wss://ws-live-data.polymarket.com}")
     private var websocketUrl: String = "wss://ws-live-data.polymarket.com"
-    
-    private val gson = Gson()
     private val scope = CoroutineScope(Dispatchers.Default + SupervisorJob())
     
     // 存储每个Leader的WebSocket客户端：leaderId -> WebSocketClient

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

@@ -1,5 +1,7 @@
 package com.wrbug.polymarketbot.service.copytrading.monitor
 
+import com.google.gson.Gson
+import com.google.gson.GsonBuilder
 import com.google.gson.JsonArray
 import com.google.gson.reflect.TypeToken
 import com.wrbug.polymarketbot.api.*
@@ -19,6 +21,29 @@ object OnChainWsUtils {
     
     private val logger = LoggerFactory.getLogger(OnChainWsUtils::class.java)
     
+    // 创建 Gson 实例（与 GsonConfig 中的配置一致，使用 lenient 模式）
+    private val gson: Gson = GsonBuilder()
+        .setLenient()
+        .create()
+    
+    /**
+     * 解析 JSON 字符串数组
+     * @param jsonString JSON 字符串，如 "[\"Yes\", \"No\"]"
+     * @return 字符串列表，如果解析失败返回空列表
+     */
+    private fun parseStringArray(jsonString: String?): List<String> {
+        if (jsonString.isNullOrBlank()) {
+            return emptyList()
+        }
+        
+        return try {
+            val listType = object : TypeToken<List<String>>() {}.type
+            gson.fromJson<List<String>>(jsonString, listType) ?: emptyList()
+        } catch (e: Exception) {
+            emptyList()
+        }
+    }
+    
     // 合约地址
     const val USDC_CONTRACT = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
     const val ERC1155_CONTRACT = "0x4d97dcd97ec945f40cf65f87097ace5ea0476045"
@@ -240,24 +265,17 @@ object OnChainWsUtils {
             val clobTokenIds = when {
                 clobTokenIdsRaw == null -> null
                 else -> {
-                    try {
-                        // 尝试解析 JSON 字符串
-                        val gson = com.google.gson.Gson()
-                        val listType = object : com.google.gson.reflect.TypeToken<List<String>>() {}.type
-                        gson.fromJson<List<String>>(clobTokenIdsRaw, listType)
-                    } catch (e: Exception) {
-                        // 如果不是 JSON 字符串，可能是其他格式，返回 null
-                        null
-                    }
+                    // 解析 JSON 字符串
+                    parseStringArray(clobTokenIdsRaw)
                 }
             }
             
             // 解析 outcomes（可能是 JSON 字符串或数组）
-            val outcomes = com.wrbug.polymarketbot.util.JsonUtils.parseStringArray(market.outcomes)
+            val outcomes = parseStringArray(market.outcomes)
             
             // 查找 tokenId 在 clobTokenIds 中的索引
-            val outcomeIndex = clobTokenIds?.indexOfFirst { 
-                it.equals(tokenId, ignoreCase = true)
+            val outcomeIndex = clobTokenIds?.indexOfFirst { token ->
+                token.equals(tokenId, ignoreCase = true)
             }?.takeIf { it >= 0 }
             
             // 获取 outcome 名称

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

@@ -27,14 +27,12 @@ import java.util.concurrent.ConcurrentHashMap
 @Service
 class UnifiedOnChainWsService(
     private val rpcNodeService: RpcNodeService,
-    private val retrofitFactory: RetrofitFactory
+    private val retrofitFactory: RetrofitFactory,
+    private val gson: Gson
 ) {
     
     private val logger = LoggerFactory.getLogger(UnifiedOnChainWsService::class.java)
     
-    // Gson 实例，用于解析 JSON
-    private val gson = Gson()
-    
     @Value("\${copy.trading.onchain.ws.reconnect.delay:3000}")
     private var reconnectDelay: Long = 3000  // 重连延迟（毫秒），默认3秒
     

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

@@ -37,7 +37,6 @@ open class CopyOrderTrackingService(
     private val sellMatchRecordRepository: SellMatchRecordRepository,
     private val sellMatchDetailRepository: SellMatchDetailRepository,
     private val processedTradeRepository: ProcessedTradeRepository,
-    private val failedTradeRepository: FailedTradeRepository,
     private val filteredOrderRepository: FilteredOrderRepository,
     private val copyTradingRepository: CopyTradingRepository,
     private val accountRepository: AccountRepository,
@@ -135,12 +134,6 @@ open class CopyOrderTrackingService(
                     return@withLock Result.success(Unit)
             }
 
-            // 检查是否已记录为失败交易
-            val failedTrade = failedTradeRepository.findByLeaderIdAndLeaderTradeId(leaderId, trade.id)
-            if (failedTrade != null) {
-                    return@withLock Result.success(Unit)
-            }
-
             // 2. 处理交易逻辑
             val result = when (trade.side.uppercase()) {
                 "BUY" -> processBuyTrade(leaderId, trade)
@@ -491,27 +484,6 @@ open class CopyOrderTrackingService(
                     if (createOrderResult.isFailure) {
                         // 提取错误信息（只保留 code 和 errorBody）
                         val exception = createOrderResult.exceptionOrNull()
-                        val errorMsg = buildFullErrorMessage(
-                            exception,
-                            "BUY",
-                            buyPrice.toString(),
-                            finalBuyQuantity.toString(),
-                            trade.id
-                        )
-                        
-                        // 记录失败交易到数据库
-                        // retryCount = MAX_RETRY_ATTEMPTS - 1，表示已重试的次数
-                        recordFailedTrade(
-                            leaderId = leaderId,
-                            trade = trade,
-                            copyTradingId = copyTrading.id!!,
-                            accountId = copyTrading.accountId,
-                            side = "BUY",
-                            price = buyPrice.toString(),
-                            size = finalBuyQuantity.toString(),
-                            errorMessage = errorMsg,
-                            retryCount = MAX_RETRY_ATTEMPTS - 1  // 已重试次数
-                        )
 
                         // 发送订单失败通知（异步，不阻塞，仅在 pushFailedOrders 为 true 时发送）
                         if (copyTrading.pushFailedOrders) {
@@ -971,26 +943,9 @@ open class CopyOrderTrackingService(
         )
 
         if (createOrderResult.isFailure) {
-            // 创建订单失败，记录到失败表
+            // 创建订单失败，记录错误日志
             val exception = createOrderResult.exceptionOrNull()
-            val errorMsg = buildFullErrorMessage(
-                exception,
-                "SELL",
-                sellPrice.toString(),
-                totalMatched.toString(),
-                leaderSellTrade.id
-            )
-            recordFailedTrade(
-                leaderId = copyTrading.leaderId,
-                trade = leaderSellTrade,
-                copyTradingId = copyTrading.id!!,
-                accountId = copyTrading.accountId,
-                side = "SELL",  // 订单方向是SELL
-                price = sellPrice.toString(),
-                size = totalMatched.toString(),
-                errorMessage = errorMsg,
-                retryCount = 1  // 已重试一次
-            )
+            logger.error("创建卖出订单失败: copyTradingId=${copyTrading.id}, tradeId=${leaderSellTrade.id}, error=${exception?.message}")
             return
         }
 
@@ -1248,98 +1203,6 @@ open class CopyOrderTrackingService(
         return "code=$code, errorBody=$errorBody"
     }
 
-    /**
-     * 记录失败交易到数据库
-     * 注意：此方法在 @Transactional 方法中被调用，会自动继承事务
-     */
-    private suspend fun recordFailedTrade(
-        leaderId: Long,
-        trade: TradeResponse,
-        copyTradingId: Long,
-        accountId: Long,
-        side: String,
-        price: String,
-        size: String,
-        errorMessage: String,
-        retryCount: Int
-    ) {
-        try {
-            // 确保错误信息不超过数据库字段限制（TEXT类型通常支持65535字符）
-            val maxErrorMessageLength = 50000  // 保留一些余量
-            val finalErrorMessage = if (errorMessage.length > maxErrorMessageLength) {
-                errorMessage.substring(0, maxErrorMessageLength) + "... (截断)"
-            } else {
-                errorMessage
-            }
-
-            val failedTrade = FailedTrade(
-                leaderId = leaderId,
-                leaderTradeId = trade.id,
-                tradeType = trade.side.uppercase(),
-                copyTradingId = copyTradingId,
-                accountId = accountId,
-                marketId = trade.market,
-                side = side,
-                price = price,
-                size = size,
-                errorMessage = finalErrorMessage,
-                retryCount = retryCount,
-                failedAt = System.currentTimeMillis()
-            )
-            failedTradeRepository.save(failedTrade)
-
-            // 记录日志，确认已保存到数据库
-            logger.info("失败交易已保存到数据库: leaderId=$leaderId, tradeId=${trade.id}, errorMessageLength=${finalErrorMessage.length}")
-
-            // 标记为已处理（失败状态），避免重复处理
-            // 注意：并发情况下可能多个请求同时处理同一笔交易，需要处理唯一约束冲突
-            try {
-                val processed = ProcessedTrade(
-                    leaderId = leaderId,
-                    leaderTradeId = trade.id,
-                    tradeType = trade.side.uppercase(),
-                    source = "polling",
-                    status = "FAILED",
-                    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 == "SUCCESS") {
-                            logger.warn("交易已成功处理，但尝试记录为失败（并发冲突）: leaderId=$leaderId, tradeId=${trade.id}")
-                        } else {
-                            logger.debug("交易已标记为失败（并发检测）: leaderId=$leaderId, tradeId=${trade.id}")
-                        }
-                    } else {
-                        // 如果查询不到，等待一下再查询（可能是事务隔离级别问题）
-                        delay(100)
-                        val existingAfterDelay =
-                            processedTradeRepository.findByLeaderIdAndLeaderTradeId(leaderId, trade.id)
-                        if (existingAfterDelay != null) {
-                            logger.debug("延迟查询到记录（并发检测）: leaderId=$leaderId, tradeId=${trade.id}, status=${existingAfterDelay.status}")
-                        } else {
-                            logger.warn(
-                                "保存ProcessedTrade失败记录时发生唯一约束冲突，但查询不到记录: leaderId=$leaderId, tradeId=${trade.id}",
-                                e
-                            )
-                        }
-                    }
-                } else {
-                    // 其他类型的异常，记录但不抛出（避免影响其他交易的处理）
-                    logger.warn("保存ProcessedTrade失败记录时发生异常: leaderId=$leaderId, tradeId=${trade.id}", e)
-                }
-            }
-
-            logger.warn("已记录失败交易: leaderId=$leaderId, tradeId=${trade.id}, error=$errorMessage")
-        } catch (e: Exception) {
-            logger.error("记录失败交易异常: leaderId=$leaderId, tradeId=${trade.id}", e)
-        }
-    }
 
     /**
      * 更新订单状态
@@ -1496,12 +1359,18 @@ open class CopyOrderTrackingService(
         return try {
             // 1. 查询订单详情
             val orderResponse = clobApi.getOrder(orderId)
-            if (!orderResponse.isSuccessful || orderResponse.body() == null) {
-                logger.warn("查询订单详情失败: orderId=$orderId, code=${orderResponse.code()}")
+            if (!orderResponse.isSuccessful) {
+                val errorBody = orderResponse.errorBody()?.string()?.take(200) ?: "无错误详情"
+                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
             }
-
-            val order = orderResponse.body()!!
             
             // 2. 如果订单未成交，使用下单价格
             if (order.status != "FILLED" && order.sizeMatched.toSafeBigDecimal() <= BigDecimal.ZERO) {

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

@@ -341,9 +341,9 @@ class CopyTradingStatisticsService(
                 // 传递 outcomeIndex 参数，确保获取对应 outcome 的价格
                 val result = accountService.getMarketPrice(marketId, outcomeIndex)
                 result.onSuccess { response ->
-                    // 使用中间价，如果没有则使用最后价格
-                    val price = response.midpoint ?: response.lastPrice
-                    if (price != null) {
+                    // 使用当前价格
+                    val price = response.currentPrice
+                    if (price.isNotBlank() && price != "0") {
                         // 使用 "marketId:outcomeIndex" 作为 key
                         val key = "$marketId:$outcomeIndex"
                         prices[key] = price

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

@@ -56,10 +56,13 @@ class OrderStatusUpdateService(
                 // 1. 清理已删除账户的订单
                 cleanupDeletedAccountOrders()
                 
-                // 2. 更新卖出订单的实际成交价并发送通知（priceUpdated 共用字段）
+                // 2. 检查30秒前创建的订单，如果未成交则删除
+                checkAndDeleteUnfilledOrders()
+                
+                // 3. 更新卖出订单的实际成交价并发送通知（priceUpdated 共用字段）
                 updatePendingSellOrderPrices()
                 
-                // 3. 更新买入订单的实际数据并发送通知
+                // 4. 更新买入订单的实际数据并发送通知
                 updatePendingBuyOrders()
             } catch (e: Exception) {
                 logger.error("订单状态更新异常: ${e.message}", e)
@@ -130,6 +133,131 @@ class OrderStatusUpdateService(
         }
     }
     
+    /**
+     * 检查30秒前创建的订单，如果未成交则删除
+     * 首次检测但加入缓存中30s后还没有成交，则删除
+     */
+    @Transactional
+    private suspend fun checkAndDeleteUnfilledOrders() {
+        try {
+            // 计算30秒前的时间戳
+            val thirtySecondsAgo = System.currentTimeMillis() - 30000
+            
+            // 查询30秒前创建的订单
+            val ordersToCheck = copyOrderTrackingRepository.findByCreatedAtBefore(thirtySecondsAgo)
+            
+            if (ordersToCheck.isEmpty()) {
+                return
+            }
+            
+            logger.debug("检查 ${ordersToCheck.size} 个30秒前创建的订单是否成交")
+            
+            // 按账户分组，避免重复创建 API 客户端
+            val ordersByAccount = ordersToCheck.groupBy { it.accountId }
+            
+            for ((accountId, orders) in ordersByAccount) {
+                try {
+                    // 获取账户
+                    val account = accountRepository.findById(accountId).orElse(null)
+                    if (account == null) {
+                        logger.warn("账户不存在，跳过检查: accountId=$accountId")
+                        continue
+                    }
+                    
+                    // 检查账户是否配置了 API 凭证
+                    if (account.apiKey == null || account.apiSecret == null || account.apiPassphrase == null) {
+                        logger.debug("账户未配置 API 凭证，跳过检查: accountId=${account.id}")
+                        continue
+                    }
+                    
+                    // 解密 API 凭证
+                    val apiSecret = try {
+                        cryptoUtils.decrypt(account.apiSecret!!)
+                    } catch (e: Exception) {
+                        logger.warn("解密 API Secret 失败: accountId=${account.id}, error=${e.message}")
+                        continue
+                    }
+                    
+                    val apiPassphrase = try {
+                        cryptoUtils.decrypt(account.apiPassphrase!!)
+                    } catch (e: Exception) {
+                        logger.warn("解密 API Passphrase 失败: accountId=${account.id}, error=${e.message}")
+                        continue
+                    }
+                    
+                    // 创建带认证的 CLOB API 客户端
+                    val clobApi = retrofitFactory.createClobApi(
+                        account.apiKey!!,
+                        apiSecret,
+                        apiPassphrase,
+                        account.walletAddress
+                    )
+                    
+                    // 检查每个订单
+                    for (order in orders) {
+                        try {
+                            // 查询订单详情
+                            val orderResponse = clobApi.getOrder(order.buyOrderId)
+                            
+                            // 先检查 HTTP 状态码，非 200 的都跳过
+                            if (orderResponse.code() != 200) {
+                                // HTTP 非 200，记录日志并跳过，等待下次轮询
+                                // 不删除订单，因为可能是临时网络问题或 API 错误
+                                val errorBody = orderResponse.errorBody()?.string()?.take(200) ?: "无错误详情"
+                                logger.debug("订单查询失败（HTTP非200），等待下次轮询: orderId=${order.buyOrderId}, copyOrderTrackingId=${order.id}, code=${orderResponse.code()}, errorBody=$errorBody")
+                                continue
+                            }
+                            
+                            // HTTP 200，检查响应体
+                            // 响应体也可能返回字符串 "null"，Gson 解析时会返回 null
+                            val orderDetail = orderResponse.body()
+                            if (orderDetail == null) {
+                                // HTTP 200 且响应体为 null（或字符串 "null"），表示订单不存在
+                                // 检查订单是否已部分卖出，如果已部分卖出则保留订单用于统计
+                                val hasMatchedDetails = sellMatchDetailRepository.findByTrackingId(order.id!!).isNotEmpty()
+                                if (hasMatchedDetails || order.matchedQuantity > BigDecimal.ZERO) {
+                                    logger.debug("订单不存在但已部分卖出，保留订单用于统计: orderId=${order.buyOrderId}, copyOrderTrackingId=${order.id}, matchedQuantity=${order.matchedQuantity}")
+                                    continue
+                                }
+                                
+                                // 订单不存在且未部分卖出，删除本地订单
+                                logger.info("订单不存在（HTTP 200 但响应体为空），删除本地订单: orderId=${order.buyOrderId}, copyOrderTrackingId=${order.id}")
+                                try {
+                                    copyOrderTrackingRepository.deleteById(order.id!!)
+                                    logger.info("已删除本地订单: orderId=${order.buyOrderId}, copyOrderTrackingId=${order.id}")
+                                } catch (e: Exception) {
+                                    logger.error("删除本地订单失败: orderId=${order.buyOrderId}, copyOrderTrackingId=${order.id}, error=${e.message}", e)
+                                }
+                                continue
+                            }
+                            
+                            // 检查订单是否成交
+                            // 如果订单状态不是 FILLED 且已成交数量为0，说明未成交，删除
+                            val sizeMatched = orderDetail.sizeMatched?.toSafeBigDecimal() ?: BigDecimal.ZERO
+                            if (orderDetail.status != "FILLED" && sizeMatched <= BigDecimal.ZERO) {
+                                logger.info("订单30秒后仍未成交，删除本地订单: orderId=${order.buyOrderId}, copyOrderTrackingId=${order.id}, status=${orderDetail.status}, sizeMatched=$sizeMatched")
+                                try {
+                                    copyOrderTrackingRepository.deleteById(order.id!!)
+                                    logger.info("已删除未成交订单: orderId=${order.buyOrderId}, copyOrderTrackingId=${order.id}")
+                                } catch (e: Exception) {
+                                    logger.error("删除未成交订单失败: orderId=${order.buyOrderId}, copyOrderTrackingId=${order.id}, error=${e.message}", e)
+                                }
+                            } else {
+                                logger.debug("订单已成交或部分成交，保留: orderId=${order.buyOrderId}, status=${orderDetail.status}, sizeMatched=$sizeMatched")
+                            }
+                        } catch (e: Exception) {
+                            logger.error("检查订单失败: orderId=${order.buyOrderId}, error=${e.message}", e)
+                        }
+                    }
+                } catch (e: Exception) {
+                    logger.error("检查账户订单失败: accountId=$accountId, error=${e.message}", e)
+                }
+            }
+        } catch (e: Exception) {
+            logger.error("检查未成交订单异常: ${e.message}", e)
+        }
+    }
+    
     /**
      * 更新待更新的卖出订单价格
      * 注意：priceUpdated 现在同时表示价格已更新和通知已发送（共用字段）
@@ -456,12 +584,36 @@ class OrderStatusUpdateService(
                     
                     // 查询订单详情
                     val orderResponse = clobApi.getOrder(order.buyOrderId)
-                    if (!orderResponse.isSuccessful || orderResponse.body() == null) {
-                        logger.debug("查询订单详情失败，等待下次轮询: orderId=${order.buyOrderId}, code=${orderResponse.code()}")
+                    
+                    // 先检查 HTTP 状态码，非 200 的都跳过
+                    if (orderResponse.code() != 200) {
+                        val errorBody = orderResponse.errorBody()?.string()?.take(200) ?: "无错误详情"
+                        logger.debug("查询订单详情失败（HTTP非200），等待下次轮询: orderId=${order.buyOrderId}, copyOrderTrackingId=${order.id}, code=${orderResponse.code()}, errorBody=$errorBody")
                         continue
                     }
                     
-                    val orderDetail = orderResponse.body()!!
+                    // HTTP 200，检查响应体
+                    // 响应体也可能返回字符串 "null"，Gson 解析时会返回 null
+                    val orderDetail = orderResponse.body()
+                    if (orderDetail == null) {
+                        // HTTP 200 且响应体为 null（或字符串 "null"），表示订单不存在
+                        // 检查订单是否已部分卖出，如果已部分卖出则保留订单用于统计
+                        val hasMatchedDetails = sellMatchDetailRepository.findByTrackingId(order.id!!).isNotEmpty()
+                        if (hasMatchedDetails || order.matchedQuantity > BigDecimal.ZERO) {
+                            logger.debug("订单不存在但已部分卖出，保留订单用于统计: orderId=${order.buyOrderId}, copyOrderTrackingId=${order.id}, matchedQuantity=${order.matchedQuantity}")
+                            continue
+                        }
+                        
+                        // 订单不存在且未部分卖出，删除本地订单
+                        logger.info("订单不存在（HTTP 200 但响应体为空），删除本地订单: orderId=${order.buyOrderId}, copyOrderTrackingId=${order.id}")
+                        try {
+                            copyOrderTrackingRepository.deleteById(order.id!!)
+                            logger.info("已删除本地订单: orderId=${order.buyOrderId}, copyOrderTrackingId=${order.id}")
+                        } catch (e: Exception) {
+                            logger.error("删除本地订单失败: orderId=${order.buyOrderId}, copyOrderTrackingId=${order.id}, error=${e.message}", e)
+                        }
+                        continue
+                    }
                     
                     // 获取实际价格和数量
                     val actualPrice = orderDetail.price?.toSafeBigDecimal() ?: order.price

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

@@ -97,21 +97,28 @@ class TelegramNotificationService(
         if ((actualPrice == null || actualSize == null) && orderId != null && clobApi != null && apiKey != null && apiSecret != null && apiPassphrase != null && walletAddressForApi != null) {
             try {
                 val orderResponse = clobApi.getOrder(orderId)
-                if (orderResponse.isSuccessful && orderResponse.body() != null) {
-                    val order = orderResponse.body()!!
-                    if (actualPrice == null) {
-                    actualPrice = order.price
-                    }
-                    if (actualSize == null) {
-                    actualSize = order.originalSize  // 使用 originalSize 作为订单数量
-                    }
-                    actualSide = order.side  // 使用订单详情中的 side
-                    if (actualOutcome == null) {
-                    actualOutcome = order.outcome  // 使用订单详情中的 outcome（市场方向）
+                if (orderResponse.isSuccessful) {
+                    val order = orderResponse.body()
+                    if (order != null) {
+                        if (actualPrice == null) {
+                            actualPrice = order.price
+                        }
+                        if (actualSize == null) {
+                            actualSize = order.originalSize  // 使用 originalSize 作为订单数量
+                        }
+                        actualSide = order.side  // 使用订单详情中的 side
+                        if (actualOutcome == null) {
+                            actualOutcome = order.outcome  // 使用订单详情中的 outcome（市场方向）
+                        }
+                    } else {
+                        logger.debug("查询订单详情失败: 响应体为空, orderId=$orderId")
                     }
+                } else {
+                    val errorBody = orderResponse.errorBody()?.string()?.take(200) ?: "无错误详情"
+                    logger.debug("查询订单详情失败: orderId=$orderId, code=${orderResponse.code()}, errorBody=$errorBody")
                 }
             } catch (e: Exception) {
-                logger.warn("查询订单详情失败: ${e.message}", e)
+                logger.warn("查询订单详情失败: orderId=$orderId, ${e.message}", e)
             }
         }
         

backend/src/main/kotlin/com/wrbug/polymarketbot/util/JsonUtils.kt

@@ -2,14 +2,16 @@ package com.wrbug.polymarketbot.util
 
 import com.google.gson.Gson
 import com.google.gson.reflect.TypeToken
+import org.springframework.stereotype.Component
 
 /**
  * JSON 工具类
  * 用于解析 JSON 字符串
  */
-object JsonUtils {
-    
-    private val gson = Gson()
+@Component
+class JsonUtils(
+    private val gson: Gson
+) {
     
     /**
      * 解析 JSON 字符串数组

backend/src/main/kotlin/com/wrbug/polymarketbot/util/RetrofitFactory.kt

@@ -1,7 +1,6 @@
 package com.wrbug.polymarketbot.util
 
 import com.google.gson.Gson
-import com.google.gson.GsonBuilder
 import com.wrbug.polymarketbot.api.BuilderRelayerApi
 import com.wrbug.polymarketbot.api.EthereumRpcApi
 import com.wrbug.polymarketbot.api.GitHubApi
@@ -24,21 +23,116 @@ import org.springframework.stereotype.Component
 import retrofit2.Retrofit
 import retrofit2.converter.gson.GsonConverterFactory
 import java.io.IOException
+import java.util.concurrent.ConcurrentHashMap
+import jakarta.annotation.PreDestroy
 
 /**
  * Retrofit 客户端工厂
  * 用于创建带认证的 Polymarket CLOB API 客户端和 Ethereum RPC API 客户端
+ * 
+ * 注意：为了避免内存泄漏，本类会缓存和复用客户端实例
  */
 @Component
 class RetrofitFactory(
     @Value("\${polymarket.clob.base-url}")
     private val clobBaseUrl: String,
     @Value("\${polymarket.gamma.base-url}")
-    private val gammaBaseUrl: String
+    private val gammaBaseUrl: String,
+    private val gson: Gson
 ) {
     
+    private val logger = LoggerFactory.getLogger(RetrofitFactory::class.java)
+    
+    // 共享的 OkHttpClient（用于不需要认证的 API）
+    private val sharedOkHttpClient: OkHttpClient by lazy {
+        createClient().build()
+    }
+    
+    // 共享的 OkHttpClient（用于需要跟随重定向的 API）
+    private val sharedOkHttpClientWithRedirect: OkHttpClient by lazy {
+        createClient()
+            .followRedirects(true)
+            .followSslRedirects(true)
+            .build()
+    }
+    
+    // 缓存 Gamma API 客户端（单例）
+    private val gammaApi: PolymarketGammaApi by lazy {
+        val baseUrl = if (gammaBaseUrl.endsWith("/")) {
+            gammaBaseUrl.dropLast(1)
+        } else {
+            gammaBaseUrl
+        }
+        
+        Retrofit.Builder()
+            .baseUrl("$baseUrl/")
+            .client(sharedOkHttpClient)
+            .addConverterFactory(GsonConverterFactory.create(gson))
+            .build()
+            .create(PolymarketGammaApi::class.java)
+    }
+    
+    // 缓存 Data API 客户端（单例）
+    private val dataApi: PolymarketDataApi by lazy {
+        val baseUrl = "https://data-api.polymarket.com"
+        
+        Retrofit.Builder()
+            .baseUrl("$baseUrl/")
+            .client(sharedOkHttpClientWithRedirect)
+            .addConverterFactory(GsonConverterFactory.create(gson))
+            .build()
+            .create(PolymarketDataApi::class.java)
+    }
+    
+    // 缓存 GitHub API 客户端（单例）
+    private val githubApi: GitHubApi by lazy {
+        val baseUrl = "https://api.github.com"
+        
+        // 添加拦截器，设置 Accept 头以获取 reactions 数据
+        val githubInterceptor = object : Interceptor {
+            override fun intercept(chain: Interceptor.Chain): Response {
+                val request = chain.request().newBuilder()
+                    .header("Accept", "application/vnd.github+json")
+                    .build()
+                return chain.proceed(request)
+            }
+        }
+        
+        val okHttpClient = createClient()
+            .addInterceptor(githubInterceptor)
+            .build()
+        
+        Retrofit.Builder()
+            .baseUrl("$baseUrl/")
+            .client(okHttpClient)
+            .addConverterFactory(GsonConverterFactory.create(gson))
+            .build()
+            .create(GitHubApi::class.java)
+    }
+    
+    // 缓存不带认证的 CLOB API 客户端（单例）
+    private val clobApiWithoutAuth: PolymarketClobApi by lazy {
+        Retrofit.Builder()
+            .baseUrl(clobBaseUrl)
+            .client(sharedOkHttpClient)
+            .addConverterFactory(GsonConverterFactory.create(gson))
+            .build()
+            .create(PolymarketClobApi::class.java)
+    }
+    
+    // 缓存带认证的 CLOB API 客户端：walletAddress -> PolymarketClobApi
+    // 注意：每个账户使用不同的 API Key，需要不同的客户端
+    private val clobApiCache = ConcurrentHashMap<String, PolymarketClobApi>()
+    
+    // 缓存 RPC API 客户端：rpcUrl -> EthereumRpcApi
+    private val rpcApiCache = ConcurrentHashMap<String, EthereumRpcApi>()
+    
+    // 缓存 Builder Relayer API 客户端：relayerUrl -> BuilderRelayerApi
+    private val builderRelayerApiCache = ConcurrentHashMap<String, BuilderRelayerApi>()
+    
     /**
      * 创建带认证的 Polymarket CLOB API 客户端
+     * 按钱包地址缓存，避免重复创建
      * @param apiKey API Key
      * @param apiSecret API Secret
      * @param apiPassphrase API Passphrase
@@ -51,67 +145,46 @@ class RetrofitFactory(
         apiPassphrase: String,
         walletAddress: String
     ): PolymarketClobApi {
-        val authInterceptor = PolymarketAuthInterceptor(apiKey, apiSecret, apiPassphrase, walletAddress)
-        
-        // 添加响应日志拦截器，用于调试 JSON 解析错误
-        val responseLoggingInterceptor = ResponseLoggingInterceptor()
-        
-        val okHttpClient = createClient()
-            .addInterceptor(authInterceptor)
-            .addInterceptor(responseLoggingInterceptor)
-            .build()
-        
-        // 创建 lenient 模式的 Gson，允许解析格式不严格的 JSON
-        val gson = GsonBuilder()
-            .setLenient()
-            .create()
-        
-        return Retrofit.Builder()
-            .baseUrl(clobBaseUrl)
-            .client(okHttpClient)
-            .addConverterFactory(GsonConverterFactory.create(gson))
-            .build()
-            .create(PolymarketClobApi::class.java)
+        // 使用钱包地址作为缓存键（每个账户使用不同的 API Key）
+        return clobApiCache.computeIfAbsent(walletAddress) {
+            val authInterceptor = PolymarketAuthInterceptor(apiKey, apiSecret, apiPassphrase, walletAddress)
+            
+            // 添加响应日志拦截器，用于调试 JSON 解析错误
+            val responseLoggingInterceptor = ResponseLoggingInterceptor()
+            
+            val okHttpClient = createClient()
+                .addInterceptor(authInterceptor)
+                .addInterceptor(responseLoggingInterceptor)
+                .build()
+            
+            Retrofit.Builder()
+                .baseUrl(clobBaseUrl)
+                .client(okHttpClient)
+                .addConverterFactory(GsonConverterFactory.create(gson))
+                .build()
+                .create(PolymarketClobApi::class.java)
+        }
     }
     
     /**
      * 创建不带认证的 Polymarket CLOB API 客户端
      * 用于不需要认证的查询接口
-     * @return PolymarketClobApi 客户端
+     * @return PolymarketClobApi 客户端（单例）
      */
     fun createClobApiWithoutAuth(): PolymarketClobApi {
-        // 添加响应日志拦截器，用于调试 JSON 解析错误
-        val responseLoggingInterceptor = ResponseLoggingInterceptor()
-        
-        val okHttpClient = createClient()
-            .addInterceptor(responseLoggingInterceptor)
-            .build()
-        
-        // 创建 lenient 模式的 Gson，允许解析格式不严格的 JSON
-        val gson = GsonBuilder()
-            .setLenient()
-            .create()
-        
-        return Retrofit.Builder()
-            .baseUrl(clobBaseUrl)
-            .client(okHttpClient)
-            .addConverterFactory(GsonConverterFactory.create(gson))
-            .build()
-            .create(PolymarketClobApi::class.java)
+        return clobApiWithoutAuth
     }
     
     /**
      * 创建 Ethereum RPC API 客户端
      * 使用固定的 baseUrl，通过拦截器动态替换为实际的 RPC URL
      * 如果 RPC 不可用，将抛出异常
+     * 按 RPC URL 缓存，避免重复创建
      * @param rpcUrl RPC 节点 URL
      * @return EthereumRpcApi 客户端
      * @throws IllegalArgumentException 如果 RPC URL 无效或不可用
      */
     fun createEthereumRpcApi(rpcUrl: String): EthereumRpcApi {
-        // 使用固定的 baseUrl（Retrofit 要求 baseUrl 必须以 / 结尾）
-        val fixedBaseUrl = "https://polyrpc.polyhermes/"
-        
         // 确保实际的 RPC URL 以 / 结尾
         val actualRpcUrl = if (rpcUrl.endsWith("/")) {
             rpcUrl
@@ -119,27 +192,28 @@ class RetrofitFactory(
             "$rpcUrl/"
         }
         
-        // 验证 RPC 是否可用
-        validateRpcAvailability(actualRpcUrl)
-        
-        // 创建 URL 替换拦截器
-        val urlReplaceInterceptor = RpcUrlReplaceInterceptor(fixedBaseUrl, actualRpcUrl)
-        
-        val okHttpClient = createClient()
-            .addInterceptor(urlReplaceInterceptor)
-            .build()
-        
-        // 创建 lenient 模式的 Gson
-        val gson = GsonBuilder()
-            .setLenient()
-            .create()
-        
-        return Retrofit.Builder()
-            .baseUrl(fixedBaseUrl)
-            .client(okHttpClient)
-            .addConverterFactory(GsonConverterFactory.create(gson))
-            .build()
-            .create(EthereumRpcApi::class.java)
+        // 使用 RPC URL 作为缓存键
+        return rpcApiCache.computeIfAbsent(actualRpcUrl) {
+            // 验证 RPC 是否可用（仅在新创建时验证）
+            validateRpcAvailability(actualRpcUrl)
+            
+            // 使用固定的 baseUrl（Retrofit 要求 baseUrl 必须以 / 结尾）
+            val fixedBaseUrl = "https://polyrpc.polyhermes/"
+            
+            // 创建 URL 替换拦截器
+            val urlReplaceInterceptor = RpcUrlReplaceInterceptor(fixedBaseUrl, actualRpcUrl)
+            
+            val okHttpClient = createClient()
+                .addInterceptor(urlReplaceInterceptor)
+                .build()
+            
+            Retrofit.Builder()
+                .baseUrl(fixedBaseUrl)
+                .client(okHttpClient)
+                .addConverterFactory(GsonConverterFactory.create(gson))
+                .build()
+                .create(EthereumRpcApi::class.java)
+        }
     }
     
     /**
@@ -149,8 +223,6 @@ class RetrofitFactory(
      * @throws IllegalArgumentException 如果 RPC 不可用
      */
     private fun validateRpcAvailability(rpcUrl: String) {
-        val logger = LoggerFactory.getLogger(RetrofitFactory::class.java)
-        
         try {
             // 解析 URL
             val httpUrl = rpcUrl.toHttpUrlOrNull()
@@ -218,56 +290,24 @@ class RetrofitFactory(
     /**
      * 创建 Polymarket Gamma API 客户端
      * Gamma API 是公开 API，不需要认证
-     * @return PolymarketGammaApi 客户端
+     * @return PolymarketGammaApi 客户端（单例）
      */
     fun createGammaApi(): PolymarketGammaApi {
-        val baseUrl = if (gammaBaseUrl.endsWith("/")) {
-            gammaBaseUrl.dropLast(1)
-        } else {
-            gammaBaseUrl
-        }
-        val okHttpClient = createClient().build()
-        
-        // 创建 lenient 模式的 Gson
-        val gson = GsonBuilder()
-            .setLenient()
-            .create()
-        
-        return Retrofit.Builder()
-            .baseUrl("$baseUrl/")
-            .client(okHttpClient)
-            .addConverterFactory(GsonConverterFactory.create(gson))
-            .build()
-            .create(PolymarketGammaApi::class.java)
+        return gammaApi
     }
     
     /**
      * 创建 Polymarket Data API 客户端
      * Data API 是公开 API，不需要认证
-     * @return PolymarketDataApi 客户端
+     * @return PolymarketDataApi 客户端（单例）
      */
     fun createDataApi(): PolymarketDataApi {
-        val baseUrl = "https://data-api.polymarket.com"
-        val okHttpClient = createClient()
-            .followRedirects(true)
-            .followSslRedirects(true)
-            .build()
-        
-        // 创建 lenient 模式的 Gson
-        val gson = GsonBuilder()
-            .setLenient()
-            .create()
-        
-        return Retrofit.Builder()
-            .baseUrl("$baseUrl/")
-            .client(okHttpClient)
-            .addConverterFactory(GsonConverterFactory.create(gson))
-            .build()
-            .create(PolymarketDataApi::class.java)
+        return dataApi
     }
     
     /**
      * 创建 Builder Relayer API 客户端
+     * 按 relayerUrl 缓存，避免重复创建
      * @param relayerUrl Builder Relayer URL
      * @param apiKey Builder API Key
      * @param secret Builder Secret
@@ -286,57 +326,61 @@ class RetrofitFactory(
             relayerUrl
         }
         
-        // 添加 Builder 认证拦截器
-        val builderAuthInterceptor = BuilderAuthInterceptor(apiKey, secret, passphrase)
-        val okHttpClient = createClient()
-            .addInterceptor(builderAuthInterceptor)
-            .build()
-        
-        val gson = GsonBuilder()
-            .setLenient()
-            .create()
-        
-        return Retrofit.Builder()
-            .baseUrl("$baseUrl/")
-            .client(okHttpClient)
-            .addConverterFactory(GsonConverterFactory.create(gson))
-            .build()
-            .create(BuilderRelayerApi::class.java)
+        // 使用 baseUrl 作为缓存键（注意：如果 API Key 变化，需要清理缓存）
+        return builderRelayerApiCache.computeIfAbsent(baseUrl) {
+            // 添加 Builder 认证拦截器
+            val builderAuthInterceptor = BuilderAuthInterceptor(apiKey, secret, passphrase)
+            val okHttpClient = createClient()
+                .addInterceptor(builderAuthInterceptor)
+                .build()
+            
+            Retrofit.Builder()
+                .baseUrl("$baseUrl/")
+                .client(okHttpClient)
+                .addConverterFactory(GsonConverterFactory.create(gson))
+                .build()
+                .create(BuilderRelayerApi::class.java)
+        }
     }
     
     /**
      * 创建 GitHub API 客户端
      * GitHub API 是公开 API，不需要认证（但建议使用 token 提高速率限制）
      * 添加 Accept 头以获取 reactions 数据
-     * @return GitHubApi 客户端
+     * @return GitHubApi 客户端（单例）
      */
     fun createGitHubApi(): GitHubApi {
-        val baseUrl = "https://api.github.com"
-        
-        // 添加拦截器，设置 Accept 头以获取 reactions 数据
-        val githubInterceptor = object : Interceptor {
-            override fun intercept(chain: Interceptor.Chain): Response {
-                val request = chain.request().newBuilder()
-                    .header("Accept", "application/vnd.github+json")
-                    .build()
-                return chain.proceed(request)
-            }
-        }
-        
-        val okHttpClient = createClient()
-            .addInterceptor(githubInterceptor)
-            .build()
-        
-        val gson = GsonBuilder()
-            .setLenient()
-            .create()
-        
-        return Retrofit.Builder()
-            .baseUrl("$baseUrl/")
-            .client(okHttpClient)
-            .addConverterFactory(GsonConverterFactory.create(gson))
-            .build()
-            .create(GitHubApi::class.java)
+        return githubApi
+    }
+    
+    /**
+     * 清理缓存（用于测试或配置变更时）
+     */
+    @PreDestroy
+    fun destroy() {
+        logger.info("清理 RetrofitFactory 缓存")
+        clobApiCache.clear()
+        rpcApiCache.clear()
+        builderRelayerApiCache.clear()
+    }
+    
+    /**
+     * 清理指定钱包地址的 CLOB API 缓存
+     * 用于 API Key 变更时
+     */
+    fun clearClobApiCache(walletAddress: String) {
+        clobApiCache.remove(walletAddress)
+        logger.debug("已清理 CLOB API 缓存: $walletAddress")
+    }
+    
+    /**
+     * 清理指定 RPC URL 的 RPC API 缓存
+     * 用于 RPC 节点变更时
+     */
+    fun clearRpcApiCache(rpcUrl: String) {
+        val actualRpcUrl = if (rpcUrl.endsWith("/")) rpcUrl else "$rpcUrl/"
+        rpcApiCache.remove(actualRpcUrl)
+        logger.debug("已清理 RPC API 缓存: $actualRpcUrl")
     }
 }
 
@@ -393,22 +437,35 @@ class ResponseLoggingInterceptor : Interceptor {
                 val responseBody = response.peekBody(2048)
                 val responseBodyString = responseBody.string()
                 
-                // 检查是否是有效的 JSON
-                val isJson = responseBodyString.trim().startsWith("{") || 
-                            responseBodyString.trim().startsWith("[")
+                // 检查响应体是否为空
+                val isEmpty = responseBodyString.isBlank()
                 
-                if (!isJson || !response.isSuccessful) {
+                // 检查是否是有效的 JSON
+                val trimmedBody = responseBodyString.trim()
+                val isJson = !isEmpty && (
+                    trimmedBody.startsWith("{") || 
+                    trimmedBody.startsWith("[")
+                )
+                
+                // 如果响应体为空或不是 JSON，记录警告
+                if (isEmpty || !isJson) {
+                    val bodyPreview = if (isEmpty) {
+                        "(空响应体)"
+                    } else {
+                        trimmedBody.take(500)
+                    }
                     logger.warn(
                         "API 响应异常: method=${request.method}, url=${request.url}, " +
-                        "code=${response.code}, isJson=$isJson, " +
-                        "responseBody=${responseBodyString.take(500)}"
+                        "code=${response.code}, isJson=$isJson, isEmpty=$isEmpty, " +
+                        "responseBody=$bodyPreview"
                     )
                 }
             } catch (e: Exception) {
+                // 如果读取响应体失败，记录异常但不影响响应
+                logger.debug("读取响应体失败: ${e.message}")
             }
         }
         
         return response
     }
 }
-

backend/src/main/resources/db/migration/V16__remove_failed_trade_table.sql

@@ -0,0 +1,8 @@
+-- ============================================
+-- V16: 删除失败交易记录表
+-- 移除下单失败存储到数据库的功能
+-- ============================================
+
+-- 删除失败交易记录表
+DROP TABLE IF EXISTS failed_trade;
+

deploy.sh

@@ -156,7 +156,18 @@ deploy() {
         # 注意：这里需要手动修改 docker-compose.yml，或者使用环境变量
         warn "请确保 docker-compose.yml 中已配置使用 image: wrbug/polyhermes:latest"
     else
-        info "构建 Docker 镜像（本地构建，版本号将显示为 dev）..."
+        # 获取当前分支名作为版本号
+        CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "dev")
+        # 如果分支名包含 /，替换为 -（Docker tag 不支持 /）
+        DOCKER_VERSION=$(echo "$CURRENT_BRANCH" | tr '/' '-')
+        
+        info "构建 Docker 镜像（本地构建，版本号: ${DOCKER_VERSION}）..."
+        
+        # 设置构建参数（通过环境变量传递给 docker-compose.yml）
+        export VERSION=${DOCKER_VERSION}
+        export GIT_TAG=${DOCKER_VERSION}
+        export GITHUB_REPO_URL=https://github.com/WrBug/PolyHermes
+        
         docker-compose build
     fi
     
@@ -196,7 +207,9 @@ main() {
     info "访问地址: http://localhost:${SERVER_PORT:-80}"
     echo ""
     if [ "$USE_DOCKER_HUB" != "true" ]; then
-        info "提示：本地构建的版本号显示为 'dev'"
+        CURRENT_BRANCH=$(git rev-parse --abbrev-ref HEAD 2>/dev/null || echo "dev")
+        DOCKER_VERSION=$(echo "$CURRENT_BRANCH" | tr '/' '-')
+        info "提示：本地构建的版本号为当前分支名: ${DOCKER_VERSION}"
         info "生产环境推荐使用 Docker Hub 镜像："
         info "  ./deploy.sh --use-docker-hub"
         info "  或修改 docker-compose.yml 使用 image: wrbug/polyhermes:latest"

docker-compose.yml

@@ -8,11 +8,11 @@ services:
     build:
       context: .
       dockerfile: Dockerfile
-      # 本地构建时可以传递版本号参数（可选）
-      # args:
-      #   VERSION: ${VERSION:-dev}
-      #   GIT_TAG: ${GIT_TAG:-}
-      #   GITHUB_REPO_URL: https://github.com/WrBug/PolyHermes
+      # 本地构建时可以传递版本号参数（自动使用当前分支名）
+      args:
+        VERSION: ${VERSION:-dev}
+        GIT_TAG: ${GIT_TAG:-${VERSION:-dev}}
+        GITHUB_REPO_URL: ${GITHUB_REPO_URL:-https://github.com/WrBug/PolyHermes}
     container_name: polyhermes
     ports:
       - "${SERVER_PORT:-80}:80"

docs/zh/smart-money-analysis.md

@@ -0,0 +1,835 @@
+# 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/pages/PositionList.tsx

@@ -399,10 +399,10 @@ const PositionList: React.FC = () => {
       })
       if (response.data.code === 0 && response.data.data) {
         setMarketPrice(response.data.data)
-        // 默认使用最优买价作为限价
-        if (response.data.data.bestBid) {
-          setLimitPrice(response.data.data.bestBid)
-          form.setFieldsValue({ limitPrice: response.data.data.bestBid })
+        // 默认使用当前价格作为限价
+        if (response.data.data.currentPrice) {
+          setLimitPrice(response.data.data.currentPrice)
+          form.setFieldsValue({ limitPrice: response.data.data.currentPrice })
         }
       }
     } catch (error: any) {
@@ -449,12 +449,10 @@ const PositionList: React.FC = () => {
   }
 
   // 获取当前卖出价格（市价或限价）
-  // 卖出操作应该使用 bestBid（最优买价），因为你要卖给愿意买入的人
   const getCurrentSellPrice = (): string => {
     if (orderType === 'MARKET') {
-      // 市价订单（卖出）：优先使用最优买价（bestBid），因为卖出是卖给买单
-      // 如果没有 bestBid，则使用当前价格，最后使用最新成交价
-      return marketPrice?.bestBid || selectedPosition?.currentPrice || marketPrice?.lastPrice || '0'
+      // 市价订单（卖出）：使用当前价格
+      return marketPrice?.currentPrice || selectedPosition?.currentPrice || '0'
     }
     return limitPrice || '0'
   }
@@ -1377,7 +1375,7 @@ const PositionList: React.FC = () => {
                   // 切换订单类型时重新计算收益
                   if (sellQuantity) {
                     const price = e.target.value === 'MARKET' 
-                      ? (marketPrice?.bestBid || selectedPosition?.currentPrice || marketPrice?.lastPrice || '0')
+                      ? (marketPrice?.currentPrice || selectedPosition?.currentPrice || '0')
                       : limitPrice || '0'
                     calculatePnl(sellQuantity, price)
                   }
@@ -1457,9 +1455,9 @@ const PositionList: React.FC = () => {
                   }}
                   placeholder="请输入限价价格"
                 />
-                {marketPrice?.bestBid && (
+                {marketPrice?.currentPrice && (
                   <div style={{ marginTop: '4px', fontSize: '12px', color: '#999' }}>
-                    参考价格（最优买价，卖出参考）: {formatNumber(marketPrice.bestBid, 4)}
+                    参考价格（卖出参考）: {formatNumber(marketPrice.currentPrice, 4)}
                   </div>
                 )}
               </Form.Item>
@@ -1469,21 +1467,14 @@ const PositionList: React.FC = () => {
               <div style={{ marginBottom: '16px', padding: '12px', background: '#f0f7ff', borderRadius: '8px' }}>
                 <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>市价参考（卖出）</div>
                 <div style={{ fontSize: '14px' }}>
-                  {marketPrice?.bestBid ? (
-                    <>最优买价（卖出参考）: <span style={{ fontWeight: '500' }}>{formatNumber(marketPrice.bestBid, 4)}</span></>
+                  {marketPrice?.currentPrice ? (
+                    <>当前价格: <span style={{ fontWeight: '500' }}>{formatNumber(marketPrice.currentPrice, 4)}</span></>
                   ) : selectedPosition?.currentPrice ? (
                     <>当前价格: <span style={{ fontWeight: '500' }}>{formatNumber(selectedPosition.currentPrice, 4)}</span></>
-                  ) : marketPrice?.lastPrice ? (
-                    <>最新成交价: <span style={{ fontWeight: '500' }}>{formatNumber(marketPrice.lastPrice, 4)}</span></>
                   ) : (
                     <span style={{ color: '#999' }}>暂无价格数据</span>
                   )}
                 </div>
-                {marketPrice?.bestAsk && (
-                  <div style={{ fontSize: '12px', color: '#999', marginTop: '4px' }}>
-                    最优卖价（买入参考）: {formatNumber(marketPrice.bestAsk, 4)}
-                  </div>
-                )}
               </div>
             )}
             

frontend/src/types/index.ts

@@ -434,14 +434,11 @@ export interface MarketPriceRequest {
 }
 
 /**
- * 市场价格响应
+ * 市场当前价格响应
  */
 export interface MarketPriceResponse {
   marketId: string
-  lastPrice?: string
-  bestBid?: string
-  bestAsk?: string
-  midpoint?: string
+  currentPrice: string
 }
 
 /**