fix: handle neg_risk market in sellPosition

Fixes #38 The sellPosition method was not checking if the market uses Neg Risk Exchange contract. For neg_risk markets, the order signing must use the Neg Risk Exchange address, otherwise the order will be rejected by Polymarket. The copy trading service already handles this correctly, but the manual sell position flow was missing this check.
Merge pull request #57 from WrBug/dev
2026-04-29 14:35:43 +08:00 · 2026-04-28 22:32:45 +08:00 · 2026-04-28 22:23:49 +08:00 · 2026-04-28 21:59:15 +08:00 · 2026-04-28 21:40:41 +08:00 · 2026-04-28 21:34:43 +08:00
88 changed files with 9091 additions and 2414 deletions
@@ -14,6 +14,10 @@
 │           └── package.json
 ├── backend/                     # 后端相关 skill
 └── common/                      # 通用 skill
+    └── create-release/          # 创建 GitHub Release
+        ├── SKILL.md
+        └── scripts/
+            └── create-release.sh
 ```

 - **SKILL.md**：YAML frontmatter（`name`、`description` 必填，`name` 须与父文件夹名一致、小写连字符）+ 给 Agent 的详细指令。
@@ -27,7 +31,8 @@

 ## 示例

- `frontend/check-i18n-keys/SKILL.md` + `frontend/check-i18n-keys/scripts/` — 检查前端多语言 key。
+- `frontend/check-i18n-keys/SKILL.md` + `frontend/check-i18n-keys/scripts/` — 检查前端多语言 key
+- `common/create-release/SKILL.md` + `common/create-release/scripts/` — 创建 GitHub Release

 ## 运行 check-i18n-keys

@@ -37,3 +42,17 @@ npm install
 npm run check-i18n
 ```

+## 运行 create-release
+
+```bash
+cd .cursor/skills/common/create-release/scripts
+./create-release.sh -t v1.0.0 -T "Release v1.0.0" -d "发布说明"
+```
+
+参数说明：
+- `-t` 版本号（必需，格式 v1.0.0）
+- `-T` Release 标题
+- `-d` Release 描述
+- `-p` 标记为 Pre-release（自动加 -beta 后缀）
+- `-y` 无交互模式
+
@@ -0,0 +1,341 @@
+---
+name: create-release
+description: 创建 PolyHermes 项目的 GitHub Release。当用户要求发布版本、创建 release、打 tag 或发布新版本时使用。
+---
+
+# Create Release
+
+创建 PolyHermes 项目的 GitHub Release，包括创建 Git tag、推送 tag、创建 GitHub Release（支持 pre-release），并自动在 Issue #1 发布公告。
+
+## 使用时机
+
+- 用户要求「发布版本」「创建 release」「打 tag」「发布新版本」时
+- 用户要求「创建 pre-release」「beta 版本」时
+- 用户提到「v1.x.x」等版本号相关操作时
+
+## 前置条件
+
+1. **GitHub CLI 已安装**：确保 `gh` 命令可用
+2. **已登录 GitHub**：运行 `gh auth status` 确认
+3. **工作目录干净**：建议先提交所有更改
+
+## 指令
+
+### 步骤 1：收集发布信息
+
+询问用户以下信息：
+- 版本号（格式：vX.Y.Z，如 v1.0.0）
+- 是否为 Pre-release（测试版本）
+- Release 标题和描述（可选，如未提供则自动生成）
+
+### 步骤 2：生成 Release 内容
+
+**重要**：如果用户未提供描述，需要根据 Git commits 自动生成。
+
+1. **获取上一个版本的 tag**：
+   ```bash
+   git describe --tags --abbrev=0 HEAD
+   ```
+
+2. **获取版本间的 commits**：
+   ```bash
+   git log <PREVIOUS_TAG>..HEAD --oneline --no-merges
+   ```
+
+3. **过滤 commit 规则**：
+   - **排除**：版本内新增功能的修复 commit
+   - **判断方法**：如果一个 commit 的消息包含「fix」「修复」「bugfix」等关键词，且是针对同一版本内新增代码的修复，则不包含
+   - **保留**：新功能、性能优化、重构、文档更新等
+
+4. **生成中英文 Release 内容**：
+   - 格式要求：**中文在上，英文在下**
+   - 使用分隔线 `---` 分隔中英文部分
+   - 按功能类型分组（新功能、改进、修复等）
+
+   示例格式：
+   ```markdown
+   ## 新功能
+
+   - 添加了 A 功能
+   - 支持了 B 操作
+
+   ## 改进
+
+   - 优化了 C 性能
+
+   ---
+
+   ## New Features
+
+   - Added feature A
+   - Supported operation B
+
+   ## Improvements
+
+   - Optimized performance C
+   ```
+
+### 步骤 3：运行发布脚本
+
+在项目根目录下执行：
+
+```bash
+cd .cursor/skills/common/create-release/scripts && \
+chmod +x create-release.sh && \
+./create-release.sh -t <VERSION> [-T "<TITLE>"] [-d "<DESCRIPTION>"] [-p] [-y]
+```
+
+### 步骤 4：发布公告到 Issue #1
+
+**重要**：Release 创建成功后，必须自动在 Issue #1 下发布公告 comment。
+
+1. **生成公告内容**（面向用户，通俗易懂）：
+
+   公告格式模板：
+   ```markdown
+   # 🎉 PolyHermes vX.X.X 版本发布公告
+
+   ## 📅 发布日期
+
+   YYYY年MM月DD日
+
+   ---
+
+   ## ✨ 本次更新亮点
+
+   ### 🚀 新功能
+
+   **功能名称**
+   - 用通俗的语言描述这个功能是什么
+   - 用户能从中获得什么好处
+   - 如何使用这个功能
+
+   ### 🔧 改进优化
+
+   - 优化了 XXX，现在 XXX 更快/更稳定了
+   - 改进了 XXX 体验，操作更简单了
+
+   ### 🐛 问题修复
+
+   - 修复了 XXX 问题，不再出现 XXX 情况
+
+   ---
+
+   ## 📦 如何更新
+
+   ### Docker 部署（推荐）
+
+   ```bash
+   # 拉取最新镜像
+   docker pull wrbug/polyhermes:vX.X.X
+
+   # 重启服务
+   docker-compose -f docker-compose.prod.yml down
+   docker-compose -f docker-compose.prod.yml up -d
+   ```
+
+   ---
+
+   ## ⚠️ 安全提醒
+
+   **请务必使用官方 Docker 镜像源，避免财产损失！**
+
+   **官方镜像地址**：`wrbug/polyhermes`
+
+   ---
+
+   ## 📚 相关链接
+
+   - **GitHub Release**: https://github.com/WrBug/PolyHermes/releases/tag/vX.X.X
+   - **Docker Hub**: https://hub.docker.com/r/wrbug/polyhermes
+   ```
+
+2. **公告内容编写原则**：
+
+   - ✅ **通俗易懂**：避免技术术语，用用户能理解的语言
+   - ✅ **突出价值**：告诉用户这个更新对他们有什么好处
+   - ✅ **简洁明了**：每个功能点用 1-2 句话说明
+   - ✅ **包含操作指引**：告诉用户如何使用新功能
+   - ✅ **中英文双语**：中文在上，英文在下（可选）
+   - ❌ **避免**：commit hash、代码细节、内部实现
+
+3. **执行发布公告命令**：
+
+   ```bash
+   gh issue comment 1 --repo WrBug/PolyHermes --body "$(cat <<'EOF'
+   # 🎉 PolyHermes vX.X.X 版本发布公告
+
+   [公告内容...]
+
+   ---
+   EOF
+   )"
+   ```
+
+   或使用文件方式（内容较长时推荐）：
+
+   ```bash
+   echo "[公告内容...]" > /tmp/announcement.md
+   gh issue comment 1 --repo WrBug/PolyHermes --body-file /tmp/announcement.md
+   ```
+
+### 参数说明
+
+| 参数 | 说明 | 示例 |
+|------|------|------|
+| `-t, --tag` | 版本号（必需） | `-t v1.0.0` |
+| `-T, --title` | Release 标题 | `-T "Release v1.0.0"` |
+| `-d, --description` | Release 描述 | `-d "## 新功能\n- 功能1"` |
+| `-f, --description-file` | 从文件读取描述 | `-f CHANGELOG.md` |
+| `-p, --prerelease` | 标记为 Pre-release（自动加 -beta 后缀） | `-p` |
+| `-y, --yes` | 无交互模式 | `-y` |
+
+## 版本号格式
+
+- 必须格式：`v数字.数字.数字`（如 v1.0.0, v1.10.2, v1.1.12）
+- 如果指定 `--prerelease`，会自动拼接 `-beta` 后缀（如 v1.0.1 → v1.0.1-beta）
+
+## Release 内容生成规则
+
+### 中英文格式
+
+Release 描述**必须**使用中英文双语格式：
+
+```markdown
+## 中文标题
+
+- 内容项1
+- 内容项2
+
+---
+
+## English Title
+
+- Item 1
+- Item 2
+```
+
+### Commit 过滤规则
+
+**需要排除的 commit 类型**：
+
+1. **版本内修复**：对同一版本新增功能的后续修复
+   - 例如：v1.0.1 新增了功能 A，然后有一个 commit 修复功能 A 的 bug → 不包含
+   - 判断依据：commit 消息包含「fix」「修复」「bugfix」且相关功能在本版本新增
+
+2. **琐碎修改**：
+   - typo 修正
+   - 代码格式调整
+   - 注释更新
+
+**需要保留的 commit 类型**：
+
+1. 新功能（feat、feature）
+2. 改进/优化（improve、optimize、enhance）
+3. 重要 bug 修复（针对旧版本的 bug）
+4. 重构（refactor）
+5. 文档更新（docs）
+
+### 分组建议
+
+- **新功能 / New Features**
+- **改进 / Improvements**
+- **修复 / Bug Fixes**（仅包含对旧版本 bug 的修复）
+- **其他 / Others**
+
+## 公告内容示例
+
+以下是一个面向用户的公告示例：
+
+```markdown
+# 🎉 PolyHermes v1.2.0 版本发布公告
+
+## 📅 发布日期
+
+2026年3月2日
+
+---
+
+## ✨ 本次更新亮点
+
+### 🚀 新功能
+
+**系统自动更新**
+- 现在可以在网页上直接更新系统，无需手动重启 Docker
+- 更新过程约 30-60 秒，系统会自动处理
+- 如果更新失败，系统会自动恢复到旧版本
+
+**RPC 节点管理**
+- 可以在系统设置中添加、编辑、删除自定义 RPC 节点
+- 可以随时启用或禁用节点
+- 系统会自动选择可用的节点
+
+### 🔧 改进优化
+
+- **更快的跟单响应**：通过实时监听链上交易，跟单速度提升到秒级
+- **更准确的盈亏统计**：系统会自动追踪实际成交价，统计数据更准确
+- **内存占用优化**：修复了内存泄漏问题，系统可以长时间稳定运行
+
+### 🐛 问题修复
+
+- 修复了部分市场无法正确查询价格的问题
+- 修复了卖出订单偶发失败的问题
+
+---
+
+## 📦 如何更新
+
+### 方式一：网页更新（推荐）
+
+1. 登录系统，进入 **系统设置** → **系统更新**
+2. 点击 **检查更新**
+3. 如果有新版本，点击 **立即升级**
+4. 等待更新完成即可
+
+### 方式二：Docker 更新
+
+```bash
+docker pull wrbug/polyhermes:v1.2.0
+docker-compose -f docker-compose.prod.yml down
+docker-compose -f docker-compose.prod.yml up -d
+```
+
+---
+
+## ⚠️ 安全提醒
+
+**请务必使用官方 Docker 镜像源！**
+
+官方镜像：`wrbug/polyhermes`
+
+---
+
+## 📚 相关链接
+
+- **GitHub Release**: https://github.com/WrBug/PolyHermes/releases/tag/v1.2.0
+- **Docker Hub**: https://hub.docker.com/r/wrbug/polyhermes
+```
+
+## 发布流程
+
+1. 验证版本号格式
+2. 检查 Git 工作目录状态
+3. 检查 tag 是否已存在
+4. 生成 Release 内容（中英文）
+5. 创建本地 tag
+6. 推送 tag 到远程
+7. 创建 GitHub Release
+8. **生成面向用户的公告内容**
+9. **发布公告到 Issue #1**
+10. 返回 Release URL 和公告链接
+
+## 注意事项
+
+- Pre-release 版本不会触发 Telegram 通知
+- GitHub Actions 会自动触发构建流程
+- 如果 tag 已存在，会提示是否删除并重新创建
+- **必须**在 Release 创建成功后发布公告到 Issue #1
+
+## 可选目录说明
+
+- `scripts/`：包含 `create-release.sh` 发布脚本
@@ -346,4 +346,3 @@ main() {

 # 执行主函数
 main "$@"
-
@@ -0,0 +1,201 @@
+---
+name: 🤖 Bug Report for AI Fix / AI Bug 报告
+description: Bug 报告模板（提交后请手动添加 'fix via ai' 标签触发自动修复）
+title: '[Bug] / '
+assignees: []
+body:
+  - type: markdown
+    attributes:
+      value: |
+        ## Bug Report Template 🐛
+
+        本模板用于报告 PolyHermes 项目的 bug。
+
+        ⚠️ **Important / 重要提示**：
+        - After submission, if you need AI auto-fix, please manually add the `fix via ai` label
+          / 提交后，如需 AI 自动修复，请手动添加 `fix via ai` 标签
+        - AI fixes will be on the `fix_issues_by_ai` branch / AI 修复将在 `fix_issues_by_ai` 分支上进行
+        - All AI fixes require human review before merging / 所有 AI 修复需要人工审核后才能合并
+        - Security vulnerabilities, database migrations, major changes are not recommended for AI auto-fix
+          / 涉及安全漏洞、数据库迁移、重大变更等问题不建议使用 AI 自动修复
+
+        ---
+        
+        本模板用于报告 PolyHermes 项目的 bug。
+
+        This template is for reporting bugs in the PolyHermes project.
+
+  - type: textarea
+    id: description
+    attributes:
+      label: 📝 Bug Description / Bug 描述
+      description: Clearly and concisely describe the bug / 清晰简洁地描述这个 bug
+      placeholder: Describe the bug you encountered / 描述你遇到的问题...
+    validations:
+      required: true
+
+  - type: dropdown
+    id: type
+    attributes:
+      label: 🎯 Bug Type / 问题类型
+      description: Select the type of bug / 选择问题类型
+      options:
+        - Frontend bug (UI/UX/interaction) / 前端 bug (UI/UX/交互问题)
+        - Backend bug (API/logic/data) / 后端 bug (API/逻辑/数据处理)
+        - Database issue / 数据库问题
+        - Performance issue / 性能问题
+        - Configuration/Deployment / 配置/部署问题
+        - Documentation / 文档问题
+        - Other / 其他
+    validations:
+      required: true
+
+  - type: dropdown
+    id: scope
+    attributes:
+      label: 📍 Affected Scope / 影响范围
+      description: Select the scope of impact / 选择问题影响范围
+      options:
+        - Specific page/function only / 仅影响特定页面/功能
+        - Entire system / 影响整个系统
+        - Specific user role / 影响特定用户角色
+        - Only in specific environment / 仅在特定环境下重现
+    validations:
+      required: true
+
+  - type: textarea
+    id: steps
+    attributes:
+      label: 🔍 Steps to Reproduce / 复现步骤
+      description: Provide clear, detailed steps to reproduce the bug / 提供清晰、详细的步骤来重现这个 bug
+      placeholder: |
+        1. Visit page: `...` / 访问页面：`...`
+        2. Click button: `...` / 点击按钮：`...`
+        3. Input data: `...` / 输入数据：`...`
+        4. Submit form: `...` / 提交表单：`...`
+        5. Observe error: `...` / 观察到错误：`...`
+    validations:
+      required: true
+
+  - type: dropdown
+    id: frequency
+    attributes:
+      label: Reproduction Frequency / 复现频率
+      options:
+        - Always reproducible (100%) / 总是能复现 (100%)
+        - Frequently reproducible (50%+) / 经常能复现 (50%+)
+        - Occasionally reproducible (<50%) / 偶尔能复现 (<50%)
+        - Hard to reproduce / 很难复现
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: 💻 Expected Behavior / 预期行为
+      description: Describe what you expected to happen / 描述你期望发生什么
+      placeholder: What should happen / 应该发生什么...
+    validations:
+      required: true
+
+  - type: textarea
+    id: actual
+    attributes:
+      label: ❌ Actual Behavior / 实际行为
+      description: Describe what actually happened / 描述实际发生了什么
+      placeholder: What actually happened / 实际发生了什么...
+    validations:
+      required: true
+
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: 📸 Screenshots / Recordings / 截图/录屏
+      description: If applicable, add screenshots or recordings to illustrate the problem (drag and drop files here)
+        / 如果适用，添加截图或录屏来说明问题（可以拖拽文件到这里）
+      placeholder: Add screenshots or recordings / 添加截图或录屏...
+
+  - type: textarea
+    id: environment
+    attributes:
+      label: 🌐 Environment / 环境
+      description: Provide relevant environment information / 提供相关环境信息
+      value: |
+        **Browser (for frontend issues) / 浏览器（前端问题）：**
+        - Browser: ______ / 浏览器：______
+        - Browser version: ______ / 浏览器版本：______
+        - Operating System: ______ / 操作系统：______
+
+        **Backend Environment (for backend issues) / 后端环境（后端问题）：**
+        - Node.js version: ______ / Node.js 版本：______
+        - Database version: ______ / 数据库版本：______
+        - Docker version (if used): ______ / Docker 版本（如果使用）：______
+        - Other relevant dependencies: ______ / 其他相关依赖版本：______
+    validations:
+      required: false
+
+  - type: textarea
+    id: related-files
+    attributes:
+      label: 📁 Related Files / Code / 相关文件/代码
+      description: Provide relevant file paths or code snippets / 提供可能涉及的文件路径或相关代码片段
+      placeholder: |
+        Possibly related files / 可能涉及的文件：
+        - frontend/src/components/...
+        - backend/src/main/kotlin/...
+
+        Error logs / 错误日志：
+        ```
+        Paste error logs here / 粘贴错误日志
+        ```
+    validations:
+      required: false
+
+  - type: textarea
+    id: suggestions
+    attributes:
+      label: 🎯 Fix Suggestions (Optional) / 修复建议（可选）
+      description: If you have fix ideas, describe them briefly / 如果你有修复思路，可以在这里简单描述
+      placeholder: |
+        Suggest adding ZZZ check in the YYY method of file XXX
+        / 建议在 XXX 文件的 YYY 方法中，添加 ZZZ 检查
+        ...
+
+  - type: dropdown
+    id: priority
+    attributes:
+      label: 🚨 Priority / 优先级
+      options:
+        - 🔴 High - Blocking core functionality, affects user experience / 高 - 阻塞核心功能，影响用户体验
+        - 🟡 Medium - Limited functionality but not blocking / 中 - 功能受限但不阻塞
+        - 🟢 Low - Minor issue, doesn't affect usage / 低 - 小问题，不影响使用
+    validations:
+      required: true
+
+  - type: textarea
+    id: additional
+    attributes:
+      label: 📝 Additional Information / 补充说明
+      description: Any other information that helps AI understand and fix the issue / 任何其他有助于 AI 理解和修复问题的信息
+      placeholder: |
+        - Was this bug introduced recently? / 这个 bug 是最近引入的吗？
+        - Is it related to a specific PR or commit? / 是否与某个特定的 PR 或 commit 相关？
+        - Does it only occur with specific datasets or users? / 是否只在特定数据集或特定用户情况下出现？
+        / ...
+        Any other context / 其他任何上下文信息...
+
+  - type: checkboxes
+    id: ai-fix-approval
+    attributes:
+      label: 🤖 AI Auto-Fix Confirmation / AI 自动修复确认
+      description: If you need AI to auto-fix this issue, check the options below (remember to add 'fix via ai' label after submission)
+        / 如需 AI 自动修复此 issue，请勾选下方选项（提交后记得添加 'fix via ai' 标签）
+      options:
+        - label: |
+            I understand the AI auto-fix workflow and agree to manually review the AI-created PR
+            / 我已了解 AI 自动修复的工作流程，并同意在 AI 创建 PR 后进行人工审核
+          required: false
+        - label: |
+            This issue is suitable for AI auto-fix (not a security vulnerability, not a database migration, not a major change)
+            / 此问题适合 AI 自动修复（非安全漏洞、非数据库迁移、非重大变更）
+          required: false
@@ -0,0 +1,127 @@
+# PR 合并后自动关闭关联的 Issue
+# 当 PR 从 ai_fix/N_xxx 分支合并到 main 时，关闭 #N 对应的 Issue（若 PR 描述中未含 Closes #N 则通过分支名解析）
+# 关闭后发送 Telegram 通知（复用 TELEGRAM_BOT_TOKEN / TELEGRAM_CHAT_ID）
+
+name: Close issue on PR merge
+
+on:
+  pull_request:
+    types: [closed]
+    branches: [main]
+
+jobs:
+  close-issue:
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    permissions:
+      issues: write
+      pull-requests: read
+
+    steps:
+      - name: Get PR info
+        id: pr
+        run: |
+          # 从 PR body 查找 Closes #N / Fixes #N（若已有则 GitHub 已自动关 issue，本 step 仅做解析）
+          BODY="${{ github.event.pull_request.body }}"
+          HEAD_REF="${{ github.event.pull_request.head.ref }}"
+
+          # 优先从 PR 描述解析（无匹配时 grep 会 exit 1，需 || true 避免 set -e 导致脚本退出）
+          ISSUE_NUM=$(echo "$BODY" | grep -oE '(Closes|Fixes|Resolves) #([0-9]+)' | head -1 | grep -oE '[0-9]+' || true)
+          if [ -z "$ISSUE_NUM" ]; then
+            # 从分支名解析 ai_fix/N_xxx
+            ISSUE_NUM=$(echo "$HEAD_REF" | sed -n 's|^ai_fix/\([0-9]*\)_.*|\1|p')
+          fi
+
+          if [ -z "$ISSUE_NUM" ]; then
+            echo "ISSUE_NUMBER=" >> $GITHUB_OUTPUT
+            echo "skip=true" >> $GITHUB_OUTPUT
+            echo "未从 PR 描述或分支名解析到 Issue 编号，跳过关闭"
+            exit 0
+          fi
+
+          echo "ISSUE_NUMBER=$ISSUE_NUM" >> $GITHUB_OUTPUT
+          echo "skip=false" >> $GITHUB_OUTPUT
+          echo "解析到 Issue #$ISSUE_NUM"
+
+      - name: Get issue details
+        if: steps.pr.outputs.skip != 'true'
+        id: issue
+        env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+        run: |
+          ISSUE_NUM="${{ steps.pr.outputs.ISSUE_NUMBER }}"
+          # 获取 issue 标题与 URL（用于 TG 消息）
+          JSON=$(gh issue view "$ISSUE_NUM" --json title,url 2>/dev/null || echo '{"title":"","url":""}')
+          TITLE=$(echo "$JSON" | jq -r '.title')
+          ISSUE_URL=$(echo "$JSON" | jq -r '.url')
+          echo "title<<EOF" >> $GITHUB_OUTPUT
+          echo "$TITLE" >> $GITHUB_OUTPUT
+          echo "EOF" >> $GITHUB_OUTPUT
+          echo "url=$ISSUE_URL" >> $GITHUB_OUTPUT
+
+      - name: Close issue
+        if: steps.pr.outputs.skip != 'true'
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const issueNumber = parseInt('${{ steps.pr.outputs.ISSUE_NUMBER }}', 10);
+            if (!issueNumber || isNaN(issueNumber)) {
+              console.log('No valid issue number, skip');
+              return;
+            }
+            const { data: issue } = await github.rest.issues.get({
+              owner: context.repo.owner,
+              repo: context.repo.repo,
+              issue_number: issueNumber
+            });
+            if (issue.state === 'open') {
+              await github.rest.issues.update({
+                owner: context.repo.owner,
+                repo: context.repo.repo,
+                issue_number: issueNumber,
+                state: 'closed'
+              });
+              console.log(`Issue #${issueNumber} closed.`);
+            } else {
+              console.log(`Issue #${issueNumber} already closed.`);
+            }
+
+      - name: Send Telegram notification
+        if: steps.pr.outputs.skip != 'true'
+        env:
+          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
+          TELEGRAM_CHAT_ID: ${{ secrets.TELEGRAM_CHAT_ID }}
+        run: |
+          # 与 docker-build 一致：未配置则跳过
+          if [ -z "$TELEGRAM_BOT_TOKEN" ] || [ -z "$TELEGRAM_CHAT_ID" ]; then
+            echo "⚠️  Telegram Bot Token 或 Chat ID 未配置，跳过通知"
+            exit 0
+          fi
+
+          ISSUE_NUM="${{ steps.pr.outputs.ISSUE_NUMBER }}"
+          ISSUE_TITLE="${{ steps.issue.outputs.title }}"
+          ISSUE_URL="${{ steps.issue.outputs.url }}"
+          PR_URL="${{ github.event.pull_request.html_url }}"
+
+          # 与 docker-build 相同的 HTML 消息格式
+          MESSAGE="✅ <b>AI 修复的 Issue 已关闭</b>"$'\n'$'\n'"🔢 <b>Issue:</b> #${ISSUE_NUM} ${ISSUE_TITLE}"$'\n'"📎 <a href=\"${ISSUE_URL}\">查看 Issue</a>"$'\n'"🔗 <a href=\"${PR_URL}\">查看 PR</a>"
+
+          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 0
+            fi
+          else
+            echo "❌ 发送 Telegram 消息时发生错误"
+            exit 0
+          fi
@@ -6,14 +6,6 @@ on:
      - published  # 当通过 GitHub Releases 页面创建 release 时触发
  workflow_dispatch:
    inputs:
-      build_type:
-        description: '构建类型'
-        required: true
-        type: choice
-        options:
-          - package-only        # 只打包产物
-          - package-and-docker # 打包产物 + Docker 镜像
-        default: 'package-and-docker'
      version:
        description: '版本号（例如: v1.0.0）'
        required: false
@@ -36,22 +28,6 @@ jobs:
        with:
          ref: ${{ github.event.release.tag_name || github.event.inputs.tag_name || github.event.inputs.version || github.ref }}
      
-      - name: Determine build type
-        id: build_config
-        run: |
-          # 确定构建类型
-          if [ "${{ github.event_name }}" = "release" ]; then
-            # Release 事件：默认只打包产物（不构建 Docker）
-            BUILD_TYPE="package-only"
-            echo "📦 Release 事件：将只打包产物（不构建 Docker）"
-          else
-            # workflow_dispatch 事件：使用用户输入
-            BUILD_TYPE="${{ github.event.inputs.build_type }}"
-            echo "🔧 手动触发：构建类型 = ${BUILD_TYPE}"
-          fi
-          
-          echo "BUILD_TYPE=${BUILD_TYPE}" >> $GITHUB_OUTPUT
-      
      - name: Extract version and check if pre-release
        id: extract_version
        run: |
@@ -100,53 +76,6 @@ jobs:
            echo "📦 这是正式版本: $TAG_NAME"
          fi
      
-      - name: Send Telegram notification (build started)
-        if: steps.extract_version.outputs.IS_PRERELEASE == 'false' && steps.build_config.outputs.BUILD_TYPE == 'package-and-docker'
-        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
-          
-          # 获取构建信息
-          TAG="${{ steps.extract_version.outputs.TAG }}"
-          
-          if [ "${{ github.event_name }}" = "release" ]; then
-            RELEASE_URL="${{ github.event.release.html_url }}"
-            MESSAGE="🔨 <b>Release 构建中</b>"$'\n'$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔧 <b>构建类型:</b> Docker 升级"$'\n'"🔗 <a href=\"${RELEASE_URL}\">查看 Release</a>"
-          else
-            WORKFLOW_URL="https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}"
-            MESSAGE="🔨 <b>构建中</b>"$'\n'$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔧 <b>构建类型:</b> Docker 升级"$'\n'"🔗 <a href=\"${WORKFLOW_URL}\">查看 Workflow</a>"
-          fi
-          
-          # 发送 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: Setup JDK 17
        uses: actions/setup-java@v4
@@ -263,22 +192,66 @@ jobs:
            checksums.txt
          retention-days: 30
      
+      # ============ 发送产物上传成功通知 ============
+      - name: Send Telegram notification (package uploaded)
+        if: steps.extract_version.outputs.IS_PRERELEASE == 'false'
+        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
+          
+          # 获取构建信息
+          TAG="${{ steps.extract_version.outputs.TAG }}"
+          
+          if [ "${{ github.event_name }}" = "release" ]; then
+            RELEASE_URL="${{ github.event.release.html_url }}"
+            MESSAGE="✅ <b>PolyHermes Package Built</b>"$'\n'$'\n'"🏷️ <b>Version:</b> <code>${TAG}</code>"$'\n'"🔧 <b>Type:</b> Online Update"$'\n'"🔗 <a href=\"${RELEASE_URL}\">View Release</a>"$'\n'"📍 <b>Update Path:</b> System Management → Overview → Check for Updates"$'\n'$'\n'"🐳 Building Docker image..."
+          else
+            WORKFLOW_URL="https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}"
+            MESSAGE="✅ <b>PolyHermes Package Built</b>"$'\n'$'\n'"🏷️ <b>Version:</b> <code>${TAG}</code>"$'\n'"🔧 <b>Type:</b> Online Update"$'\n'"🔗 <a href=\"${WORKFLOW_URL}\">View Workflow</a>"$'\n'$'\n'"🐳 Building Docker image..."
+          fi
+          
+          # 发送 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 0
+            fi
+          else
+            echo "❌ 发送 Telegram 消息时发生错误"
+            exit 0
+          fi
+      
+      # ============ Docker 构建 ============
      - name: Set up Docker Buildx
-        if: steps.build_config.outputs.BUILD_TYPE == 'package-and-docker'
        uses: docker/setup-buildx-action@v3
        with:
          # 启用多架构构建支持
          platforms: linux/amd64,linux/arm64
      
      - name: Log in to Docker Hub
-        if: steps.build_config.outputs.BUILD_TYPE == 'package-and-docker'
        uses: docker/login-action@v3
        with:
          username: ${{ secrets.DOCKER_USERNAME }}
          password: ${{ secrets.DOCKER_PASSWORD }}
      
      - name: Prepare Docker build context
-        if: steps.build_config.outputs.BUILD_TYPE == 'package-and-docker'
        run: |
          echo "📦 准备 Docker 构建上下文..."
          # 确保构建产物存在且可访问
@@ -295,7 +268,7 @@ jobs:
          ls -lh backend/build/libs/*.jar
      
      - name: Build and push Docker image
-        if: steps.build_config.outputs.BUILD_TYPE == 'package-and-docker'
+        id: docker_build
        uses: docker/build-push-action@v5
        with:
          context: .
@@ -314,13 +287,8 @@ jobs:
          cache-from: type=registry,ref=wrbug/polyhermes:latest
          cache-to: type=inline
      
-      - name: Skip Docker build notice
-        if: steps.build_config.outputs.BUILD_TYPE == 'package-only'
-        run: |
-          echo "⏭️  跳过 Docker 镜像构建（构建类型：package-only）"
-          echo "✅ 仅打包产物已完成"
-
-      - name: Send Telegram notification
+      # ============ 发送 Docker 构建成功通知 ============
+      - name: Send Telegram notification (Docker build completed)
        if: steps.extract_version.outputs.IS_PRERELEASE == 'false'
        env:
          TELEGRAM_BOT_TOKEN: ${{ secrets.TELEGRAM_BOT_TOKEN }}
@@ -335,25 +303,14 @@ jobs:
          # 获取构建信息
          VERSION="${{ steps.extract_version.outputs.VERSION }}"
          TAG="${{ steps.extract_version.outputs.TAG }}"
-          BUILD_TYPE="${{ steps.build_config.outputs.BUILD_TYPE }}"
-          
-          # 构建消息内容（仅包含关键信息）
          DEPLOY_DOC_URL="https://github.com/WrBug/PolyHermes/blob/main/docs/zh/DEPLOYMENT.md"
          
          if [ "${{ github.event_name }}" = "release" ]; then
            RELEASE_URL="${{ github.event.release.html_url }}"
-            if [ "$BUILD_TYPE" = "package-and-docker" ]; then
-              MESSAGE="✅ <b>Release 构建成功</b>"$'\n'$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔧 <b>构建类型:</b> Docker 升级"$'\n'"🔗 <a href=\"${RELEASE_URL}\">查看 Release</a>"$'\n'"📚 <a href=\"${DEPLOY_DOC_URL}\">Docker 部署文档</a>"
-            else
-              MESSAGE="✅ <b>Release 打包成功</b>"$'\n'$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔧 <b>构建类型:</b> 在线升级"$'\n'"🔗 <a href=\"${RELEASE_URL}\">查看 Release</a>"$'\n'"📍 <b>升级路径:</b> 系统管理 → 概览 → 检查更新"
-            fi
+            MESSAGE="🐳 <b>Docker Image Built Successfully</b>"$'\n'$'\n'"🏷️ <b>Version:</b> <code>${TAG}</code>"$'\n'"📦 <b>Image:</b> <code>wrbug/polyhermes:${TAG}</code>"$'\n'"🔗 <a href=\"${RELEASE_URL}\">View Release</a>"$'\n'"📚 <a href=\"${DEPLOY_DOC_URL}\">Docker Deployment Guide</a>"
          else
            WORKFLOW_URL="https://github.com/${{ github.repository }}/actions/runs/${{ github.run_id }}"
-            if [ "$BUILD_TYPE" = "package-and-docker" ]; then
-              MESSAGE="✅ <b>构建成功</b>"$'\n'$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔧 <b>构建类型:</b> Docker 升级"$'\n'"🔗 <a href=\"${WORKFLOW_URL}\">查看 Workflow</a>"$'\n'"📚 <a href=\"${DEPLOY_DOC_URL}\">Docker 部署文档</a>"
-            else
-              MESSAGE="✅ <b>打包成功</b>"$'\n'$'\n'"🏷️ <b>Tag:</b> <code>${TAG}</code>"$'\n'"🔧 <b>构建类型:</b> 在线升级"$'\n'"🔗 <a href=\"${WORKFLOW_URL}\">查看 Workflow</a>"$'\n'"📍 <b>升级路径:</b> 系统管理 → 概览 → 检查更新"
-            fi
+            MESSAGE="🐳 <b>Docker Image Built Successfully</b>"$'\n'$'\n'"🏷️ <b>Version:</b> <code>${TAG}</code>"$'\n'"📦 <b>Image:</b> <code>wrbug/polyhermes:${TAG}</code>"$'\n'"🔗 <a href=\"${WORKFLOW_URL}\">View Workflow</a>"$'\n'"📚 <a href=\"${DEPLOY_DOC_URL}\">Docker Deployment Guide</a>"
          fi
          
          # 发送 Telegram 消息（使用 jq 转义 JSON）
@@ -371,11 +328,9 @@ jobs:
              echo "✅ Telegram 通知发送成功"
            else
              echo "❌ Telegram 通知发送失败: $RESPONSE"
-              # 构建成功，通知失败不应该导致整个 job 失败
              exit 0
            fi
          else
            echo "❌ 发送 Telegram 消息时发生错误"
-            # 构建成功，通知失败不应该导致整个 job 失败
            exit 0
-          fi
+          fi
@@ -112,4 +112,5 @@ __pycache__/
 clob-client/
 builder-relayer-client/
 landing-page/
-
+clob-client-v2/
+settings.local.json
@@ -73,7 +73,7 @@ interface PolymarketClobApi {
     */
    @POST("/orders/batch")
    suspend fun createOrdersBatch(
-        @Body request: CreateOrdersBatchRequest
+        @Body request: List<NewOrderRequest>
    ): Response<List<OrderResponse>>
    
    /**
@@ -174,22 +174,25 @@ interface PolymarketClobApi {
 // 请求和响应数据类

 /**
- * 签名的订单对象（根据官方文档）
- * 参考: https://docs.polymarket.com/developers/CLOB/orders/create-order
+ * V2 签名的订单对象
+ * EIP-712 签名字段: salt, maker, signer, tokenId, makerAmount, takerAmount, side, signatureType, timestamp, metadata, builder
+ * API payload 额外字段: taker, expiration (不在 EIP-712 签名中，但 API 请求需要)
+ * 参考: clob-client-v2/src/types/ordersV2.ts NewOrderV2
 */
 data class SignedOrderObject(
    val salt: Long,                    // random salt used to create unique order
    val maker: String,                  // maker address (funder)
    val signer: String,                 // signing address
-    val taker: String,                  // taker address (operator)
+    val taker: String,                  // taker address (zero address for public orders, NOT in EIP-712 signing)
    val tokenId: String,                // ERC1155 token ID of conditional token being traded
    val makerAmount: String,            // maximum amount maker is willing to spend
    val takerAmount: String,            // minimum amount taker will pay the maker in return
-    val expiration: String,             // unix expiration timestamp
-    val nonce: String,                  // maker's exchange nonce of the order is associated
-    val feeRateBps: String,             // fee rate basis points as required by the operator
    val side: String,                   // buy or sell enum index ("BUY" or "SELL")
    val signatureType: Int,             // signature type enum index
+    val timestamp: String,              // order creation time in milliseconds (V2)
+    val expiration: String,             // expiration timestamp unix seconds, "0" = no expiration (NOT in EIP-712 signing)
+    val metadata: String,               // bytes32 metadata (V2)
+    val builder: String,                // bytes32 builder code (V2)
    val signature: String               // hex encoded signature
 )

@@ -198,10 +201,11 @@ data class SignedOrderObject(
 * 参考: https://docs.polymarket.com/developers/CLOB/orders/create-order
 */
 data class NewOrderRequest(
-    val order: SignedOrderObject,       // signed object
+    val order: SignedOrderObject,       // V2 signed object
    val owner: String,                  // api key of order owner
    val orderType: String,              // order type ("FOK", "GTC", "GTD", "FAK")
-    val deferExec: Boolean = false      // defer execution flag
+    val deferExec: Boolean = false,     // defer execution
+    val postOnly: Boolean = false       // post only (maker-only)
 )

 /**
@@ -212,6 +216,7 @@ data class NewOrderResponse(
    val success: Boolean,               // boolean indicating if server-side error
    @SerializedName("errorMsg")
    val errorMsg: String? = null,       // error message in case of unsuccessful placement
+    val error: String? = null,          // error message (alternative field, e.g. "Trading restricted in your region...")
    @SerializedName("orderID")
    val orderId: String? = null,        // id of order（API 返回字段名为 orderID）
    @SerializedName("transactionsHashes")
@@ -222,27 +227,17 @@ data class NewOrderResponse(
    val takingAmount: String? = null,   // taking amount
    @SerializedName("makingAmount")
    val makingAmount: String? = null    // making amount
-)
-
-/**
- * 旧的订单请求格式（已废弃，保留用于兼容）
- * @deprecated 使用 NewOrderRequest 代替
- */
-@Deprecated("使用 NewOrderRequest 代替，需要签名的订单对象")
-data class CreateOrderRequest(
-    val market: String? = null,      // condition ID（可选，如果提供tokenId则不需要）
-    val token_id: String? = null,    // token ID（可选，如果提供market则不需要）
-    val side: String,                // "BUY" or "SELL"
-    val price: String,
-    val size: String,
-    val type: String = "LIMIT",
-    val expiration: Long? = null
-)
-
-@Deprecated("使用 NewOrderRequest 代替")
-data class CreateOrdersBatchRequest(
-    val orders: List<NewOrderRequest>
-)
+) {
+    /**
+     * 获取错误信息的便捷方法
+     * 优先返回 errorMsg，其次返回 error，最后返回默认消息
+     */
+    fun getErrorMessage(): String {
+        return errorMsg?.takeIf { it.isNotBlank() }
+            ?: error?.takeIf { it.isNotBlank() }
+            ?: "创建订单失败"
+    }
+}

 data class CancelOrdersBatchRequest(
    val orderIds: List<String>
@@ -572,5 +572,53 @@ class AccountController(
        }
    }

+    /**
+     * 将 USDC.e wrap 为 pUSD（V2 迁移）
+     */
+    @PostMapping("/wrap-to-pusd")
+    fun wrapToPusd(@RequestBody request: Map<String, Any>): ResponseEntity<ApiResponse<Map<String, String?>>> {
+        return try {
+            val accountId = (request["accountId"] as? Number)?.toLong()
+                ?: return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ACCOUNT_ID_INVALID, messageSource = messageSource))
+            val result = runBlocking { accountService.wrapUsdcToPusd(accountId) }
+            result.fold(
+                onSuccess = { txHash ->
+                    ResponseEntity.ok(ApiResponse.success(mapOf("transactionHash" to txHash)))
+                },
+                onFailure = { e ->
+                    logger.error("USDC.e → pUSD wrap 失败: ${e.message}", e)
+                    ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, e.message, messageSource))
+                }
+            )
+        } catch (e: Exception) {
+            logger.error("USDC.e → pUSD wrap 异常: ${e.message}", e)
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, e.message, messageSource))
+        }
+    }
+
+    /**
+     * 查询 USDC.e 余额（V2 迁移用）
+     */
+    @PostMapping("/usdce-balance")
+    fun getUsdceBalance(@RequestBody request: Map<String, Any>): ResponseEntity<ApiResponse<Map<String, String>>> {
+        return try {
+            val accountId = (request["accountId"] as? Number)?.toLong()
+                ?: return ResponseEntity.ok(ApiResponse.error(ErrorCode.PARAM_ACCOUNT_ID_INVALID, messageSource = messageSource))
+            val result = runBlocking { accountService.getUsdceBalance(accountId) }
+            result.fold(
+                onSuccess = { balance ->
+                    ResponseEntity.ok(ApiResponse.success(mapOf("balance" to balance.toPlainString())))
+                },
+                onFailure = { e ->
+                    logger.error("查询 USDC.e 余额失败: ${e.message}", e)
+                    ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, e.message, messageSource))
+                }
+            )
+        } catch (e: Exception) {
+            logger.error("查询 USDC.e 余额异常: ${e.message}", e)
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, e.message, messageSource))
+        }
+    }
+
 }

@@ -13,10 +13,15 @@ import com.wrbug.polymarketbot.dto.CryptoTailMarketOptionDto
 import com.wrbug.polymarketbot.dto.CryptoTailAutoMinSpreadResponse
 import com.wrbug.polymarketbot.dto.CryptoTailMonitorInitRequest
 import com.wrbug.polymarketbot.dto.CryptoTailMonitorInitResponse
+import com.wrbug.polymarketbot.dto.CryptoTailManualOrderRequest
+import com.wrbug.polymarketbot.dto.CryptoTailManualOrderResponse
+import com.wrbug.polymarketbot.dto.CryptoTailPnlCurveRequest
+import com.wrbug.polymarketbot.dto.CryptoTailPnlCurveResponse
 import com.wrbug.polymarketbot.enums.ErrorCode
 import com.wrbug.polymarketbot.service.binance.BinanceKlineAutoSpreadService
 import com.wrbug.polymarketbot.service.cryptotail.CryptoTailStrategyService
 import com.wrbug.polymarketbot.service.cryptotail.CryptoTailMonitorService
+import com.wrbug.polymarketbot.service.cryptotail.CryptoTailStrategyExecutionService
 import org.slf4j.LoggerFactory
 import org.springframework.context.MessageSource
 import org.springframework.http.ResponseEntity
@@ -24,12 +29,14 @@ import org.springframework.web.bind.annotation.PostMapping
 import org.springframework.web.bind.annotation.RequestBody
 import org.springframework.web.bind.annotation.RequestMapping
 import org.springframework.web.bind.annotation.RestController
+import kotlinx.coroutines.runBlocking

@RestController
@RequestMapping("/api/crypto-tail-strategy")
 class CryptoTailStrategyController(
    private val cryptoTailStrategyService: CryptoTailStrategyService,
    private val cryptoTailMonitorService: CryptoTailMonitorService,
+    private val cryptoTailStrategyExecutionService: CryptoTailStrategyExecutionService,
    private val binanceKlineAutoSpreadService: BinanceKlineAutoSpreadService,
    private val messageSource: MessageSource
 ) {
@@ -125,6 +132,26 @@ class CryptoTailStrategyController(
        }
    }

+    @PostMapping("/pnl-curve")
+    fun getPnlCurve(@RequestBody request: CryptoTailPnlCurveRequest): ResponseEntity<ApiResponse<CryptoTailPnlCurveResponse>> {
+        return try {
+            if (request.strategyId <= 0) {
+                return ResponseEntity.ok(ApiResponse.error(ErrorCode.CRYPTO_TAIL_STRATEGY_NOT_FOUND, messageSource = messageSource))
+            }
+            val result = cryptoTailStrategyService.getPnlCurve(request)
+            result.fold(
+                onSuccess = { ResponseEntity.ok(ApiResponse.success(it)) },
+                onFailure = { e ->
+                    logger.error("查询收益曲线失败: ${e.message}", e)
+                    ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_CRYPTO_TAIL_STRATEGY_TRIGGERS_FETCH_FAILED, e.message, messageSource))
+                }
+            )
+        } catch (e: Exception) {
+            logger.error("查询收益曲线异常: ${e.message}", e)
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_CRYPTO_TAIL_STRATEGY_TRIGGERS_FETCH_FAILED, e.message, messageSource))
+        }
+    }
+
    @PostMapping("/triggers")
    fun getTriggerRecords(@RequestBody request: CryptoTailStrategyTriggerListRequest): ResponseEntity<ApiResponse<CryptoTailStrategyTriggerListResponse>> {
        return try {
@@ -216,4 +243,41 @@ class CryptoTailStrategyController(
            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, e.message, messageSource))
        }
    }
+
+    /**
+     * 手动下单
+     * 用户主动触发下单，不检查任何条件，仅检查当前周期是否已下单
+     */
+    @PostMapping("/manual-order")
+    fun manualOrder(@RequestBody request: CryptoTailManualOrderRequest): ResponseEntity<ApiResponse<CryptoTailManualOrderResponse>> {
+        return runBlocking {
+            try {
+                if (request.strategyId <= 0) {
+                    return@runBlocking ResponseEntity.ok(
+                        ApiResponse.error(ErrorCode.CRYPTO_TAIL_STRATEGY_NOT_FOUND, messageSource = messageSource)
+                    )
+                }
+                val result = cryptoTailStrategyExecutionService.manualOrder(request)
+                result.fold(
+                    onSuccess = { ResponseEntity.ok(ApiResponse.success(it)) },
+                    onFailure = { e ->
+                        logger.error("手动下单失败: ${e.message}", e)
+                        val code = when (e.message) {
+                            "策略不存在" -> ErrorCode.CRYPTO_TAIL_STRATEGY_NOT_FOUND
+                            "当前周期已下单" -> ErrorCode.PARAM_ERROR
+                            "价格必须在 0~1 之间" -> ErrorCode.PARAM_ERROR
+                            "数量不能少于 1" -> ErrorCode.PARAM_ERROR
+                            "总金额不能少于 $1" -> ErrorCode.PARAM_ERROR
+                            "总金额超过策略配置的投入金额" -> ErrorCode.PARAM_ERROR
+                            else -> ErrorCode.SERVER_ERROR
+                        }
+                        ResponseEntity.ok(ApiResponse.error(code, e.message, messageSource))
+                    }
+                )
+            } catch (e: Exception) {
+                logger.error("手动下单异常: ${e.message}", e)
+                ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, e.message, messageSource))
+            }
+        }
+    }
 }
@@ -3,6 +3,7 @@ package com.wrbug.polymarketbot.controller.system
 import com.wrbug.polymarketbot.dto.*
 import com.wrbug.polymarketbot.enums.ErrorCode
 import com.wrbug.polymarketbot.service.system.NotificationConfigService
+import com.wrbug.polymarketbot.service.system.NotificationTemplateService
 import com.wrbug.polymarketbot.service.system.TelegramNotificationService
 import kotlinx.coroutines.runBlocking
 import org.slf4j.LoggerFactory
@@ -18,6 +19,7 @@ import org.springframework.web.bind.annotation.*
 class NotificationController(
    private val notificationConfigService: NotificationConfigService,
    private val telegramNotificationService: TelegramNotificationService,
+    private val notificationTemplateService: NotificationTemplateService,
    private val messageSource: MessageSource
 ) {
    
@@ -335,6 +337,155 @@ class NotificationController(
            ))
        }
    }
+
+    // ==================== 模板相关 API ====================
+
+    /**
+     * 获取所有模板类型
+     */
+    @PostMapping("/templates/types")
+    fun getTemplateTypes(): ResponseEntity<ApiResponse<List<TemplateTypeInfoDto>>> {
+        return try {
+            val types = notificationTemplateService.getTemplateTypes()
+            ResponseEntity.ok(ApiResponse.success(types))
+        } catch (e: Exception) {
+            logger.error("获取模板类型失败: ${e.message}", e)
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, messageSource = messageSource))
+        }
+    }
+
+    /**
+     * 获取所有模板
+     */
+    @PostMapping("/templates/list")
+    fun getTemplates(): ResponseEntity<ApiResponse<List<NotificationTemplateDto>>> {
+        return try {
+            val templates = notificationTemplateService.getAllTemplates()
+            ResponseEntity.ok(ApiResponse.success(templates))
+        } catch (e: Exception) {
+            logger.error("获取模板列表失败: ${e.message}", e)
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, messageSource = messageSource))
+        }
+    }
+
+    /**
+     * 获取单个模板
+     */
+    @PostMapping("/templates/detail")
+    fun getTemplateDetail(@RequestBody request: TemplateDetailRequest): ResponseEntity<ApiResponse<NotificationTemplateDto>> {
+        return try {
+            if (request.templateType.isBlank()) {
+                return ResponseEntity.ok(ApiResponse.paramError("模板类型不能为空"))
+            }
+
+            val template = notificationTemplateService.getTemplate(request.templateType)
+            if (template == null) {
+                ResponseEntity.ok(ApiResponse.error(ErrorCode.NOT_FOUND, messageSource = messageSource))
+            } else {
+                ResponseEntity.ok(ApiResponse.success(template))
+            }
+        } catch (e: Exception) {
+            logger.error("获取模板详情失败: ${e.message}", e)
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, messageSource = messageSource))
+        }
+    }
+
+    /**
+     * 获取模板可用变量
+     */
+    @PostMapping("/templates/variables")
+    fun getTemplateVariables(@RequestBody request: TemplateDetailRequest): ResponseEntity<ApiResponse<TemplateVariablesResponse>> {
+        return try {
+            if (request.templateType.isBlank()) {
+                return ResponseEntity.ok(ApiResponse.paramError("模板类型不能为空"))
+            }
+
+            val variables = notificationTemplateService.getTemplateVariables(request.templateType)
+            if (variables == null) {
+                ResponseEntity.ok(ApiResponse.error(ErrorCode.NOT_FOUND, messageSource = messageSource))
+            } else {
+                ResponseEntity.ok(ApiResponse.success(variables))
+            }
+        } catch (e: Exception) {
+            logger.error("获取模板变量失败: ${e.message}", e)
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, messageSource = messageSource))
+        }
+    }
+
+    /**
+     * 更新模板
+     */
+    @PostMapping("/templates/update")
+    fun updateTemplate(@RequestBody request: UpdateTemplateRequestWithId): ResponseEntity<ApiResponse<NotificationTemplateDto>> {
+        return try {
+            if (request.templateType.isBlank()) {
+                return ResponseEntity.ok(ApiResponse.paramError("模板类型不能为空"))
+            }
+            if (request.templateContent.isBlank()) {
+                return ResponseEntity.ok(ApiResponse.paramError("模板内容不能为空"))
+            }
+
+            val template = notificationTemplateService.updateTemplate(request.templateType, request.templateContent)
+            ResponseEntity.ok(ApiResponse.success(template))
+        } catch (e: Exception) {
+            logger.error("更新模板失败: ${e.message}", e)
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, messageSource = messageSource))
+        }
+    }
+
+    /**
+     * 重置模板为默认
+     */
+    @PostMapping("/templates/reset")
+    fun resetTemplate(@RequestBody request: TemplateDetailRequest): ResponseEntity<ApiResponse<NotificationTemplateDto>> {
+        return try {
+            if (request.templateType.isBlank()) {
+                return ResponseEntity.ok(ApiResponse.paramError("模板类型不能为空"))
+            }
+
+            val template = notificationTemplateService.resetTemplate(request.templateType)
+            if (template == null) {
+                ResponseEntity.ok(ApiResponse.error(ErrorCode.NOT_FOUND, messageSource = messageSource))
+            } else {
+                ResponseEntity.ok(ApiResponse.success(template))
+            }
+        } catch (e: Exception) {
+            logger.error("重置模板失败: ${e.message}", e)
+            ResponseEntity.ok(ApiResponse.error(ErrorCode.SERVER_ERROR, messageSource = messageSource))
+        }
+    }
+
+    /**
+     * 发送模板测试消息
+     */
+    @PostMapping("/templates/test")
+    fun testTemplate(@RequestBody request: TestTemplateRequest): ResponseEntity<ApiResponse<Boolean>> {
+        return try {
+            if (request.templateType.isBlank()) {
+                return ResponseEntity.ok(ApiResponse.paramError("模板类型不能为空"))
+            }
+
+            val success = runBlocking {
+                notificationTemplateService.sendTestMessage(request.templateType, request.templateContent)
+            }
+
+            if (success) {
+                ResponseEntity.ok(ApiResponse.success(true))
+            } else {
+                ResponseEntity.ok(ApiResponse.error(
+                    ErrorCode.NOTIFICATION_TEST_FAILED,
+                    messageSource = messageSource
+                ))
+            }
+        } catch (e: Exception) {
+            logger.error("发送模板测试消息失败: ${e.message}", e)
+            ResponseEntity.ok(ApiResponse.error(
+                ErrorCode.NOTIFICATION_TEST_FAILED,
+                customMsg = "发送测试消息失败：${e.message}",
+                messageSource = messageSource
+            ))
+        }
+    }
 }

 /**
@@ -384,3 +535,18 @@ data class NotificationConfigDeleteRequest(
    val id: Long
 )

+/**
+ * 模板详情请求
+ */
+data class TemplateDetailRequest(
+    val templateType: String
+)
+
+/**
+ * 更新模板请求（带类型）
+ */
+data class UpdateTemplateRequestWithId(
+    val templateType: String,
+    val templateContent: String
+)
+
@@ -0,0 +1,21 @@
+package com.wrbug.polymarketbot.dto
+
+/**
+ * 加密价差策略手动下单请求
+ */
+data class CryptoTailManualOrderRequest(
+    /** 策略ID */
+    val strategyId: Long = 0L,
+    /** 当前周期开始时间 (Unix 秒) */
+    val periodStartUnix: Long = 0L,
+    /** 下单方向: UP or DOWN */
+    val direction: String = "UP",
+    /** 下单价格 */
+    val price: String = "0",
+    /** 下单数量 */
+    val size: String = "1",
+    /** 市场标题（用于记录） */
+    val marketTitle: String = "",
+    /** Token IDs */
+    val tokenIds: List<String> = emptyList()
+)
@@ -0,0 +1,31 @@
+package com.wrbug.polymarketbot.dto
+
+/**
+ * 加密价差策略手动下单响应
+ */
+data class CryptoTailManualOrderResponse(
+    /** 是否成功 */
+    val success: Boolean = false,
+    /** 订单ID */
+    val orderId: String? = null,
+    /** 提示消息 */
+    val message: String = "",
+    /** 下单详情 */
+    val orderDetails: ManualOrderDetails? = null
+)
+
+/**
+ * 手动下单详情
+ */
+data class ManualOrderDetails(
+    /** 策略ID */
+    val strategyId: Long = 0L,
+    /** 方向 */
+    val direction: String = "",
+    /** 下单价格 */
+    val price: String = "",
+    /** 下单数量 */
+    val size: String = "",
+    /** 总金额 */
+    val totalAmount: String = ""
+)
@@ -5,7 +5,9 @@ package com.wrbug.polymarketbot.dto
 */
 data class CryptoTailMonitorInitRequest(
    /** 策略ID */
-    val strategyId: Long = 0L
+    val strategyId: Long = 0L,
+    /** 指定周期开始时间 (Unix 秒)，不传则用服务器当前周期 */
+    val periodStartUnix: Long? = null
 )

 /**
@@ -55,7 +57,11 @@ data class CryptoTailMonitorInitResponse(
    /** 当前时间 (毫秒时间戳) */
    val currentTimestamp: Long = System.currentTimeMillis(),
    /** 是否启用 */
-    val enabled: Boolean = true
+    val enabled: Boolean = true,
+    /** 投入金额模式: FIXED or RATIO */
+    val amountMode: String? = null,
+    /** 投入金额数值 */
+    val amountValue: String? = null
 )

 /**
@@ -167,3 +167,45 @@ data class CryptoTailMarketOptionDto(
    val periodStartUnix: Long = 0L,
    val endDate: String? = null
 )
+
+/**
+ * 收益曲线请求
+ * @param strategyId 策略ID
+ * @param startDate 开始时间（毫秒时间戳），null 表示不限制
+ * @param endDate 结束时间（毫秒时间戳），null 表示不限制
+ */
+data class CryptoTailPnlCurveRequest(
+    val strategyId: Long = 0L,
+    val startDate: Long? = null,
+    val endDate: Long? = null
+)
+
+/**
+ * 收益曲线单点数据
+ */
+data class CryptoTailPnlCurvePoint(
+    /** 时间点（毫秒时间戳，结算时间或创建时间） */
+    val timestamp: Long = 0L,
+    /** 累计收益 USDC */
+    val cumulativePnl: String = "0",
+    /** 当笔收益 USDC */
+    val pointPnl: String = "0",
+    /** 截至该点累计已结算笔数 */
+    val settledCount: Long = 0L
+)
+
+/**
+ * 收益曲线响应
+ */
+data class CryptoTailPnlCurveResponse(
+    val strategyId: Long = 0L,
+    val strategyName: String = "",
+    /** 筛选范围内总已实现收益 USDC */
+    val totalRealizedPnl: String = "0",
+    val settledCount: Long = 0L,
+    val winCount: Long = 0L,
+    val winRate: String? = null,
+    /** 最大回撤 USDC（正数表示回撤幅度） */
+    val maxDrawdown: String? = null,
+    val curveData: List<CryptoTailPnlCurvePoint> = emptyList()
+)
@@ -0,0 +1,63 @@
+package com.wrbug.polymarketbot.dto
+
+/**
+ * 消息模板 DTO
+ */
+data class NotificationTemplateDto(
+    val id: Long? = null,
+    val templateType: String,  // 模板类型
+    val templateContent: String,  // 模板内容
+    val isDefault: Boolean = false,  // 是否使用默认模板
+    val createdAt: Long? = null,
+    val updatedAt: Long? = null
+)
+
+/**
+ * 模板变量 DTO
+ */
+data class TemplateVariableDto(
+    val key: String,  // 变量名，如 account_name
+    val category: String,  // 分类：common, order, copy_trading, redeem, error
+    val sortOrder: Int = 0  // 排序顺序
+)
+
+/**
+ * 模板变量分类 DTO
+ */
+data class TemplateVariableCategoryDto(
+    val key: String,  // 分类 key
+    val sortOrder: Int = 0  // 排序顺序
+)
+
+/**
+ * 模板变量列表响应
+ */
+data class TemplateVariablesResponse(
+    val templateType: String,  // 模板类型
+    val categories: List<TemplateVariableCategoryDto>,  // 分类列表
+    val variables: List<TemplateVariableDto>  // 变量列表
+)
+
+/**
+ * 更新模板请求
+ */
+data class UpdateTemplateRequest(
+    val templateContent: String  // 模板内容
+)
+
+/**
+ * 测试模板请求
+ */
+data class TestTemplateRequest(
+    val templateType: String,  // 模板类型
+    val templateContent: String? = null  // 可选，如果不提供则使用已保存的模板
+)
+
+/**
+ * 模板类型信息
+ */
+data class TemplateTypeInfoDto(
+    val type: String,  // 模板类型
+    val name: String,  // 类型名称
+    val description: String  // 类型描述
+)
@@ -51,18 +51,21 @@ data class OrderPushMessage(

 /**
 * 订单详情（通过 API 获取）
+ * @param price 订单限价（用户提交的买入/卖出价）
+ * @param avgFilledPrice 实际成交价 = original_size * price / size_matched（有成交时优先用于推送展示）
 */
 data class OrderDetailDto(
    val id: String,                    // 订单 ID
    val market: String,                 // 市场 ID (condition ID)
    val side: String,                   // BUY/SELL
-    val price: String,                  // 价格
+    val price: String,                  // 订单限价
    val size: String,                   // 订单大小
    val filled: String,                 // 已成交数量
    val status: String,                 // 订单状态
    val createdAt: String,             // 创建时间（ISO 8601 格式）
    val marketName: String? = null,     // 市场名称（通过 Data API 获取）
    val marketSlug: String? = null,     // 市场 slug
-    val marketIcon: String? = null       // 市场图标
+    val marketIcon: String? = null,    // 市场图标
+    val avgFilledPrice: String? = null  // 实际成交价 = original_size*price/size_matched（有成交时使用）
 )

@@ -56,6 +56,9 @@ data class CryptoTailStrategyTrigger(
    @Column(name = "fail_reason", length = 500)
    val failReason: String? = null,

+    @Column(name = "trigger_type", nullable = false, length = 20)
+    val triggerType: String = "AUTO",
+
    @Column(name = "created_at", nullable = false)
    val createdAt: Long = System.currentTimeMillis(),

@@ -0,0 +1,30 @@
+package com.wrbug.polymarketbot.entity
+
+import jakarta.persistence.*
+
+/**
+ * 消息推送模板实体
+ * 用于存储用户自定义的消息模板
+ */
+@Entity
+@Table(name = "notification_templates")
+data class NotificationTemplate(
+    @Id
+    @GeneratedValue(strategy = GenerationType.IDENTITY)
+    val id: Long? = null,
+
+    @Column(name = "template_type", unique = true, nullable = false, length = 50)
+    val templateType: String,  // ORDER_SUCCESS, ORDER_FAILED, ORDER_FILTERED, CRYPTO_TAIL_SUCCESS, REDEEM_SUCCESS, REDEEM_NO_RETURN
+
+    @Column(name = "template_content", nullable = false, columnDefinition = "TEXT")
+    var templateContent: String,  // 模板内容，支持 {{variable}} 变量
+
+    @Column(name = "is_default", nullable = false)
+    var isDefault: Boolean = false,  // 是否使用默认模板
+
+    @Column(name = "created_at", nullable = false)
+    val createdAt: Long = System.currentTimeMillis(),
+
+    @Column(name = "updated_at", nullable = false)
+    var updatedAt: Long = System.currentTimeMillis()
+)
@@ -40,4 +40,16 @@ interface CryptoTailStrategyTriggerRepository : JpaRepository<CryptoTailStrategy
    /** 策略已结算中赢的笔数（outcome_index = winner_outcome_index） */
    @Query("SELECT COUNT(t) FROM CryptoTailStrategyTrigger t WHERE t.strategyId = :strategyId AND t.resolved = true AND t.outcomeIndex = t.winnerOutcomeIndex")
    fun countWinsByStrategyId(@Param("strategyId") strategyId: Long): Long
+
+    /** 收益曲线：已结算记录，按结算时间（无则创建时间）在区间内升序 */
+    @Query(
+        "SELECT t FROM CryptoTailStrategyTrigger t WHERE t.strategyId = :strategyId AND t.resolved = true " +
+            "AND COALESCE(t.settledAt, t.createdAt) >= :start AND COALESCE(t.settledAt, t.createdAt) <= :end " +
+            "ORDER BY COALESCE(t.settledAt, t.createdAt) ASC"
+    )
+    fun findResolvedByStrategyIdAndTimeRangeOrderBySettledAsc(
+        @Param("strategyId") strategyId: Long,
+        @Param("start") start: Long,
+        @Param("end") end: Long
+    ): List<CryptoTailStrategyTrigger>
 }
@@ -0,0 +1,11 @@
+package com.wrbug.polymarketbot.repository
+
+import com.wrbug.polymarketbot.entity.NotificationTemplate
+import org.springframework.data.jpa.repository.JpaRepository
+import org.springframework.stereotype.Repository
+
+@Repository
+interface NotificationTemplateRepository : JpaRepository<NotificationTemplate, Long> {
+    fun findByTemplateType(templateType: String): NotificationTemplate?
+    fun existsByTemplateType(templateType: String): Boolean
+}
@@ -10,7 +10,10 @@ import com.wrbug.polymarketbot.util.toSafeBigDecimal
 import com.wrbug.polymarketbot.util.eq
 import com.wrbug.polymarketbot.util.gt
 import com.wrbug.polymarketbot.util.JsonUtils
+import com.wrbug.polymarketbot.util.fromJson
 import com.wrbug.polymarketbot.util.getEventSlug
+import com.google.gson.JsonObject
+import com.google.gson.JsonPrimitive
 import com.wrbug.polymarketbot.service.common.PolymarketClobService
 import com.wrbug.polymarketbot.service.common.BlockchainService
 import com.wrbug.polymarketbot.service.common.MarketService
@@ -362,14 +365,14 @@ class AccountService(
    }

    /**
-     * Polymarket 代币批准检查：USDC.e 需授权的 spender 合约地址（Polygon 主网）
+     * Polymarket 代币批准检查：pUSD 需授权的 spender 合约地址（Polygon 主网）
     * 来源：Polymarket/magic-safe-builder-example README §6 Token Approvals
     * 及 neg-risk-ctf-adapter 仓库 addresses.json (chainId 137)
     */
    private val setupApprovalSpenders = mapOf(
        "CTF_CONTRACT" to "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045",           // Conditional Tokens
-        "CTF_EXCHANGE" to "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E",             // 普通市场交易所
-        "NEG_RISK_EXCHANGE" to "0xC5d563A36AE78145C45a50134d48A1215220f80a",         // 负风险市场交易所
+        "CTF_EXCHANGE" to "0xE111180000d2663C0091e4f400237545B87B996B",             // 普通市场交易所
+        "NEG_RISK_EXCHANGE" to "0xe2222d279d744050d28e00520010520000310F59",         // 负风险市场交易所
        "NEG_RISK_ADAPTER" to "0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296"          // 负风险适配器（非 WCOL 地址）
    )

@@ -938,7 +941,7 @@ class AccountService(
    }

    /**
-     * 轮询用：遍历所有账户，对代理地址 WCOL 余额 > 0 的执行解包为 USDC.e。
+     * 轮询用：遍历所有账户，对代理地址 WCOL 余额 > 0 的执行解包。
     * 由 WcolUnwrapJobService 每 20 秒调用，赎回后无需在赎回流程内等待确认与解包。
     */
    suspend fun runWcolUnwrapForAllAccounts() {
@@ -1241,23 +1244,17 @@ class AccountService(
                else -> "GTC"
            }

-            // GTC 和 FOK 订单的 expiration 必须为 "0"
-            // 只有 GTD 订单才需要设置具体的过期时间
-            val expiration = "0"
-
            // 7. 解密私钥
            val decryptedPrivateKey = decryptPrivateKey(account)

-            // 获取费率（根据 Polymarket Maker Rebates Program 要求）
-            val feeRateResult = clobService.getFeeRate(tokenId)
-            val feeRateBps = if (feeRateResult.isSuccess) {
-                feeRateResult.getOrNull()?.toString() ?: "0"
-            } else {
-                logger.warn("获取费率失败，使用默认值 0: tokenId=$tokenId, error=${feeRateResult.exceptionOrNull()?.message}")
-                "0"
+            // 11. 检查市场是否为 Neg Risk 市场，获取正确的 Exchange 合约地址
+            val negRisk = marketService.getNegRiskByConditionId(request.marketId) == true
+            val exchangeContract = orderSigningService.getExchangeContract(negRisk)
+            if (negRisk) {
+                logger.debug("市场为 Neg Risk，使用 Neg Risk Exchange 签约: conditionId=${request.marketId}")
            }

-            // 11. 创建并签名订单（使用计算后的卖出数量，按账户钱包类型使用对应 signatureType）
+            // 12. 创建并签名订单（使用计算后的卖出数量，按账户钱包类型使用对应 signatureType）
            val signedOrder = try {
                orderSigningService.createAndSignOrder(
                    privateKey = decryptedPrivateKey,
@@ -1267,22 +1264,19 @@ class AccountService(
                    price = sellPrice,
                    size = sellQuantity.toPlainString(),  // 使用计算后的卖出数量
                    signatureType = orderSigningService.getSignatureTypeForWalletType(account.walletType),
-                    nonce = "0",
-                    feeRateBps = feeRateBps,  // 使用动态获取的费率
-                    expiration = expiration
+                    exchangeContract = exchangeContract
                )
            } catch (e: Exception) {
                logger.error("创建并签名订单失败", e)
                return Result.failure(Exception("创建并签名订单失败: ${e.message}"))
            }

-            // 12. 构建订单请求
+            // 13. 构建订单请求

            val newOrderRequest = com.wrbug.polymarketbot.api.NewOrderRequest(
                order = signedOrder,
                owner = account.apiKey,  // API Key
-                orderType = orderType,
-                deferExec = false
+                orderType = orderType
            )

            // 13. 解密 API 凭证并使用账户的API凭证创建订单
@@ -1331,13 +1325,22 @@ class AccountService(

                            // 使用当前时间作为订单创建时间
                            val orderTime = System.currentTimeMillis()
+                            
+                            // 查询可用余额
+                            val availableBalance = try {
+                                blockchainService.getUsdcBalance(account.walletAddress, account.proxyAddress).getOrNull()
+                            } catch (e: Exception) {
+                                logger.warn("查询可用余额失败: accountId=${account.id}, ${e.message}")
+                                null
+                            }

                            telegramNotificationService?.sendOrderSuccessNotification(
                                orderId = orderId,
                                marketTitle = marketTitle,
                                marketId = request.marketId,
                                marketSlug = marketSlug,
-                                side = request.side,
+                                side = "SELL",  // 手动卖出订单，方向固定为 SELL
+                                outcome = request.side,  // request.side 是市场方向（YES/NO）
                                price = sellPrice,  // 直接传递卖出价格
                                size = sellQuantity.toPlainString(),  // 直接传递卖出数量
                                accountName = account.accountName,
@@ -1348,7 +1351,8 @@ class AccountService(
                                apiPassphrase = try { cryptoUtils.decrypt(account.apiPassphrase!!) } catch (e: Exception) { null },
                                walletAddressForApi = account.walletAddress,
                                locale = locale,
-                                orderTime = orderTime  // 使用订单创建时间
+                                orderTime = orderTime,  // 使用订单创建时间
+                                availableBalance = availableBalance
                            )
                        } catch (e: Exception) {
                            logger.warn("发送订单成功通知失败: ${e.message}", e)
@@ -1368,7 +1372,7 @@ class AccountService(
                        )
                    )
                } else {
-                    val errorMsg = response.errorMsg ?: "未知错误"
+                    val errorMsg = response.getErrorMessage()
                    val fullErrorMsg = "创建订单失败: accountId=${account.id}, marketId=${request.marketId}, side=${request.side}, orderType=${request.orderType}, price=${if (request.orderType == "LIMIT") sellPrice else "MARKET"}, quantity=${sellQuantity.toPlainString()}, errorMsg=$errorMsg"
                    logger.error(fullErrorMsg)
                    
@@ -1413,6 +1417,14 @@ class AccountService(
                } catch (e: Exception) {
                    null
                }
+                
+                // 尝试从 errorBody 解析 error 字段（使用 Gson）
+                val apiError = try {
+                    (errorBody?.fromJson<JsonObject>()?.get("error") as? JsonPrimitive)?.asString
+                } catch (e: Exception) {
+                    null
+                }
+                
                val fullErrorMsg = "创建订单失败: accountId=${account.id}, marketId=${request.marketId}, side=${request.side}, orderType=${request.orderType}, price=${if (request.orderType == "LIMIT") sellPrice else "MARKET"}, quantity=${sellQuantity.toPlainString()}, code=${orderResponse.code()}, message=${orderResponse.message()}${if (errorBody != null) ", errorBody=$errorBody" else ""}"
                logger.error(fullErrorMsg)
                
@@ -1431,8 +1443,10 @@ class AccountService(
                            java.util.Locale("zh", "CN")  // 默认简体中文
                        }

-                        // 只传递后端返回的 msg，不传递完整堆栈
-                        val errorMsg = orderResponse.body()?.errorMsg ?: "创建订单失败"
+                        // 优先使用解析的 API error，其次使用响应体的 errorMsg，最后使用默认消息
+                        val errorMsg = apiError 
+                            ?: orderResponse.body()?.getErrorMessage() 
+                            ?: "创建订单失败 (HTTP ${orderResponse.code()})"

                        telegramNotificationService?.sendOrderFailureNotification(
                            marketTitle = marketTitle,
@@ -1442,7 +1456,7 @@ class AccountService(
                            outcome = null,  // 失败时可能没有 outcome
                            price = if (request.orderType == "LIMIT") sellPrice.toString() else "MARKET",
                            size = sellQuantity.toString(),
-                            errorMessage = errorMsg,  // 只传递后端返回的 msg
+                            errorMessage = errorMsg,  // 只传递后端返回的错误信息
                            accountName = account.accountName,
                            walletAddress = account.walletAddress,
                            locale = locale
@@ -1800,16 +1814,42 @@ class AccountService(
                    for (transaction in accountTransactions) {
                        val account = accounts[transaction.accountId]
                        if (account != null) {
-                            telegramNotificationService?.sendRedeemNotification(
-                                accountName = account.accountName,
-                                walletAddress = account.walletAddress,
-                                transactionHash = transaction.transactionHash,
-                                totalRedeemedValue = transaction.positions.fold(BigDecimal.ZERO) { sum, info ->
-                                    sum.add(info.value.toSafeBigDecimal())
-                                }.toPlainString(),
-                                positions = transaction.positions,
-                                locale = locale
-                            )
+                            // 查询可用余额
+                            val availableBalance = try {
+                                blockchainService.getUsdcBalance(account.walletAddress, account.proxyAddress).getOrNull()
+                            } catch (e: Exception) {
+                                logger.warn("查询可用余额失败: accountId=${account.id}, ${e.message}")
+                                null
+                            }
+                            
+                            // 计算该账户的赎回总价值
+                            val accountTotalValue = transaction.positions.fold(BigDecimal.ZERO) { sum, info ->
+                                sum.add(info.value.toSafeBigDecimal())
+                            }
+                            
+                            // 根据赎回价值选择不同的通知类型
+                            if (accountTotalValue.gt(BigDecimal.ZERO)) {
+                                // 有收益：发送赎回成功通知
+                                telegramNotificationService?.sendRedeemNotification(
+                                    accountName = account.accountName,
+                                    walletAddress = account.walletAddress,
+                                    transactionHash = transaction.transactionHash,
+                                    totalRedeemedValue = accountTotalValue.toPlainString(),
+                                    positions = transaction.positions,
+                                    locale = locale,
+                                    availableBalance = availableBalance
+                                )
+                            } else {
+                                // 无收益（输的仓位）：发送已结算无收益通知
+                                telegramNotificationService?.sendRedeemNoReturnNotification(
+                                    accountName = account.accountName,
+                                    walletAddress = account.walletAddress,
+                                    transactionHash = transaction.transactionHash,
+                                    positions = transaction.positions,
+                                    locale = locale,
+                                    availableBalance = availableBalance
+                                )
+                            }
                        }
                    }
                } catch (e: Exception) {
@@ -1876,6 +1916,32 @@ class AccountService(
            false
        }
    }
+
+    /**
+     * 将账户的 USDC.e wrap 为 pUSD
+     */
+    suspend fun wrapUsdcToPusd(accountId: Long): Result<String?> {
+        val account = accountRepository.findById(accountId).orElse(null)
+            ?: return Result.failure(IllegalArgumentException("账户不存在"))
+        if (account.proxyAddress.isBlank()) {
+            return Result.failure(IllegalStateException("账户代理地址不存在"))
+        }
+        val privateKey = cryptoUtils.decrypt(account.privateKey)
+        val walletType = WalletType.fromStringOrDefault(account.walletType, WalletType.SAFE)
+        return blockchainService.wrapUsdcToPusd(privateKey, account.proxyAddress, walletType)
+    }
+
+    /**
+     * 查询 USDC.e 余额（用于迁移提示）
+     */
+    suspend fun getUsdceBalance(accountId: Long): Result<BigDecimal> {
+        val account = accountRepository.findById(accountId).orElse(null)
+            ?: return Result.failure(IllegalArgumentException("账户不存在"))
+        if (account.proxyAddress.isBlank()) {
+            return Result.failure(IllegalStateException("账户代理地址不存在"))
+        }
+        return blockchainService.queryUsdceBalance(account.proxyAddress)
+    }
 }


@@ -11,7 +11,7 @@ import org.springframework.stereotype.Service

 /**
 * WCOL 解包轮询任务
- * 每 20 秒轮询一次，遍历所有账户的代理地址：若 WCOL 余额 > 0 则解包为 USDC.e。
+ * 每 20 秒轮询一次，遍历所有账户的代理地址：若 WCOL 余额 > 0 则执行解包。
 * 同一时间仅允许单次执行；若上次执行未结束则本次忽略（与现有轮询逻辑一致）。
 * 若未配置 Builder API Key，直接跳过本轮（解包依赖 Relayer Gasless，未配置则无法执行）。
 */
@@ -408,10 +408,25 @@ class BacktestExecutionService(
                                val cost = actualSellQuantity.multiply(position.avgPrice)
                                val profitLoss = netAmount.subtract(cost)

-                                // 更新余额和持仓
+                                // Bug #39 Fix: correctly reduce position quantity after sell
                                currentBalance += netAmount
-                                if (position.quantity <= BigDecimal.ZERO) {
+                                val remainingQuantity = position.quantity - actualSellQuantity
+                                val remainingLeaderBuyQuantity = if (position.leaderBuyQuantity != null && position.leaderBuyQuantity > BigDecimal.ZERO) {
+                                    val totalQty = position.quantity
+                                    val leaderReduction = actualSellQuantity.divide(
+                                        totalQty, 8, java.math.RoundingMode.DOWN
+                                    )
+                                    (position.leaderBuyQuantity - leaderReduction).coerceAtLeast(BigDecimal.ZERO)
+                                } else {
+                                    position.leaderBuyQuantity
+                                }
+                                if (remainingQuantity <= BigDecimal.ZERO) {
                                    positions.remove(positionKey)
+                                } else {
+                                    positions[positionKey] = position.copy(
+                                        quantity = remainingQuantity,
+                                        leaderBuyQuantity = remainingLeaderBuyQuantity
+                                    )
                                }

                                // 记录交易到当前页列表
@@ -632,7 +647,8 @@ class BacktestExecutionService(
            val settlementPrice = avgPrice

            val settlementValue = quantity.multiply(settlementPrice)
-            val profitLoss = settlementValue.negate()
+            // Bug #39 Fix: profitLoss for closed settlement at avgPrice should be ~0
+            val profitLoss = settlementValue.subtract(quantity.multiply(avgPrice))

            balance += settlementValue

@@ -702,7 +718,8 @@ class BacktestExecutionService(
            if (balance > peakBalance) {
                peakBalance = balance
            }
-            val drawdown = peakBalance - runningBalance
+            // Bug #39 Fix: use current balance, not runningBalance from previous iteration
+            val drawdown = peakBalance - balance
            if (drawdown > maxDrawdown) {
                maxDrawdown = drawdown
            }
@@ -91,7 +91,12 @@ class BinanceKlineService {
            }
        }.toSet()
        val wsKeysNeeded = parsed.map { (_, symbol, interval) -> "$symbol-$interval" }.toSet()
-        if (normalized == requiredMarketPrefixes.get()) return
+        
+        // 检查是否有需要的 WebSocket 连接缺失（可能因网络问题断开）
+        val hasMissingConnection = wsKeysNeeded.any { it !in connectedWebSockets.keys }
+        
+        // 只有当集合相同且所有需要的连接都存在时才跳过
+        if (normalized == requiredMarketPrefixes.get() && !hasMissingConnection) return
        requiredMarketPrefixes.set(normalized)
        synchronized(subscriptionLock) {
            connectedWebSockets.keys.toList().forEach { wsKey ->
@@ -39,8 +39,8 @@ class BlockchainService(
    
    private val logger = LoggerFactory.getLogger(BlockchainService::class.java)
    
-    // USDC 合约地址（Polygon 主网，Polymarket 使用 Polygon）
-    private val usdcContractAddress = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
+    // pUSD 合约地址（Polygon 主网，Polymarket 使用 Polygon）
+    private val usdcContractAddress = "0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB"
    
    // Polymarket Safe 代理工厂合约地址（Polygon 主网，用于 MetaMask 用户）
    // 合约地址: 0xaacFeEa03eb1561C4e67d661e40682Bd20E3541b
@@ -56,7 +56,7 @@ class BlockchainService(
    // ConditionalTokens 合约地址（Polygon 主网）
    private val conditionalTokensAddress = "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"

-    // Neg Risk WrappedCollateral 合约地址（Polygon，解包后得 USDC.e）
+    // Neg Risk WrappedCollateral 合约地址（Polygon）
    private val wcolContractAddress = "0x3A3BD7bb9528E159577F7C2e685CC81A765002E2"
    
    // 空集合ID（用于计算collectionId）
@@ -812,11 +812,11 @@ class BlockchainService(
    }

    /**
-     * 将代理钱包内的 WCOL 解包为 USDC.e（解包后转入代理地址）
-     * 赎回 Neg Risk 仓位后到账为 WCOL，调用此方法可转为 USDC.e 以便显示/使用。
+     * 将代理钱包内的 WCOL 执行解包（解包后转入代理地址）
+     * 赎回 Neg Risk 仓位后到账为 WCOL，调用此方法可执行解包后续资产处理。
     *
     * Safe 与 Magic 使用同一套逻辑：同一 [createUnwrapWcolTx] + [RelayClientService.execute]；
-     * Safe 走 execTransaction，Magic 走 PROXY 编码，最终均为代理合约调用 WCOL.unwrap(proxyAddress, amount)，USDC.e 转入 proxyAddress。
+     * Safe 走 execTransaction，Magic 走 PROXY 编码，最终均为代理合约调用 WCOL.unwrap(proxyAddress, amount)。
     *
     * @param privateKey 主钱包私钥
     * @param proxyAddress 代理地址（Safe 或 Magic 代理）
@@ -855,6 +855,99 @@ class BlockchainService(
        }
    }

+    // USDC.e 合约地址（仅用于 wrap 查询）
+    private val usdceContractAddress = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
+
+    /**
+     * 查询 USDC.e 余额（用于 wrap 前检查）
+     */
+    suspend fun queryUsdceBalance(walletAddress: String): Result<BigDecimal> {
+        return try {
+            val rpcApi = polygonRpcApi
+            val functionSelector = "0x70a08231"
+            val paddedAddress = walletAddress.removePrefix("0x").lowercase().padStart(64, '0')
+            val data = functionSelector + paddedAddress
+            val rpcRequest = JsonRpcRequest(
+                method = "eth_call",
+                params = listOf(mapOf("to" to usdceContractAddress, "data" to data), "latest")
+            )
+            val response = rpcApi.call(rpcRequest)
+            if (!response.isSuccessful || response.body() == null) {
+                return Result.failure(Exception("RPC 请求失败"))
+            }
+            val hexBalance = response.body()!!.result?.asString ?: return Result.failure(Exception("result 为空"))
+            val balanceWei = BigInteger(hexBalance.removePrefix("0x"), 16)
+            Result.success(BigDecimal(balanceWei).divide(BigDecimal("1000000")))
+        } catch (e: Exception) {
+            Result.failure(e)
+        }
+    }
+
+    /**
+     * 将 USDC.e wrap 为 pUSD
+     * 步骤：1) 检查 USDC.e 余额 → 2) approve CollateralOnramp → 3) wrap
+     */
+    suspend fun wrapUsdcToPusd(
+        privateKey: String,
+        proxyAddress: String,
+        walletType: WalletType
+    ): Result<String?> {
+        return try {
+            val balanceResult = queryUsdceBalance(proxyAddress)
+            val balance = balanceResult.getOrElse {
+                logger.warn("查询 USDC.e 余额失败: ${it.message}")
+                return Result.failure(it)
+            }
+            if (balance <= BigDecimal.ZERO) {
+                return Result.success(null)
+            }
+            val wrapAmountWei = balance.movePointRight(6).toBigInteger()
+            logger.info("开始 wrap USDC.e → pUSD: proxy=${proxyAddress.take(10)}..., amount=$balance")
+
+            val unlimitedAllowance = BigInteger.valueOf(2).pow(256).minus(BigInteger.ONE)
+            val approveTx = relayClientService.createUsdceApproveForWrapTx(unlimitedAllowance)
+            val wrapTx = relayClientService.createWrapToPusdTx(proxyAddress, wrapAmountWei)
+            if (walletType == WalletType.MAGIC) {
+                // MAGIC 账户走 PROXY 时，不使用 Safe MultiSend(delegatecall)；
+                // 改为顺序执行两笔 CALL，避免内层 delegatecall 回滚导致“外层成功但业务失败”。
+                val approveResult = relayClientService.execute(privateKey, proxyAddress, approveTx, walletType)
+                val approveHash = approveResult.getOrElse {
+                    logger.error("USDC.e approve 失败: ${it.message}", it)
+                    return Result.failure(it)
+                }
+                logger.info("USDC.e approve 成功: txHash=$approveHash")
+
+                val wrapResult = relayClientService.execute(privateKey, proxyAddress, wrapTx, walletType)
+                wrapResult.fold(
+                    onSuccess = { txHash ->
+                        logger.info("USDC.e → pUSD wrap 成功: txHash=$txHash")
+                        Result.success(txHash)
+                    },
+                    onFailure = { e ->
+                        logger.error("USDC.e → pUSD wrap 失败: ${e.message}", e)
+                        Result.failure(e)
+                    }
+                )
+            } else {
+                val safeTx = relayClientService.createMultiSendTx(listOf(approveTx, wrapTx))
+                val executeResult = relayClientService.execute(privateKey, proxyAddress, safeTx, walletType)
+                executeResult.fold(
+                    onSuccess = { txHash ->
+                        logger.info("USDC.e → pUSD wrap 成功: txHash=$txHash")
+                        Result.success(txHash)
+                    },
+                    onFailure = { e ->
+                        logger.error("USDC.e → pUSD wrap 失败: ${e.message}", e)
+                        Result.failure(e)
+                    }
+                )
+            }
+        } catch (e: Exception) {
+            logger.error("USDC.e → pUSD wrap 异常: ${e.message}", e)
+            Result.failure(e)
+        }
+    }
+
    /**
     * 获取代理钱包的 nonce（用于构建 Safe 交易）
     */
@@ -223,15 +223,7 @@ class PolymarketClobService(
        }
    }
    
-    /**
-     * 创建订单（已废弃，使用 createSignedOrder 代替）
-     * @deprecated 使用 createSignedOrder 代替，需要签名的订单对象
-     */
-    @Deprecated("使用 createSignedOrder 代替")
-    suspend fun createOrder(request: CreateOrderRequest): Result<OrderResponse> {
-        return Result.failure(UnsupportedOperationException("已废弃，请使用 createSignedOrder 方法"))
-    }
-    
+
    /**
     * 创建签名的订单
     * 注意：此方法需要完整的订单签名逻辑，当前为占位实现
@@ -401,7 +393,7 @@ class PolymarketClobService(
            Result.failure(e)
        }
    }
-    
+
    /**
     * 获取费率
     * 文档: https://docs.polymarket.com/developers/market-makers/maker-rebates-program#1-fetch-the-fee-rate
@@ -45,7 +45,9 @@ object OnChainWsUtils {
    }
    
    // 合约地址
-    const val USDC_CONTRACT = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
+    const val PUSD_CONTRACT = "0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB"         // V2 pUSD
+    const val USDC_CONTRACT = PUSD_CONTRACT  // 默认使用 pUSD
+    private val COLLATERAL_CONTRACTS = setOf(PUSD_CONTRACT.lowercase())
    const val ERC1155_CONTRACT = "0x4d97dcd97ec945f40cf65f87097ace5ea0476045"
    const val ERC20_TRANSFER_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
    const val ERC1155_TRANSFER_SINGLE_TOPIC = "0xc3d58168c5ae7397731d063d5bbf3d657854427343f4c083240f7aacaa2d0f62"
@@ -96,8 +98,8 @@ object OnChainWsUtils {
            val t0 = topics[0].lowercase()
            val data = log.get("data")?.asString ?: "0x"
            
-            // USDC ERC20 Transfer
-            if (address == USDC_CONTRACT.lowercase() && t0 == ERC20_TRANSFER_TOPIC && topics.size >= 3) {
+            // 抵押品 ERC20 Transfer（当前仅匹配 pUSD）
+            if (address in COLLATERAL_CONTRACTS && t0 == ERC20_TRANSFER_TOPIC && topics.size >= 3) {
                val from = topicToAddress(topics[1])
                val to = topicToAddress(topics[2])
                val value = hexToBigInt(data)
@@ -149,6 +151,42 @@ object OnChainWsUtils {
        return Pair(erc20, erc1155)
    }
    
+    /**
+     * 通过 CLOB 交易历史获取 Leader 真实成交价（用于无 USDC 转账的 ERC1155-only 场景）
+     * 查询该 token 最近的成交记录，匹配 side 方向的第一条作为成交价
+     * 返回 usdcRaw = price × sizeRaw
+     */
+    private suspend fun fetchEstimatedUsdcRaw(
+        tokenId: String,
+        side: String,
+        sizeRaw: BigInteger,
+        retrofitFactory: RetrofitFactory
+    ): BigInteger? {
+        return try {
+            val clobApi = retrofitFactory.createClobApiWithoutAuth()
+            val response = clobApi.getTrades(asset_id = tokenId)
+            if (!response.isSuccessful || response.body() == null) {
+                logger.warn("CLOB 交易历史查询失败: tokenId=$tokenId, code=${response.code()}")
+                return null
+            }
+            val trades = response.body()!!.data
+            val clobSide = side.lowercase()
+            val matchedTrade = trades.firstOrNull { it.side.equals(clobSide, ignoreCase = true) }
+            if (matchedTrade == null) {
+                logger.warn("CLOB 交易历史中未找到匹配成交: tokenId=$tokenId, side=$clobSide, totalTrades=${trades.size}")
+                return null
+            }
+            val price = matchedTrade.price.toBigDecimal()
+            val usdcRaw = price.multiply(sizeRaw.toBigDecimal())
+                .setScale(0, java.math.RoundingMode.DOWN).toBigInteger()
+            logger.debug("CLOB 交易历史估算: tokenId=$tokenId, side=$clobSide, tradePrice=${matchedTrade.price}, tradeSize=${matchedTrade.size}, sizeRaw=$sizeRaw, usdcRaw=$usdcRaw")
+            usdcRaw
+        } catch (e: Exception) {
+            logger.warn("获取 CLOB 交易历史失败: tokenId=$tokenId, side=$side, error=${e.message}")
+            null
+        }
+    }
+
    /**
     * 从 Transfer 日志解析交易信息
     */
@@ -205,6 +243,32 @@ object OnChainWsUtils {
            asset = bestOutId
            sizeRaw = bestOutVal
            usdcRaw = usdcIn
+        } else if (bestInId != null && bestInVal > BigInteger.ZERO && bestOutId == null
+            && usdcOut == BigInteger.ZERO && usdcIn == BigInteger.ZERO
+        ) {
+            // BUY（无 USDC）: 只收到 ERC1155 token，无 USDC 流动（CLOB 内部结算等场景）
+            side = "BUY"
+            asset = bestInId
+            sizeRaw = bestInVal
+            usdcRaw = fetchEstimatedUsdcRaw(bestInId.toString(), "BUY", bestInVal, retrofitFactory)
+                ?: run {
+                    logger.warn("无法获取估算价格（ERC1155-only BUY）: txHash=$txHash, tokenId=$bestInId")
+                    return null
+                }
+            logger.debug("ERC1155-only BUY: txHash=$txHash, tokenId=$bestInId, sizeRaw=$sizeRaw, usdcRaw=$usdcRaw")
+        } else if (bestOutId != null && bestOutVal > BigInteger.ZERO && bestInId == null
+            && usdcOut == BigInteger.ZERO && usdcIn == BigInteger.ZERO
+        ) {
+            // SELL（无 USDC）: 只发出 ERC1155 token，无 USDC 流动
+            side = "SELL"
+            asset = bestOutId
+            sizeRaw = bestOutVal
+            usdcRaw = fetchEstimatedUsdcRaw(bestOutId.toString(), "SELL", bestOutVal, retrofitFactory)
+                ?: run {
+                    logger.warn("无法获取估算价格（ERC1155-only SELL）: txHash=$txHash, tokenId=$bestOutId")
+                    return null
+                }
+            logger.debug("ERC1155-only SELL: txHash=$txHash, tokenId=$bestOutId, sizeRaw=$sizeRaw, usdcRaw=$usdcRaw")
        } else {
            // 无法判断交易方向
            logger.debug("无法判断交易方向: txHash=$txHash, bestInId=$bestInId, bestInVal=$bestInVal, bestOutId=$bestOutId, bestOutVal=$bestOutVal, usdcOut=$usdcOut, usdcIn=$usdcIn")
@@ -20,7 +20,12 @@ import com.wrbug.polymarketbot.repository.CopyTradingRepository
 import com.wrbug.polymarketbot.repository.LeaderRepository
 import com.wrbug.polymarketbot.constants.PolymarketConstants
 import com.wrbug.polymarketbot.service.common.MarketService
+import com.wrbug.polymarketbot.util.div
+import com.wrbug.polymarketbot.util.gt
+import com.wrbug.polymarketbot.util.multi
+import com.wrbug.polymarketbot.util.toSafeBigDecimal
 import org.springframework.stereotype.Service
+import java.math.BigDecimal
 import java.util.concurrent.ConcurrentHashMap

 /**
@@ -426,20 +431,29 @@ class OrderPushService(
                    // 获取市场信息（使用 MarketService，优先从数据库/缓存获取）
                    val market = marketService.getMarket(conditionId ?: openOrder.market)

-                    // 转换为 DTO
+                    // 有成交时按公式计算实际成交价：original_size * price / size_matched，数量用 size_matched
+                    val sizeMatched = openOrder.sizeMatched.toSafeBigDecimal()
+                    val avgFilledPrice = if (sizeMatched.gt(BigDecimal.ZERO)) {
+                        openOrder.originalSize.toSafeBigDecimal()
+                            .multi(openOrder.price)
+                            .div(sizeMatched, 18)
+                    } else null
+
+                    // 转换为 DTO（展示数量用 size_matched）
                    // 注意：createdAt 是 unix timestamp (Long)，需要转换为字符串
                    OrderDetailDto(
                        id = openOrder.id,
                        market = openOrder.market,
                        side = openOrder.side,
                        price = openOrder.price,
-                        size = openOrder.originalSize,  // 使用 original_size
-                        filled = openOrder.sizeMatched,  // 使用 size_matched
+                        size = openOrder.originalSize,
+                        filled = openOrder.sizeMatched,  // 已成交数量用 size_matched
                        status = openOrder.status,
                        createdAt = openOrder.createdAt.toString(),  // unix timestamp 转换为字符串
                        marketName = market?.title,
                        marketSlug = market?.slug,  // 显示用的 slug
-                        marketIcon = market?.icon
+                        marketIcon = market?.icon,
+                        avgFilledPrice = avgFilledPrice?.toPlainString()  // 实际成交价 = original_size*price/size_matched
                    )
                },
                onFailure = { e ->
@@ -41,10 +41,9 @@ class OrderSigningService {
        return if (walletTypeEnum == com.wrbug.polymarketbot.enums.WalletType.MAGIC) 1 else 2
    }

-    // Polygon 主网合约地址（标准 CTF Exchange）
-    private val EXCHANGE_CONTRACT = "0x4bFb41d5B3570DeFd03C39a9A4D8dE6Bd8B8982E"
-    // Neg Risk CTF Exchange（neg risk 市场需用此合约签约，否则服务端返回 invalid signature）
-    private val NEG_RISK_EXCHANGE_CONTRACT = "0xC5d563A36AE78145C45a50134d48A1215220f80a"
+    // V2 合约地址
+    private val EXCHANGE_CONTRACT = "0xE111180000d2663C0091e4f400237545B87B996B"
+    private val NEG_RISK_EXCHANGE_CONTRACT = "0xe2222d279d744050d28e00520010520000310F59"
    private val CHAIN_ID = 137L
    
    // USDC 有 6 位小数
@@ -156,8 +155,8 @@ class OrderSigningService {
    }
    
    /**
-     * 创建并签名订单
-     * 
+     * 创建并签名订单 (V2)
+     *
     * @param privateKey 私钥（十六进制字符串）
     * @param makerAddress maker 地址（funder，通常是 proxyAddress）
     * @param tokenId token ID
@@ -165,9 +164,6 @@ class OrderSigningService {
     * @param price 价格
     * @param size 数量
     * @param signatureType 签名类型（1: Email/Magic, 2: Browser Wallet, 0: EOA）
-     * @param nonce nonce（默认 "0"）
-     * @param feeRateBps 费率基点（默认 "0"）
-     * @param expiration 过期时间戳（秒，0 表示永不过期）
     * @param exchangeContract 签约用 exchange 合约地址；null 时用标准 CTF Exchange，neg risk 市场需传 Neg Risk Exchange
     * @return 签名的订单对象
     */
@@ -178,10 +174,7 @@ class OrderSigningService {
        side: String,
        price: String,
        size: String,
-        signatureType: Int = 2,  // 默认使用 Browser Wallet（与正确订单数据一致）
-        nonce: String = "0",
-        feeRateBps: String = "0",
-        expiration: String = "0",
+        signatureType: Int = 2,
        exchangeContract: String? = null
    ): SignedOrderObject {
        try {
@@ -189,33 +182,32 @@ class OrderSigningService {
            val cleanPrivateKey = privateKey.removePrefix("0x")
            val privateKeyBigInt = BigInteger(cleanPrivateKey, 16)
            val credentials = Credentials.create(privateKeyBigInt.toString(16))
-            // 统一转换为小写，确保与 EIP-712 编码时使用的地址格式一致
-            // EIP-712 编码时地址会被转换为小写，所以订单对象中的地址也应该是小写
            val signerAddress = credentials.address.lowercase()
-            
+
            // 2. 计算订单金额
            val amounts = calculateOrderAmounts(side, size, price)
-            
-            // 3. 生成 salt（使用时间戳，毫秒）
+
+            // 3. 生成 salt 和 timestamp（V2: timestamp 替代 nonce 保证唯一性）
            val salt = generateSalt()
-            
-            // 4. taker 地址（默认使用零地址）
-            val taker = "0x0000000000000000000000000000000000000000"
-            
+            val timestamp = System.currentTimeMillis().toString()
+
+            // 4. V2 字段默认值
+            val metadata = "0x0000000000000000000000000000000000000000000000000000000000000000"
+            val builder = "0x0000000000000000000000000000000000000000000000000000000000000000"
+
            // 5. 确保 maker 地址也是小写格式
            val makerAddressLower = makerAddress.lowercase()
-            
-            // 打印签名前的订单参数（DEBUG 级别，避免敏感信息泄露）
-            logger.debug("========== 订单签名前参数 ==========")
+
+            logger.debug("========== 订单签名前参数 (V2) ==========")
            logger.debug("订单方向: $side, 价格: $price, 数量: $size")
            logger.debug("Token ID: $tokenId")
            logger.debug("Maker: ${makerAddressLower.take(10)}...${makerAddressLower.takeLast(6)}")
            logger.debug("Signer: ${signerAddress.take(10)}...${signerAddress.takeLast(6)}")
            logger.debug("Amounts - Maker: ${amounts.makerAmount}, Taker: ${amounts.takerAmount}")
-            logger.debug("Salt: $salt, Expiration: $expiration, Nonce: $nonce, FeeRateBPS: $feeRateBps")
+            logger.debug("Salt: $salt, Timestamp: $timestamp")
            logger.debug("Signature Type: $signatureType, Chain ID: $CHAIN_ID")
-            
-            // 6. 构建订单数据并签名（neg risk 市场需用 NEG_RISK_EXCHANGE_CONTRACT）
+
+            // 6. 构建订单数据并签名
            val contract = exchangeContract?.takeIf { it.isNotBlank() } ?: EXCHANGE_CONTRACT
            val signature = signOrder(
                privateKey = privateKey,
@@ -224,44 +216,41 @@ class OrderSigningService {
                salt = salt,
                maker = makerAddressLower,
                signer = signerAddress,
-                taker = taker,
                tokenId = tokenId,
                makerAmount = amounts.makerAmount,
                takerAmount = amounts.takerAmount,
-                expiration = expiration,
-                nonce = nonce,
-                feeRateBps = feeRateBps,
                side = side.uppercase(),
-                signatureType = signatureType
+                signatureType = signatureType,
+                timestamp = timestamp,
+                metadata = metadata,
+                builder = builder
            )
-            
-            // 7. 创建签名的订单对象
-            // 注意：所有地址字段都使用小写格式，确保与签名时使用的地址一致
+
+            // 7. 创建 V2 签名订单对象
            return SignedOrderObject(
                salt = salt,
                maker = makerAddressLower,
                signer = signerAddress,
-                taker = taker,
+                taker = "0x0000000000000000000000000000000000000000",
                tokenId = tokenId,
                makerAmount = amounts.makerAmount,
                takerAmount = amounts.takerAmount,
-                expiration = expiration,
-                nonce = nonce,
-                feeRateBps = feeRateBps,
                side = side.uppercase(),
                signatureType = signatureType,
+                timestamp = timestamp,
+                expiration = "0",
+                metadata = metadata,
+                builder = builder,
                signature = signature
            )
        } catch (e: Exception) {
-            logger.error("创建并签名订单失败", e)
-            throw RuntimeException("创建并签名订单失败: ${e.message}", e)
+            logger.error("创建并签名订单失败 (V2)", e)
+            throw RuntimeException("创建并签名订单失败 (V2): ${e.message}", e)
        }
    }
    
    /**
-     * 签名订单（EIP-712）
-     * 
-     * 参考: @polymarket/order-utils 的 ExchangeOrderBuilder
+     * 签名订单 V2（EIP-712）
     */
    private fun signOrder(
        privateKey: String,
@@ -270,56 +259,47 @@ class OrderSigningService {
        salt: Long,
        maker: String,
        signer: String,
-        taker: String,
        tokenId: String,
        makerAmount: String,
        takerAmount: String,
-        expiration: String,
-        nonce: String,
-        feeRateBps: String,
        side: String,
-        signatureType: Int
+        signatureType: Int,
+        timestamp: String,
+        metadata: String,
+        builder: String
    ): String {
        try {
-            // 1. 私钥与密钥对
            val cleanPrivateKey = privateKey.removePrefix("0x")
            val privateKeyBigInt = BigInteger(cleanPrivateKey, 16)
            val credentials = Credentials.create(privateKeyBigInt.toString(16))
            val ecKeyPair = credentials.ecKeyPair

-            // 2. 编码域分隔符（verifyingContract 显式小写，与 EIP-712 约定一致）
            val domainSeparator = com.wrbug.polymarketbot.util.Eip712Encoder.encodeExchangeDomain(
                chainId = chainId,
                verifyingContract = exchangeContract.lowercase()
            )

-            // 3. 编码订单消息哈希
-            // signatureType：1 = POLY_PROXY (Magic), 2 = POLY_GNOSIS_SAFE (Safe), 0 = EOA
            val orderHash = com.wrbug.polymarketbot.util.Eip712Encoder.encodeExchangeOrder(
                salt = salt,
                maker = maker,
                signer = signer,
-                taker = taker,
                tokenId = tokenId,
                makerAmount = makerAmount,
                takerAmount = takerAmount,
-                expiration = expiration,
-                nonce = nonce,
-                feeRateBps = feeRateBps,
                side = side,
-                signatureType = signatureType
+                signatureType = signatureType,
+                timestamp = timestamp,
+                metadata = metadata,
+                builder = builder
            )

-            // 4. 计算完整 EIP-712 结构化数据哈希
            val structuredHash = com.wrbug.polymarketbot.util.Eip712Encoder.hashStructuredData(
                domainSeparator = domainSeparator,
                messageHash = orderHash
            )

-            // 5. 使用私钥签名（needToHash=false，对 32 字节 hash 直接签名）
            val signature = org.web3j.crypto.Sign.signMessage(structuredHash, ecKeyPair, false)

-            // 6. 组合 r + s + v
            val rHex = org.web3j.utils.Numeric.toHexString(signature.r).removePrefix("0x").padStart(64, '0')
            val sHex = org.web3j.utils.Numeric.toHexString(signature.s).removePrefix("0x").padStart(64, '0')
            val vBytes = signature.v
@@ -328,8 +308,8 @@ class OrderSigningService {

            return "0x$rHex$sHex$vHex"
        } catch (e: Exception) {
-            logger.error("订单签名失败", e)
-            throw RuntimeException("订单签名失败: ${e.message}", e)
+            logger.error("订单签名失败 (V2)", e)
+            throw RuntimeException("订单签名失败 (V2): ${e.message}", e)
        }
    }
    
@@ -562,16 +562,7 @@ open class CopyOrderTrackingService(
                    // 解密私钥
                    val decryptedPrivateKey = decryptPrivateKey(account)

-                    // 获取费率（根据 Polymarket Maker Rebates Program 要求）
-                    val feeRateResult = clobService.getFeeRate(tokenId)
-                    val feeRateBps = if (feeRateResult.isSuccess) {
-                        feeRateResult.getOrNull()?.toString() ?: "0"
-                    } else {
-                        logger.warn("获取费率失败，使用默认值 0: tokenId=$tokenId, error=${feeRateResult.exceptionOrNull()?.message}")
-                        "0"
-                    }
-
-                    logger.info("准备创建买入订单: copyTradingId=${copyTrading.id}, tradeId=${trade.id}, leaderPrice=${trade.price}, tolerance=${copyTrading.priceTolerance}, calculatedPrice=$buyPrice, quantity=$finalBuyQuantity, baseFee=$feeRateBps")
+                    logger.info("准备创建买入订单: copyTradingId=${copyTrading.id}, tradeId=${trade.id}, leaderPrice=${trade.price}, tolerance=${copyTrading.priceTolerance}, calculatedPrice=$buyPrice, quantity=$finalBuyQuantity")

                    // Neg Risk 市场需用 Neg Risk Exchange 签约，否则服务端返回 invalid signature
                    val negRisk = marketService.getNegRiskByConditionId(effectiveMarketId) == true
@@ -594,7 +585,6 @@ open class CopyOrderTrackingService(
                        owner = account.apiKey,
                        copyTradingId = copyTrading.id!!,
                        tradeId = trade.id,
-                        feeRateBps = feeRateBps,
                        signatureType = orderSigningService.getSignatureTypeForWalletType(account.walletType)
                    )

@@ -1018,15 +1008,6 @@ open class CopyOrderTrackingService(
        // 8. 解密私钥（在方法开始时解密一次，后续复用）
        val decryptedPrivateKey = decryptPrivateKey(account)

-        // 获取费率（根据 Polymarket Maker Rebates Program 要求）
-        val feeRateResult = clobService.getFeeRate(tokenId)
-        val feeRateBps = if (feeRateResult.isSuccess) {
-            feeRateResult.getOrNull()?.toString() ?: "0"
-        } else {
-            logger.warn("获取费率失败，使用默认值 0: tokenId=$tokenId, error=${feeRateResult.exceptionOrNull()?.message}")
-            "0"
-        }
-
        // 9. Neg Risk 市场需用 Neg Risk Exchange 签约
        val negRiskSell = marketService.getNegRiskByConditionId(leaderSellTrade.market) == true
        val exchangeContractSell = orderSigningService.getExchangeContract(negRiskSell)
@@ -1042,9 +1023,6 @@ open class CopyOrderTrackingService(
                price = sellPrice.toString(),
                size = totalMatched.toString(),
                signatureType = orderSigningService.getSignatureTypeForWalletType(account.walletType),
-                nonce = "0",
-                feeRateBps = feeRateBps,  // 使用动态获取的费率
-                expiration = "0",
                exchangeContract = exchangeContractSell
            )
        } catch (e: Exception) {
@@ -1058,8 +1036,7 @@ open class CopyOrderTrackingService(
        val orderRequest = NewOrderRequest(
            order = signedOrder,
            owner = account.apiKey,
-            orderType = "FAK",  // Fill-And-Kill
-            deferExec = false
+            orderType = "FAK"  // Fill-And-Kill
        )

        // 12. 创建带认证的CLOB API客户端（使用解密后的凭证）
@@ -1084,7 +1061,6 @@ open class CopyOrderTrackingService(
            owner = account.apiKey,
            copyTradingId = copyTrading.id,
            tradeId = leaderSellTrade.id,
-            feeRateBps = feeRateBps,
            signatureType = orderSigningService.getSignatureTypeForWalletType(account.walletType)
        )

@@ -1179,7 +1155,6 @@ open class CopyOrderTrackingService(
     * @param owner API Key（用于owner字段）
     * @param copyTradingId 跟单配置ID（用于日志）
     * @param tradeId Leader 交易ID（用于日志）
-     * @param feeRateBps 费率基点（从API动态获取）
     * @param signatureType 签名类型（1=Magic, 2=Safe）
     * @return 成功返回订单ID，失败返回异常
     */
@@ -1196,7 +1171,6 @@ open class CopyOrderTrackingService(
        owner: String,
        copyTradingId: Long,
        tradeId: String,
-        feeRateBps: String,
        signatureType: Int
    ): Result<String> {
        var lastError: Exception? = null
@@ -1213,9 +1187,6 @@ open class CopyOrderTrackingService(
                    price = price,
                    size = size,
                    signatureType = signatureType,
-                    nonce = "0",
-                    feeRateBps = feeRateBps,  // 使用动态获取的费率
-                    expiration = "0",
                    exchangeContract = exchangeContract
                )

@@ -1232,8 +1203,7 @@ open class CopyOrderTrackingService(
                val orderRequest = NewOrderRequest(
                    order = signedOrder,
                    owner = owner,
-                    orderType = "FAK",  // Fill-And-Kill
-                    deferExec = false
+                    orderType = "FAK"  // Fill-And-Kill
                )

                // 调用 API 创建订单
@@ -7,8 +7,10 @@ import com.wrbug.polymarketbot.service.common.MarketService
 import com.wrbug.polymarketbot.service.system.TelegramNotificationService
 import com.wrbug.polymarketbot.util.RetrofitFactory
 import com.wrbug.polymarketbot.util.CryptoUtils
-import com.wrbug.polymarketbot.util.toSafeBigDecimal
+import com.wrbug.polymarketbot.util.div
+import com.wrbug.polymarketbot.util.gt
 import com.wrbug.polymarketbot.util.multi
+import com.wrbug.polymarketbot.util.toSafeBigDecimal
 import kotlinx.coroutines.*
 import org.slf4j.LoggerFactory
 import org.springframework.boot.context.event.ApplicationReadyEvent
@@ -38,7 +40,8 @@ class OrderStatusUpdateService(
    private val cryptoUtils: CryptoUtils,
    private val trackingService: CopyOrderTrackingService,
    private val marketService: MarketService,  // 市场信息服务
-    private val telegramNotificationService: TelegramNotificationService?
+    private val telegramNotificationService: TelegramNotificationService?,
+    private val blockchainService: com.wrbug.polymarketbot.service.common.BlockchainService
 ) : ApplicationContextAware {

    private val logger = LoggerFactory.getLogger(OrderStatusUpdateService::class.java)
@@ -555,11 +558,13 @@ class OrderStatusUpdateService(

                        logger.info("更新卖出订单价格成功: orderId=${record.sellOrderId}, 原价格=${record.sellPrice}, 新价格=$actualSellPrice")

-                        // 发送通知（使用实际价格）
+                        // 发送通知（使用实际成交价）
                        sendSellOrderNotification(
                            record = updatedRecord,
                            actualPrice = actualSellPrice.toString(),
                            actualSize = record.totalMatchedQuantity.toString(),
+                            avgFilledPrice = actualSellPrice.toString(),
+                            filled = record.totalMatchedQuantity.toString(),
                            account = account,
                            copyTrading = copyTrading,
                            clobApi = clobApi,
@@ -588,11 +593,13 @@ class OrderStatusUpdateService(

                        logger.debug("卖出订单价格无需更新: orderId=${record.sellOrderId}, price=$actualSellPrice")

-                        // 发送通知
+                        // 发送通知（使用实际成交价）
                        sendSellOrderNotification(
                            record = updatedRecord,
                            actualPrice = actualSellPrice.toString(),
                            actualSize = record.totalMatchedQuantity.toString(),
+                            avgFilledPrice = actualSellPrice.toString(),
+                            filled = record.totalMatchedQuantity.toString(),
                            account = account,
                            copyTrading = copyTrading,
                            clobApi = clobApi,
@@ -808,9 +815,11 @@ class OrderStatusUpdateService(
                    val actualPrice = orderDetail.price?.toSafeBigDecimal() ?: order.price
                    val actualSize = orderDetail.originalSize?.toSafeBigDecimal() ?: order.quantity
                    val actualOutcome = orderDetail.outcome
+                    // 使用交易所订单的实际创建时间（API返回秒级，转为毫秒）
+                    val actualCreatedAt = if (orderDetail.createdAt > 0) orderDetail.createdAt * 1000 else order.createdAt

                    // 更新订单数据（如果实际数据与临时数据不同）
-                    val needUpdate = actualPrice != order.price || actualSize != order.quantity
+                    val needUpdate = actualPrice != order.price || actualSize != order.quantity || actualCreatedAt != order.createdAt

                    // 先保存更新后的订单，标记 notificationSent = true
                    // 这样可以防止其他并发任务重复发送通知
@@ -831,7 +840,7 @@ class OrderStatusUpdateService(
                        status = order.status,
                        notificationSent = true,  // 标记为已发送通知
                        source = order.source,  // 保留原始订单来源
-                        createdAt = order.createdAt,
+                        createdAt = actualCreatedAt,
                        updatedAt = System.currentTimeMillis()
                    )

@@ -844,12 +853,24 @@ class OrderStatusUpdateService(
                        logger.debug("买入订单数据无需更新: orderId=${order.buyOrderId}")
                    }

-                    // 发送通知（使用实际数据）
+                    // 有成交时按公式计算实际成交价：original_size * price / size_matched，数量用 size_matched
+                    val sizeMatchedDec = orderDetail.sizeMatched.toSafeBigDecimal()
+                    val avgFilledPriceStr = if (sizeMatchedDec.gt(BigDecimal.ZERO)) {
+                        orderDetail.originalSize.toSafeBigDecimal()
+                            .multi(orderDetail.price)
+                            .div(sizeMatchedDec, 18)
+                            .toPlainString()
+                    } else null
+                    val filledSize = orderDetail.sizeMatched
+
+                    // 发送通知（使用实际数据，优先展示平均成交价）
                    sendBuyOrderNotification(
                        order = updatedOrder,
                        actualPrice = actualPrice.toString(),
                        actualSize = actualSize.toString(),
                        actualOutcome = actualOutcome,
+                        avgFilledPrice = avgFilledPriceStr,
+                        filled = filledSize,
                        account = account,
                        copyTrading = copyTrading,
                        clobApi = clobApi,
@@ -876,6 +897,8 @@ class OrderStatusUpdateService(
        actualPrice: String? = null,
        actualSize: String? = null,
        actualOutcome: String? = null,
+        avgFilledPrice: String? = null,  // 平均成交价（有成交时用于 TG 展示）
+        filled: String? = null,  // 已成交数量（与 avgFilledPrice 一起用于金额计算）
        account: Account? = null,
        copyTrading: CopyTrading? = null,
        clobApi: PolymarketClobApi? = null,
@@ -930,14 +953,24 @@ class OrderStatusUpdateService(
                    null
                }

-            // 发送通知
+            // 查询可用余额
+            val availableBalance = try {
+                blockchainService.getUsdcBalance(finalAccount.walletAddress, finalAccount.proxyAddress).getOrNull()
+            } catch (e: Exception) {
+                logger.warn("查询可用余额失败: accountId=${finalAccount.id}, ${e.message}")
+                null
+            }
+
+            // 发送通知（优先使用平均成交价展示）
            telegramNotificationService.sendOrderSuccessNotification(
                orderId = order.buyOrderId,
                marketTitle = marketTitle,
                marketId = order.marketId,
                marketSlug = market?.eventSlug,  // 跳转用的 slug
                side = "BUY",
-                price = actualPrice ?: order.price.toString(),  // 使用实际价格或临时价格
+                price = actualPrice ?: order.price.toString(),  // 限价，无 avgFilledPrice 时展示
+                avgFilledPrice = avgFilledPrice,
+                filled = filled,
                size = actualSize ?: order.quantity.toString(),  // 使用实际数量或临时数量
                outcome = actualOutcome,  // 使用实际 outcome
                accountName = finalAccount.accountName,
@@ -950,7 +983,8 @@ class OrderStatusUpdateService(
                locale = locale,
                leaderName = leaderName,
                configName = configName,
-                orderTime = orderCreatedAt  // 使用订单创建时间
+                orderTime = orderCreatedAt,  // 使用订单创建时间
+                availableBalance = availableBalance
            )

            logger.info("买入订单通知已发送: orderId=${order.buyOrderId}, copyTradingId=${order.copyTradingId}")
@@ -969,6 +1003,8 @@ class OrderStatusUpdateService(
        actualPrice: String? = null,
        actualSize: String? = null,
        actualOutcome: String? = null,
+        avgFilledPrice: String? = null,  // 平均成交价（有成交时用于 TG 展示）
+        filled: String? = null,  // 已成交数量（与 avgFilledPrice 一起用于金额计算）
        account: Account? = null,
        copyTrading: CopyTrading? = null,
        clobApi: PolymarketClobApi? = null,
@@ -1023,14 +1059,24 @@ class OrderStatusUpdateService(
                    null
                }

-            // 发送通知
+            // 查询可用余额
+            val availableBalance = try {
+                blockchainService.getUsdcBalance(finalAccount.walletAddress, finalAccount.proxyAddress).getOrNull()
+            } catch (e: Exception) {
+                logger.warn("查询可用余额失败: accountId=${finalAccount.id}, ${e.message}")
+                null
+            }
+
+            // 发送通知（优先使用平均成交价展示）
            telegramNotificationService.sendOrderSuccessNotification(
                orderId = record.sellOrderId,
                marketTitle = marketTitle,
                marketId = record.marketId,
                marketSlug = market?.eventSlug,  // 跳转用的 slug
                side = "SELL",
-                price = actualPrice ?: record.sellPrice.toString(),  // 使用实际价格或临时价格
+                price = actualPrice ?: record.sellPrice.toString(),  // 限价，无 avgFilledPrice 时展示
+                avgFilledPrice = avgFilledPrice,
+                filled = filled,
                size = actualSize ?: record.totalMatchedQuantity.toString(),  // 使用实际数量或临时数量
                outcome = actualOutcome,  // 使用实际 outcome
                accountName = finalAccount.accountName,
@@ -1043,7 +1089,8 @@ class OrderStatusUpdateService(
                locale = locale,
                leaderName = leaderName,
                configName = configName,
-                orderTime = orderCreatedAt  // 使用订单创建时间
+                orderTime = orderCreatedAt,  // 使用订单创建时间
+                availableBalance = availableBalance
            )

            logger.info("卖出订单通知已发送: orderId=${record.sellOrderId}, copyTradingId=${record.copyTradingId}")
@@ -147,7 +147,8 @@ class CryptoTailMonitorService(

            val account = accountRepository.findById(strategy.accountId).orElse(null)
            val nowSeconds = System.currentTimeMillis() / 1000
-            val periodStartUnix = (nowSeconds / strategy.intervalSeconds) * strategy.intervalSeconds
+            val periodStartUnix = request.periodStartUnix
+                ?: ((nowSeconds / strategy.intervalSeconds) * strategy.intervalSeconds)

            // 获取市场信息
            val slug = "${strategy.marketSlugPrefix}-$periodStartUnix"
@@ -207,7 +208,9 @@ class CryptoTailMonitorService(
                tokenIdUp = tokenIds.getOrNull(0),
                tokenIdDown = tokenIds.getOrNull(1),
                currentTimestamp = System.currentTimeMillis(),
-                enabled = strategy.enabled
+                enabled = strategy.enabled,
+                amountMode = strategy.amountMode,
+                amountValue = strategy.amountValue.toPlainString()
            )

            Result.success(response)
@@ -6,6 +6,10 @@ import com.wrbug.polymarketbot.repository.CryptoTailStrategyRepository
 import com.wrbug.polymarketbot.repository.CryptoTailStrategyTriggerRepository
 import com.wrbug.polymarketbot.service.common.MarketService
 import com.wrbug.polymarketbot.service.system.TelegramNotificationService
+import com.wrbug.polymarketbot.util.div
+import com.wrbug.polymarketbot.util.gt
+import com.wrbug.polymarketbot.util.multi
+import com.wrbug.polymarketbot.util.toSafeBigDecimal
 import com.wrbug.polymarketbot.util.CryptoUtils
 import com.wrbug.polymarketbot.util.RetrofitFactory
 import kotlinx.coroutines.CoroutineScope
@@ -20,6 +24,7 @@ import org.springframework.scheduling.annotation.Scheduled
 import org.springframework.stereotype.Service
 import org.springframework.transaction.annotation.Transactional
 import jakarta.annotation.PreDestroy
+import java.math.BigDecimal

 /**
 * 加密价差策略订单 TG 通知轮询服务（与跟单一致）
@@ -128,6 +133,15 @@ class CryptoTailOrderNotificationPollingService(
        val market = marketService.getMarket(order.market)
        val marketTitle = trigger.marketTitle?.takeIf { it.isNotBlank() } ?: market?.title ?: order.market
        val orderTimeMs = if (order.createdAt < 1_000_000_000_000L) order.createdAt * 1000 else order.createdAt
+        // 实际成交价 = original_size * price / size_matched，数量用 size_matched
+        val sizeMatchedDec = order.sizeMatched.toSafeBigDecimal()
+        val avgFilledPriceStr = if (sizeMatchedDec.gt(BigDecimal.ZERO)) {
+            order.originalSize.toSafeBigDecimal()
+                .multi(order.price)
+                .div(sizeMatchedDec, 18)
+                .toPlainString()
+        } else null
+        val filledSize = order.sizeMatched
        telegramNotificationService.sendCryptoTailOrderSuccessNotification(
            orderId = orderId,
            marketTitle = marketTitle,
@@ -137,6 +151,8 @@ class CryptoTailOrderNotificationPollingService(
            outcome = order.outcome,
            price = order.price,
            size = order.originalSize,
+            avgFilledPrice = avgFilledPriceStr,
+            filled = filledSize,
            strategyName = strategy.name,
            accountName = account.accountName,
            walletAddress = account.walletAddress,
@@ -3,6 +3,9 @@ package com.wrbug.polymarketbot.service.cryptotail
 import com.wrbug.polymarketbot.api.GammaEventBySlugResponse
 import com.wrbug.polymarketbot.api.NewOrderRequest
 import com.wrbug.polymarketbot.api.PolymarketClobApi
+import com.wrbug.polymarketbot.dto.CryptoTailManualOrderRequest
+import com.wrbug.polymarketbot.dto.CryptoTailManualOrderResponse
+import com.wrbug.polymarketbot.dto.ManualOrderDetails
 import com.wrbug.polymarketbot.entity.Account
 import com.wrbug.polymarketbot.entity.CryptoTailStrategy
 import com.wrbug.polymarketbot.entity.CryptoTailStrategyTrigger
@@ -43,6 +46,9 @@ private const val SPREAD_MAX_PRICE_ADJUSTMENT = "0.02"
 /** 数量小数位数，与 OrderSigningService 的 roundConfig.size 一致 */
 private const val SIZE_DECIMAL_SCALE = 2

+/** 单笔下单最小 USDC 金额（平台限制），RATIO 模式计算值低于此值时按此值下单 */
+private val MIN_ORDER_USDC = BigDecimal("1")
+
 /**
 * 周期内预置上下文：账户、解密凭证、费率、签名类型、CLOB 客户端；不含预签订单。
 * 触发时 FIXED/RATIO 均按 outcomeIndex 计算 size 并签名提交。
@@ -55,7 +61,6 @@ private data class PeriodContext(
    val apiSecretDecrypted: String,
    val apiPassphraseDecrypted: String,
    val clobApi: PolymarketClobApi,
-    val feeRateByTokenId: Map<String, String>,
    val signatureType: Int,
    val tokenIds: List<String>,
    val marketTitle: String?
@@ -146,12 +151,9 @@ class CryptoTailStrategyExecutionService(
        }

        val clobApi = retrofitFactory.createClobApi(account.apiKey, apiSecret, apiPassphrase, account.walletAddress)
-        val feeRateByTokenId = tokenIds.associate { tokenId ->
-            tokenId to (clobService.getFeeRate(tokenId).getOrNull()?.toString() ?: "0")
-        }
        val signatureType = orderSigningService.getSignatureTypeForWalletType(account.walletType)

-        if (strategy.amountMode.uppercase() != "RATIO" && strategy.amountValue < BigDecimal("1")) return null
+        if (strategy.amountMode.uppercase() != "RATIO" && strategy.amountValue < MIN_ORDER_USDC) return null

        val ctx = PeriodContext(
            strategy = strategy,
@@ -161,7 +163,6 @@ class CryptoTailStrategyExecutionService(
            apiSecretDecrypted = apiSecret,
            apiPassphraseDecrypted = apiPassphrase,
            clobApi = clobApi,
-            feeRateByTokenId = feeRateByTokenId,
            signatureType = signatureType,
            tokenIds = tokenIds,
            marketTitle = marketTitle
@@ -334,29 +335,36 @@ class CryptoTailStrategyExecutionService(
        val ctx = getOrInvalidatePeriodContext(strategy, periodStartUnix)

        if (ctx != null) {
-            val amountUsdc = when (strategy.amountMode.uppercase()) {
+            var availableBalanceForRatio = BigDecimal.ZERO
+            var amountUsdc = when (strategy.amountMode.uppercase()) {
                "RATIO" -> {
                    val balanceResult = accountService.getAccountBalance(ctx.account.id)
                    val availableBalance =
                        balanceResult.getOrNull()?.availableBalance?.toSafeBigDecimal() ?: BigDecimal.ZERO
+                    availableBalanceForRatio = availableBalance
                    availableBalance.multiply(strategy.amountValue).divide(BigDecimal("100"), 18, RoundingMode.DOWN)
                }

                else -> strategy.amountValue
            }
-            if (amountUsdc < BigDecimal("1")) {
-                saveTriggerRecord(
-                    strategy,
-                    periodStartUnix,
-                    marketTitle,
-                    outcomeIndex,
-                    triggerPrice,
-                    amountUsdc,
-                    null,
-                    "fail",
-                    "投入金额不足"
-                )
-                return
+            if (amountUsdc < MIN_ORDER_USDC) {
+                val amountMode = strategy.amountMode.uppercase()
+                if (amountMode == "RATIO" && availableBalanceForRatio >= MIN_ORDER_USDC) {
+                    amountUsdc = MIN_ORDER_USDC
+                } else {
+                    saveTriggerRecord(
+                        strategy,
+                        periodStartUnix,
+                        marketTitle,
+                        outcomeIndex,
+                        triggerPrice,
+                        amountUsdc,
+                        null,
+                        "fail",
+                        "投入金额不足"
+                    )
+                    return
+                }
            }

            val tokenId = tokenIds.getOrNull(outcomeIndex) ?: run {
@@ -384,7 +392,6 @@ class CryptoTailStrategyExecutionService(
            }
            val priceStr = price.toPlainString()
            val size = computeSize(amountUsdc, price)
-            val feeRateBps = ctx.feeRateByTokenId[tokenId] ?: "0"
            val signedOrder = orderSigningService.createAndSignOrder(
                privateKey = ctx.decryptedPrivateKey,
                makerAddress = ctx.account.proxyAddress,
@@ -392,16 +399,12 @@ class CryptoTailStrategyExecutionService(
                side = "BUY",
                price = priceStr,
                size = size,
-                signatureType = ctx.signatureType,
-                nonce = "0",
-                feeRateBps = feeRateBps,
-                expiration = "0"
+                signatureType = ctx.signatureType
            )
            val orderRequest = NewOrderRequest(
                order = signedOrder,
                owner = ctx.account.apiKey!!,
-                orderType = "FAK",
-                deferExec = false
+                orderType = "FAK"
            )
            submitOrderAndSaveRecord(
                ctx.clobApi,
@@ -411,7 +414,8 @@ class CryptoTailStrategyExecutionService(
                outcomeIndex,
                triggerPrice,
                amountUsdc,
-                orderRequest
+                orderRequest,
+                triggerType = "AUTO"
            )
            return
        }
@@ -427,7 +431,8 @@ class CryptoTailStrategyExecutionService(
        outcomeIndex: Int,
        triggerPrice: BigDecimal,
        amountUsdc: BigDecimal,
-        orderRequest: NewOrderRequest
+        orderRequest: NewOrderRequest,
+        triggerType: String = "AUTO"
    ) {
        var failReason: String? = null
        try {
@@ -444,9 +449,10 @@ class CryptoTailStrategyExecutionService(
                        amountUsdc,
                        body.orderId,
                        "success",
-                        null
+                        null,
+                        triggerType = triggerType
                    )
-                    logger.info("加密价差策略下单成功: strategyId=${strategy.id}, periodStartUnix=$periodStartUnix, outcomeIndex=$outcomeIndex, orderId=${body.orderId}")
+                    logger.info("加密价差策略下单成功: strategyId=${strategy.id}, periodStartUnix=$periodStartUnix, outcomeIndex=$outcomeIndex, orderId=${body.orderId}, triggerType=$triggerType")
                    return
                }
                failReason = body.errorMsg ?: "unknown"
@@ -467,7 +473,8 @@ class CryptoTailStrategyExecutionService(
            amountUsdc,
            null,
            "fail",
-            failReason
+            failReason,
+            triggerType = triggerType
        )
        logger.error("加密价差策略下单失败: strategyId=${strategy.id}, periodStartUnix=$periodStartUnix, reason=$failReason")
    }
@@ -514,23 +521,28 @@ class CryptoTailStrategyExecutionService(

        val balanceResult = accountService.getAccountBalance(account.id)
        val availableBalance = balanceResult.getOrNull()?.availableBalance?.toSafeBigDecimal() ?: BigDecimal.ZERO
-        val amountUsdc = when (strategy.amountMode.uppercase()) {
+        var amountUsdc = when (strategy.amountMode.uppercase()) {
            "RATIO" -> availableBalance.multiply(strategy.amountValue).divide(BigDecimal("100"), 18, RoundingMode.DOWN)
            else -> strategy.amountValue
        }
-        if (amountUsdc < BigDecimal("1")) {
-            saveTriggerRecord(
-                strategy,
-                periodStartUnix,
-                marketTitle,
-                outcomeIndex,
-                triggerPrice,
-                amountUsdc,
-                null,
-                "fail",
-                "投入金额不足"
-            )
-            return
+        if (amountUsdc < MIN_ORDER_USDC) {
+            val amountMode = strategy.amountMode.uppercase()
+            if (amountMode == "RATIO" && availableBalance >= MIN_ORDER_USDC) {
+                amountUsdc = MIN_ORDER_USDC
+            } else {
+                saveTriggerRecord(
+                    strategy,
+                    periodStartUnix,
+                    marketTitle,
+                    outcomeIndex,
+                    triggerPrice,
+                    amountUsdc,
+                    null,
+                    "fail",
+                    "投入金额不足"
+                )
+                return
+            }
        }

        val tokenId = tokenIds.getOrNull(outcomeIndex) ?: run {
@@ -587,7 +599,6 @@ class CryptoTailStrategyExecutionService(
            ""
        }
        val clobApi = retrofitFactory.createClobApi(account.apiKey, apiSecret, apiPassphrase, account.walletAddress)
-        val feeRateBps = clobService.getFeeRate(tokenId).getOrNull()?.toString() ?: "0"
        val signatureType = orderSigningService.getSignatureTypeForWalletType(account.walletType)

        val signedOrder = orderSigningService.createAndSignOrder(
@@ -597,16 +608,12 @@ class CryptoTailStrategyExecutionService(
            side = "BUY",
            price = priceStr,
            size = size,
-            signatureType = signatureType,
-            nonce = "0",
-            feeRateBps = feeRateBps,
-            expiration = "0"
+            signatureType = signatureType
        )
        val orderRequest = NewOrderRequest(
            order = signedOrder,
            owner = account.apiKey!!,
-            orderType = "FAK",
-            deferExec = false
+            orderType = "FAK"
        )
        submitOrderAndSaveRecord(
            clobApi,
@@ -650,7 +657,8 @@ class CryptoTailStrategyExecutionService(
        amountUsdc: BigDecimal,
        orderId: String?,
        status: String,
-        failReason: String?
+        failReason: String?,
+        triggerType: String = "AUTO"
    ) {
        val record = CryptoTailStrategyTrigger(
            strategyId = strategy.id!!,
@@ -661,11 +669,168 @@ class CryptoTailStrategyExecutionService(
            amountUsdc = amountUsdc,
            orderId = orderId,
            status = status,
-            failReason = failReason
+            failReason = failReason,
+            triggerType = triggerType
        )
        triggerRepository.save(record)
    }

+    /**
+     * 手动下单：用户主动触发下单，不检查任何条件，仅检查当前周期是否已下单
+     */
+    suspend fun manualOrder(request: CryptoTailManualOrderRequest): Result<CryptoTailManualOrderResponse> {
+        return try {
+            val strategy = strategyRepository.findById(request.strategyId).orElse(null)
+                ?: return Result.failure(IllegalArgumentException("策略不存在"))
+
+            val outcomeIndex = if (request.direction.uppercase() == "UP") 0 else 1
+
+            if (outcomeIndex < 0 || outcomeIndex >= request.tokenIds.size) {
+                return Result.failure(IllegalArgumentException("outcomeIndex 越界"))
+            }
+
+            val price = request.price.toSafeBigDecimal()
+            if (price <= BigDecimal.ZERO || price > BigDecimal.ONE) {
+                return Result.failure(IllegalArgumentException("价格必须在 0~1 之间"))
+            }
+            val priceRounded = price.setScale(4, RoundingMode.UP)
+
+            val size = request.size.toSafeBigDecimal()
+            if (size < BigDecimal.ONE) {
+                return Result.failure(IllegalArgumentException("数量不能少于 1"))
+            }
+
+            val amountUsdc = priceRounded.multi(size).setScale(2, RoundingMode.HALF_UP)
+            if (amountUsdc < BigDecimal.ONE) {
+                return Result.failure(IllegalArgumentException("总金额不能少于 \$1"))
+            }
+
+            val mutex = getTriggerMutex(strategy.id!!, request.periodStartUnix)
+            mutex.withLock {
+                if (triggerRepository.findByStrategyIdAndPeriodStartUnix(
+                        strategy.id!!,
+                        request.periodStartUnix
+                    ) != null
+                ) {
+                    return@withLock Result.failure(IllegalArgumentException("当前周期已下单"))
+                }
+
+                var ctx = getOrInvalidatePeriodContext(strategy, request.periodStartUnix)
+                if (ctx == null) {
+                    ctx = ensurePeriodContext(
+                        strategy,
+                        request.periodStartUnix,
+                        request.tokenIds,
+                        request.marketTitle.ifBlank { null }
+                    )
+                }
+                if (ctx != null) {
+                    val tokenId = request.tokenIds.getOrNull(outcomeIndex)
+                        ?: return@withLock Result.failure(IllegalArgumentException("tokenIds 越界"))
+
+                    val priceStr = priceRounded.toPlainString()
+                    val sizeStr = size.toPlainString()
+
+                    val signedOrder = orderSigningService.createAndSignOrder(
+                        privateKey = ctx.decryptedPrivateKey,
+                        makerAddress = ctx.account.proxyAddress,
+                        tokenId = tokenId,
+                        side = "BUY",
+                        price = priceStr,
+                        size = sizeStr,
+                        signatureType = ctx.signatureType
+                    )
+
+                    val orderRequest = NewOrderRequest(
+                        order = signedOrder,
+                        owner = ctx.account.apiKey!!,
+                        orderType = "FAK"
+                    )
+
+                    val orderResult = submitOrderForManualOrder(
+                        ctx.clobApi,
+                        strategy,
+                        request.periodStartUnix,
+                        request.marketTitle,
+                        outcomeIndex,
+                        priceRounded,
+                        amountUsdc,
+                        orderRequest
+                    )
+
+                    orderResult.fold(
+                        onSuccess = { orderId ->
+                            Result.success(
+                                CryptoTailManualOrderResponse(
+                                    success = true,
+                                    orderId = orderId,
+                                    message = "下单成功",
+                                    orderDetails = ManualOrderDetails(
+                                        strategyId = strategy.id!!,
+                                        direction = request.direction,
+                                        price = priceStr,
+                                        size = sizeStr,
+                                        totalAmount = amountUsdc.toPlainString()
+                                    )
+                                )
+                            )
+                        },
+                        onFailure = { e ->
+                            Result.failure(e)
+                        }
+                    )
+                } else {
+                    Result.failure(IllegalArgumentException("账户未配置或凭证不足"))
+                }
+            }
+        } catch (e: Exception) {
+            logger.error("手动下单异常: strategyId=${request.strategyId}, ${e.message}", e)
+            Result.failure(e)
+        }
+    }
+
+    private suspend fun submitOrderForManualOrder(
+        clobApi: PolymarketClobApi,
+        strategy: CryptoTailStrategy,
+        periodStartUnix: Long,
+        marketTitle: String?,
+        outcomeIndex: Int,
+        price: BigDecimal,
+        amountUsdc: BigDecimal,
+        orderRequest: NewOrderRequest
+    ): Result<String> {
+        return try {
+            val response = clobApi.createOrder(orderRequest)
+            if (response.isSuccessful && response.body() != null) {
+                val body = response.body()!!
+                if (body.success && body.orderId != null) {
+                    saveTriggerRecord(
+                        strategy,
+                        periodStartUnix,
+                        marketTitle,
+                        outcomeIndex,
+                        price,
+                        amountUsdc,
+                        body.orderId,
+                        "success",
+                        null,
+                        triggerType = "MANUAL"
+                    )
+                    logger.info("手动下单成功: strategyId=${strategy.id}, periodStartUnix=$periodStartUnix, outcomeIndex=$outcomeIndex, orderId=${body.orderId}")
+                    Result.success(body.orderId)
+                } else {
+                    Result.failure(Exception(body.errorMsg ?: "unknown"))
+                }
+            } else {
+                val errorBody = response.errorBody()?.string().orEmpty()
+                Result.failure(Exception(errorBody.ifEmpty { "请求失败" }))
+            }
+        } catch (e: Exception) {
+            logger.error("手动下单异常: strategyId=${strategy.id}, periodStartUnix=$periodStartUnix", e)
+            Result.failure(e)
+        }
+    }
+
    @PreDestroy
    fun destroy() {
        // 清理所有周期上下文缓存，避免敏感信息（明文私钥、API Secret）在内存中保留
@@ -9,6 +9,7 @@ import com.wrbug.polymarketbot.enums.SpreadDirection
 import com.wrbug.polymarketbot.repository.CryptoTailStrategyRepository
 import com.wrbug.polymarketbot.repository.CryptoTailStrategyTriggerRepository
 import com.wrbug.polymarketbot.event.CryptoTailStrategyChangedEvent
+import com.wrbug.polymarketbot.util.gt
 import com.wrbug.polymarketbot.util.toSafeBigDecimal
 import org.slf4j.LoggerFactory
 import org.springframework.context.ApplicationEventPublisher
@@ -220,6 +221,61 @@ class CryptoTailStrategyService(
        }
    }

+    fun getPnlCurve(request: CryptoTailPnlCurveRequest): Result<CryptoTailPnlCurveResponse> {
+        return try {
+            val strategy = strategyRepository.findById(request.strategyId).orElse(null)
+                ?: return Result.failure(IllegalArgumentException(ErrorCode.CRYPTO_TAIL_STRATEGY_NOT_FOUND.messageKey))
+            val start = request.startDate ?: 0L
+            val end = request.endDate ?: Long.MAX_VALUE
+            val triggers = triggerRepository.findResolvedByStrategyIdAndTimeRangeOrderBySettledAsc(
+                request.strategyId, start, end
+            )
+            var cumulative = BigDecimal.ZERO
+            var peak = BigDecimal.ZERO
+            var maxDrawdown = BigDecimal.ZERO
+            var winCountInRange = 0L
+            val curveData = triggers.map { t ->
+                val pnl = t.realizedPnl ?: BigDecimal.ZERO
+                cumulative = cumulative.add(pnl)
+                if (cumulative.gt(peak)) peak = cumulative
+                val drawdown = peak.subtract(cumulative)
+                if (drawdown.gt(maxDrawdown)) maxDrawdown = drawdown
+                if (t.winnerOutcomeIndex != null && t.outcomeIndex == t.winnerOutcomeIndex) winCountInRange++
+                val ts = t.settledAt ?: t.createdAt
+                CryptoTailPnlCurvePoint(
+                    timestamp = ts,
+                    cumulativePnl = cumulative.toPlainString(),
+                    pointPnl = pnl.toPlainString(),
+                    settledCount = 0L
+                )
+            }.mapIndexed { index, p ->
+                p.copy(settledCount = (index + 1).toLong())
+            }
+            val totalPnl = if (curveData.isEmpty()) BigDecimal.ZERO else curveData.last().cumulativePnl.toSafeBigDecimal()
+            val settledCountInRange = curveData.size.toLong()
+            val winRateStr = if (settledCountInRange > 0L) {
+                BigDecimal(winCountInRange).divide(BigDecimal(settledCountInRange), 4, java.math.RoundingMode.HALF_UP).toPlainString()
+            } else null
+            Result.success(
+                CryptoTailPnlCurveResponse(
+                    strategyId = request.strategyId,
+                    strategyName = strategy.name ?: strategy.marketSlugPrefix,
+                    totalRealizedPnl = totalPnl.toPlainString(),
+                    settledCount = settledCountInRange,
+                    winCount = winCountInRange,
+                    winRate = winRateStr,
+                    maxDrawdown = if (maxDrawdown.compareTo(BigDecimal.ZERO) > 0) maxDrawdown.toPlainString() else null,
+                    curveData = curveData
+                )
+            )
+        } catch (e: IllegalArgumentException) {
+            Result.failure(e)
+        } catch (e: Exception) {
+            logger.error("查询收益曲线失败: ${e.message}", e)
+            Result.failure(e)
+        }
+    }
+
    fun getTriggerRecords(request: CryptoTailStrategyTriggerListRequest): Result<CryptoTailStrategyTriggerListResponse> {
        return try {
            val page = PageRequest.of((request.page - 1).coerceAtLeast(0), request.pageSize.coerceIn(1, 100))
@@ -0,0 +1,457 @@
+package com.wrbug.polymarketbot.service.system
+
+import com.wrbug.polymarketbot.dto.*
+import com.wrbug.polymarketbot.entity.NotificationTemplate
+import com.wrbug.polymarketbot.repository.NotificationTemplateRepository
+import org.slf4j.LoggerFactory
+import org.springframework.context.annotation.Lazy
+import org.springframework.stereotype.Service
+import org.springframework.transaction.annotation.Transactional
+
+/**
+ * 消息模板服务
+ * 负责管理消息模板、渲染模板、提供变量信息
+ */
+@Service
+class NotificationTemplateService(
+    private val templateRepository: NotificationTemplateRepository,
+    @Lazy private val telegramNotificationService: TelegramNotificationService
+) {
+    private val logger = LoggerFactory.getLogger(NotificationTemplateService::class.java)
+
+    companion object {
+        // 模板类型定义
+        val TEMPLATE_TYPES = mapOf(
+            "ORDER_SUCCESS" to TemplateTypeInfoDto(
+                type = "ORDER_SUCCESS",
+                name = "订单成功通知",
+                description = "订单创建成功时发送的通知"
+            ),
+            "ORDER_FAILED" to TemplateTypeInfoDto(
+                type = "ORDER_FAILED",
+                name = "订单失败通知",
+                description = "订单创建失败时发送的通知"
+            ),
+            "ORDER_FILTERED" to TemplateTypeInfoDto(
+                type = "ORDER_FILTERED",
+                name = "订单过滤通知",
+                description = "订单被风控过滤时发送的通知"
+            ),
+            "CRYPTO_TAIL_SUCCESS" to TemplateTypeInfoDto(
+                type = "CRYPTO_TAIL_SUCCESS",
+                name = "加密价差策略成功通知",
+                description = "加密价差策略下单成功时发送的通知"
+            ),
+            "REDEEM_SUCCESS" to TemplateTypeInfoDto(
+                type = "REDEEM_SUCCESS",
+                name = "仓位赎回成功通知",
+                description = "仓位赎回成功时发送的通知"
+            ),
+            "REDEEM_NO_RETURN" to TemplateTypeInfoDto(
+                type = "REDEEM_NO_RETURN",
+                name = "仓位结算（无收益）通知",
+                description = "仓位结算但无收益时发送的通知"
+            )
+        )
+
+        // 变量分类
+        val VARIABLE_CATEGORIES = listOf(
+            TemplateVariableCategoryDto("common", 0),
+            TemplateVariableCategoryDto("order", 10),
+            TemplateVariableCategoryDto("copy_trading", 20),
+            TemplateVariableCategoryDto("redeem", 30),
+            TemplateVariableCategoryDto("error", 40),
+            TemplateVariableCategoryDto("filter", 50),
+            TemplateVariableCategoryDto("strategy", 60)
+        )
+
+        // 各模板类型可用的变量
+        val TEMPLATE_VARIABLES = mapOf(
+            "ORDER_SUCCESS" to listOf(
+                // 通用变量
+                TemplateVariableDto("account_name", "common", 1),
+                TemplateVariableDto("wallet_address", "common", 2),
+                TemplateVariableDto("time", "common", 3),
+                // 订单变量
+                TemplateVariableDto("order_id", "order", 10),
+                TemplateVariableDto("market_title", "order", 11),
+                TemplateVariableDto("market_link", "order", 12),
+                TemplateVariableDto("side", "order", 13),
+                TemplateVariableDto("outcome", "order", 14),
+                TemplateVariableDto("price", "order", 15),
+                TemplateVariableDto("quantity", "order", 16),
+                TemplateVariableDto("amount", "order", 17),
+                TemplateVariableDto("available_balance", "order", 18),
+                // 跟单变量
+                TemplateVariableDto("leader_name", "copy_trading", 21),
+                TemplateVariableDto("config_name", "copy_trading", 22)
+            ),
+            "ORDER_FAILED" to listOf(
+                // 通用变量
+                TemplateVariableDto("account_name", "common", 1),
+                TemplateVariableDto("wallet_address", "common", 2),
+                TemplateVariableDto("time", "common", 3),
+                // 订单变量
+                TemplateVariableDto("market_title", "order", 10),
+                TemplateVariableDto("market_link", "order", 11),
+                TemplateVariableDto("side", "order", 12),
+                TemplateVariableDto("outcome", "order", 13),
+                TemplateVariableDto("price", "order", 14),
+                TemplateVariableDto("quantity", "order", 15),
+                TemplateVariableDto("amount", "order", 16),
+                // 错误变量
+                TemplateVariableDto("error_message", "error", 20)
+            ),
+            "ORDER_FILTERED" to listOf(
+                // 通用变量
+                TemplateVariableDto("account_name", "common", 1),
+                TemplateVariableDto("wallet_address", "common", 2),
+                TemplateVariableDto("time", "common", 3),
+                // 订单变量
+                TemplateVariableDto("market_title", "order", 10),
+                TemplateVariableDto("market_link", "order", 11),
+                TemplateVariableDto("side", "order", 12),
+                TemplateVariableDto("outcome", "order", 13),
+                TemplateVariableDto("price", "order", 14),
+                TemplateVariableDto("quantity", "order", 15),
+                TemplateVariableDto("amount", "order", 16),
+                // 过滤变量
+                TemplateVariableDto("filter_type", "filter", 20),
+                TemplateVariableDto("filter_reason", "filter", 21)
+            ),
+            "CRYPTO_TAIL_SUCCESS" to listOf(
+                // 通用变量
+                TemplateVariableDto("account_name", "common", 1),
+                TemplateVariableDto("wallet_address", "common", 2),
+                TemplateVariableDto("time", "common", 3),
+                // 订单变量
+                TemplateVariableDto("order_id", "order", 10),
+                TemplateVariableDto("market_title", "order", 11),
+                TemplateVariableDto("market_link", "order", 12),
+                TemplateVariableDto("side", "order", 13),
+                TemplateVariableDto("outcome", "order", 14),
+                TemplateVariableDto("price", "order", 15),
+                TemplateVariableDto("quantity", "order", 16),
+                TemplateVariableDto("amount", "order", 17),
+                // 策略变量
+                TemplateVariableDto("strategy_name", "strategy", 20)
+            ),
+            "REDEEM_SUCCESS" to listOf(
+                // 通用变量
+                TemplateVariableDto("account_name", "common", 1),
+                TemplateVariableDto("wallet_address", "common", 2),
+                TemplateVariableDto("time", "common", 3),
+                // 赎回变量
+                TemplateVariableDto("transaction_hash", "redeem", 10),
+                TemplateVariableDto("total_value", "redeem", 11),
+                TemplateVariableDto("available_balance", "redeem", 12)
+            ),
+            "REDEEM_NO_RETURN" to listOf(
+                // 通用变量
+                TemplateVariableDto("account_name", "common", 1),
+                TemplateVariableDto("wallet_address", "common", 2),
+                TemplateVariableDto("time", "common", 3),
+                // 赎回变量
+                TemplateVariableDto("transaction_hash", "redeem", 10),
+                TemplateVariableDto("available_balance", "redeem", 11)
+            )
+        )
+
+        // 默认模板
+        val DEFAULT_TEMPLATES = mapOf(
+            "ORDER_SUCCESS" to """
+🚀 <b>订单创建成功</b>
+
+📊 <b>订单信息：</b>
+• 订单ID: <code>{{order_id}}</code>
+• 市场: <a href="{{market_link}}">{{market_title}}</a>
+• 市场方向: <b>{{outcome}}</b>
+• 方向: <b>{{side}}</b>
+• 价格: <code>{{price}}</code>
+• 数量: <code>{{quantity}}</code> shares
+• 金额: <code>${'$'}{{amount}}</code>
+• 账户: {{account_name}}
+• 可用余额: <code>${'$'}{{available_balance}}</code>
+
+⏰ 时间: <code>{{time}}</code>
+            """.trimIndent(),
+            "ORDER_FAILED" to """
+❌ <b>订单创建失败</b>
+
+📊 <b>订单信息：</b>
+• 市场: <a href="{{market_link}}">{{market_title}}</a>
+• 市场方向: <b>{{outcome}}</b>
+• 方向: <b>{{side}}</b>
+• 价格: <code>{{price}}</code>
+• 数量: <code>{{quantity}}</code> shares
+• 金额: <code>${'$'}{{amount}}</code>
+• 账户: {{account_name}}
+
+⚠️ <b>错误信息：</b>
+<code>{{error_message}}</code>
+
+⏰ 时间: <code>{{time}}</code>
+            """.trimIndent(),
+            "ORDER_FILTERED" to """
+🚫 <b>订单被过滤</b>
+
+📊 <b>订单信息：</b>
+• 市场: <a href="{{market_link}}">{{market_title}}</a>
+• 市场方向: <b>{{outcome}}</b>
+• 方向: <b>{{side}}</b>
+• 价格: <code>{{price}}</code>
+• 数量: <code>{{quantity}}</code> shares
+• 金额: <code>${'$'}{{amount}}</code>
+• 账户: {{account_name}}
+
+⚠️ <b>过滤类型：</b> <code>{{filter_type}}</code>
+
+📝 <b>过滤原因：</b>
+<code>{{filter_reason}}</code>
+
+⏰ 时间: <code>{{time}}</code>
+            """.trimIndent(),
+            "CRYPTO_TAIL_SUCCESS" to """
+🚀 <b>加密价差策略下单成功</b>
+
+📊 <b>订单信息：</b>
+• 订单ID: <code>{{order_id}}</code>
+• 策略: {{strategy_name}}
+• 市场: <a href="{{market_link}}">{{market_title}}</a>
+• 市场方向: <b>{{outcome}}</b>
+• 方向: <b>{{side}}</b>
+• 价格: <code>{{price}}</code>
+• 数量: <code>{{quantity}}</code> shares
+• 金额: <code>${'$'}{{amount}}</code>
+• 账户: {{account_name}}
+
+⏰ 时间: <code>{{time}}</code>
+            """.trimIndent(),
+            "REDEEM_SUCCESS" to """
+💸 <b>仓位赎回成功</b>
+
+📊 <b>赎回信息：</b>
+• 账户: {{account_name}}
+• 交易哈希: <code>{{transaction_hash}}</code>
+• 赎回总价值: <code>${'$'}{{total_value}}</code>
+• 可用余额: <code>${'$'}{{available_balance}}</code>
+
+⏰ 时间: <code>{{time}}</code>
+            """.trimIndent(),
+            "REDEEM_NO_RETURN" to """
+📋 <b>仓位已结算（无收益）</b>
+
+📊 <b>结算信息：</b>
+<i>市场已结算，您的预测未命中，赎回价值为 0。</i>
+
+• 账户: {{account_name}}
+• 交易哈希: <code>{{transaction_hash}}</code>
+• 可用余额: <code>${'$'}{{available_balance}}</code>
+
+⏰ 时间: <code>{{time}}</code>
+            """.trimIndent()
+        )
+    }
+
+    /**
+     * 获取所有模板类型
+     */
+    fun getTemplateTypes(): List<TemplateTypeInfoDto> {
+        return TEMPLATE_TYPES.values.toList()
+    }
+
+    /**
+     * 获取所有模板列表
+     */
+    fun getAllTemplates(): List<NotificationTemplateDto> {
+        return templateRepository.findAll().map { it.toDto() }
+    }
+
+    /**
+     * 获取单个模板
+     */
+    fun getTemplate(templateType: String): NotificationTemplateDto? {
+        return templateRepository.findByTemplateType(templateType)?.toDto()
+            ?: DEFAULT_TEMPLATES[templateType]?.let {
+                NotificationTemplateDto(
+                    templateType = templateType,
+                    templateContent = it,
+                    isDefault = true
+                )
+            }
+    }
+
+    /**
+     * 获取模板可用变量
+     */
+    fun getTemplateVariables(templateType: String): TemplateVariablesResponse? {
+        if (!TEMPLATE_TYPES.containsKey(templateType)) return null
+        val variables = TEMPLATE_VARIABLES[templateType] ?: emptyList()
+
+        // 获取使用的分类
+        val usedCategories = variables.map { it.category }.toSet()
+        val categories = VARIABLE_CATEGORIES.filter { usedCategories.contains(it.key) }
+
+        return TemplateVariablesResponse(
+            templateType = templateType,
+            categories = categories,
+            variables = variables
+        )
+    }
+
+    /**
+     * 更新模板
+     */
+    @Transactional
+    fun updateTemplate(templateType: String, content: String): NotificationTemplateDto {
+        val template = templateRepository.findByTemplateType(templateType)
+        val now = System.currentTimeMillis()
+
+        return if (template != null) {
+            template.templateContent = content
+            template.isDefault = false
+            template.updatedAt = now
+            templateRepository.save(template).toDto()
+        } else {
+            val newTemplate = NotificationTemplate(
+                templateType = templateType,
+                templateContent = content,
+                isDefault = false,
+                createdAt = now,
+                updatedAt = now
+            )
+            templateRepository.save(newTemplate).toDto()
+        }
+    }
+
+    /**
+     * 重置模板为默认
+     */
+    @Transactional
+    fun resetTemplate(templateType: String): NotificationTemplateDto? {
+        val defaultContent = DEFAULT_TEMPLATES[templateType] ?: return null
+        val template = templateRepository.findByTemplateType(templateType)
+        val now = System.currentTimeMillis()
+
+        return if (template != null) {
+            template.templateContent = defaultContent
+            template.isDefault = true
+            template.updatedAt = now
+            templateRepository.save(template).toDto()
+        } else {
+            val newTemplate = NotificationTemplate(
+                templateType = templateType,
+                templateContent = defaultContent,
+                isDefault = true,
+                createdAt = now,
+                updatedAt = now
+            )
+            templateRepository.save(newTemplate).toDto()
+        }
+    }
+
+    /**
+     * 渲染模板（按类型取模板内容后替换变量）
+     * 优化：先解析模版中需要的变量，只替换这些变量，未提供的变量使用 "-" 占位
+     */
+    fun renderTemplate(templateType: String, variables: Map<String, String>): String {
+        val template = getTemplate(templateType)
+        val content = template?.templateContent ?: DEFAULT_TEMPLATES[templateType] ?: ""
+        return renderTemplateContent(content, variables)
+    }
+
+    /**
+     * 对给定模板内容做变量替换（不查库）
+     * 优化：先解析模版中的变量占位符，只替换这些变量，未提供的变量使用 "-" 占位
+     */
+    fun renderTemplateContent(content: String, variables: Map<String, String>): String {
+        // 先解析模版中需要的变量
+        val requiredVariables = extractTemplateVariables(content)
+        
+        var result = content
+        // 只替换模版中实际使用的变量
+        requiredVariables.forEach { varName ->
+            val value = variables[varName]
+            result = result.replace("{{$varName}}", value ?: "-")
+        }
+        return result
+    }
+
+    /**
+     * 解析模版中使用的变量名
+     * @return 变量名列表（去重）
+     */
+    private fun extractTemplateVariables(content: String): Set<String> {
+        val regex = Regex("\\{\\{([^}]+)}}")
+        return regex.findAll(content)
+            .map { it.groupValues[1].trim() }
+            .toSet()
+    }
+
+    /**
+     * 根据模版需要的变量过滤输入变量
+     * 只保留模版中实际使用的变量，避免不必要的数据获取
+     */
+    fun filterVariablesForTemplate(templateType: String, variables: Map<String, String>): Map<String, String> {
+        val template = getTemplate(templateType)
+        val content = template?.templateContent ?: DEFAULT_TEMPLATES[templateType] ?: return emptyMap()
+        val requiredVariables = extractTemplateVariables(content)
+        return variables.filterKeys { it in requiredVariables }
+    }
+
+    /**
+     * 发送测试消息
+     */
+    suspend fun sendTestMessage(templateType: String, content: String? = null): Boolean {
+        val templateContent = content ?: getTemplate(templateType)?.templateContent ?: return false
+        val testVariables = generateTestVariables(templateType)
+        val message = renderTemplateContent(templateContent, testVariables)
+        return try {
+            telegramNotificationService.sendMessage(message)
+            true
+        } catch (e: Exception) {
+            logger.error("发送测试消息失败: ${e.message}", e)
+            false
+        }
+    }
+
+    /**
+     * 生成测试变量数据
+     */
+    private fun generateTestVariables(templateType: String): Map<String, String> {
+        return mapOf(
+            "account_name" to "测试账户",
+            "wallet_address" to "0x1234...5678",
+            "time" to "2024-01-15 12:30:00",
+            "order_id" to "12345678",
+            "market_title" to "测试市场标题",
+            "market_link" to "https://polymarket.com/event/test",
+            "side" to "买入",
+            "outcome" to "YES",
+            "price" to "0.55",
+            "quantity" to "100",
+            "amount" to "55.00",
+            "available_balance" to "1000.00",
+            "leader_name" to "测试Leader",
+            "config_name" to "测试配置",
+            "error_message" to "余额不足",
+            "filter_type" to "价差过大",
+            "filter_reason" to "当前市场价差为 5%，超过设定的 3% 限制",
+            "strategy_name" to "BTC价差策略",
+            "transaction_hash" to "0xabcd...efgh",
+            "total_value" to "100.00"
+        )
+    }
+
+    /**
+     * Entity 转 DTO
+     */
+    private fun NotificationTemplate.toDto() = NotificationTemplateDto(
+        id = id,
+        templateType = templateType,
+        templateContent = templateContent,
+        isDefault = isDefault,
+        createdAt = createdAt,
+        updatedAt = updatedAt
+    )
+}
@@ -39,8 +39,14 @@ class RelayClientService(
    // ConditionalTokens 合约地址
    private val conditionalTokensAddress = "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045"

-    // USDC.e 合约地址（普通市场抵押品）
-    private val usdcContractAddress = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
+    // pUSD 合约地址（普通市场抵押品）
+    private val usdcContractAddress = "0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB"
+
+    // USDC.e 合约地址（仅用于 wrap 到 pUSD）
+    private val usdceContractAddress = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174"
+
+    // CollateralOnramp 合约地址（USDC.e → pUSD）
+    private val collateralOnrampAddress = "0x93070a847efEf7F70739046A929D47a521F5B8ee"

    // Neg Risk 市场使用的 WrappedCollateral 合约地址（Polygon，neg-risk-ctf-adapter）
    private val negRiskWrappedCollateralAddress = "0x3A3BD7bb9528E159577F7C2e685CC81A765002E2"
@@ -51,7 +57,9 @@ class RelayClientService(
    // Polygon PROXY（Magic）合约地址，参考 builder-relayer-client config
    private val proxyFactoryAddress = "0xaB45c5A4B0c941a2F231C04C3f49182e1A254052"
    private val relayHubAddress = "0xD216153c06E857cD7f72665E0aF1d7D82172F494"
-    private val defaultProxyGasLimit = "10000000"
+    // PROXY relayCall 内层 gasLimit（签名参数）不能给过大值，否则 RelayHub 会因 gasleft 校验失败回滚。
+    private val defaultProxyGasLimit = "2400000"
+    private val maxProxyGasLimit = BigInteger.valueOf(2400000)

    // Safe MultiSend 合约地址（Polygon 主网）
    private val safeMultisendAddress = "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761"
@@ -282,14 +290,14 @@ class RelayClientService(
    }

    /**
-     * 创建 WCOL 解包交易（将 Wrapped Collateral 解包为 USDC.e）
+     * 创建 WCOL 解包交易（将 Wrapped Collateral 执行解包）
     * 合约: Neg Risk WrappedCollateral 0x3A3BD7bb9528E159577F7C2e685CC81A765002E2
-     * 方法: unwrap(address _to, uint256 _amount)，解包后 USDC.e 转到 _to
+     * 方法: unwrap(address _to, uint256 _amount)
     *
     * Safe 与 Magic 共用此交易对象：Safe 走 [executeViaBuilderRelayer] / [executeManually]（execTransaction），
     * Magic 走 [executeViaBuilderRelayerProxy]（encodeProxyTransactionData），语义一致。
     *
-     * @param toAddress 接收 USDC.e 的地址（通常为 proxy 自身，使余额留在代理钱包）
+     * @param toAddress 接收解包资产的地址（通常为 proxy 自身，使余额留在代理钱包）
     * @param amountWei WCOL 数量（6 位小数对应的 raw 值，与 balanceOf 返回一致）
     * @return Safe 交易对象
     */
@@ -323,6 +331,41 @@ class RelayClientService(
        )
    }

+    /**
+     * 创建 USDC.e approve 交易（用于 wrap 到 pUSD）
+     * 授权 CollateralOnramp 合约花费用户的 USDC.e
+     */
+    fun createUsdceApproveForWrapTx(amount: BigInteger): SafeTransaction {
+        val functionSelector = EthereumUtils.getFunctionSelector("approve(address,uint256)")
+        val encodedSpender = EthereumUtils.encodeAddress(collateralOnrampAddress)
+        val encodedAmount = EthereumUtils.encodeUint256(amount)
+        val callData = "0x" + functionSelector.removePrefix("0x") + encodedSpender + encodedAmount
+        return SafeTransaction(
+            to = usdceContractAddress,
+            operation = 0,
+            data = callData,
+            value = "0"
+        )
+    }
+
+    /**
+     * 创建 USDC.e → pUSD wrap 交易
+     * CollateralOnramp.wrap(address _asset, address _to, uint256 _amount)
+     */
+    fun createWrapToPusdTx(recipientAddress: String, amount: BigInteger): SafeTransaction {
+        val functionSelector = EthereumUtils.getFunctionSelector("wrap(address,address,uint256)")
+        val asset = EthereumUtils.encodeAddress(usdceContractAddress)
+        val to = EthereumUtils.encodeAddress(recipientAddress)
+        val amt = EthereumUtils.encodeUint256(amount)
+        val callData = "0x" + functionSelector.removePrefix("0x") + asset + to + amt
+        return SafeTransaction(
+            to = collateralOnrampAddress,
+            operation = 0,
+            data = callData,
+            value = "0"
+        )
+    }
+
    /**
     * 创建 MultiSend 交易（合并多个 SafeTransaction 为一笔交易）
     * 参考 TypeScript: builder-relayer-client/src/encode/safe.ts createSafeMultisendTransaction
@@ -489,7 +532,16 @@ class RelayClientService(
        
        // 估算 gas limit（参考 builder-relayer-client builder/proxy.ts getGasLimit）
        val gasLimit = try {
-            estimateProxyGasLimit(fromAddress, proxyFactoryAddress, proxyCallData)
+            val estimatedGasLimit = estimateProxyGasLimit(fromAddress, proxyFactoryAddress, proxyCallData)
+            val estimatedBigInt = BigInteger(estimatedGasLimit)
+            if (estimatedBigInt > maxProxyGasLimit) {
+                logger.warn(
+                    "估算 PROXY gas limit 过大，进行截断: estimated=$estimatedGasLimit, capped=$maxProxyGasLimit"
+                )
+                maxProxyGasLimit.toString()
+            } else {
+                estimatedGasLimit
+            }
        } catch (e: Exception) {
            logger.warn("估算 PROXY gas limit 失败，使用默认值: ${e.message}", e)
            defaultProxyGasLimit
@@ -26,6 +26,7 @@ import java.util.concurrent.TimeUnit
@Service
 class TelegramNotificationService(
    private val notificationConfigService: NotificationConfigService,
+    private val notificationTemplateService: NotificationTemplateService,
    private val objectMapper: ObjectMapper,
    private val messageSource: MessageSource
 ) {
@@ -85,7 +86,9 @@ class TelegramNotificationService(
        marketId: String? = null,
        marketSlug: String? = null,
        side: String,
-        price: String? = null,  // 订单价格（可选，如果提供则直接使用）
+        price: String? = null,  // 订单限价（可选）
+        avgFilledPrice: String? = null,  // 平均成交价（可选，有成交时优先展示）
+        filled: String? = null,  // 已成交数量（可选，与 avgFilledPrice 一起时用于金额计算）
        size: String? = null,  // 订单数量（可选，如果提供则直接使用）
        outcome: String? = null,  // 市场方向（可选，如果提供则直接使用）
        accountName: String? = null,
@@ -98,7 +101,8 @@ class TelegramNotificationService(
        locale: java.util.Locale? = null,
        leaderName: String? = null,  // Leader 名称（备注）
        configName: String? = null,  // 跟单配置名
-        orderTime: Long? = null  // 订单创建时间（毫秒时间戳），用于通知中的时间显示
+        orderTime: Long? = null,  // 订单创建时间（毫秒时间戳），用于通知中的时间显示
+        availableBalance: String? = null  // 可用余额（可选）
    ) {
        // 1. 如果提供了 orderId，检查是否已发送过通知（去重）
        if (orderId != null) {
@@ -128,14 +132,21 @@ class TelegramNotificationService(
            java.util.Locale("zh", "CN")  // 默认简体中文
        }
        
-        // 优先使用传入的价格和数量，如果没有提供则尝试从订单详情获取
-        var actualPrice: String? = price
+        // 优先使用平均成交价（实际成交价），其次传入的限价，若未提供则从订单详情获取
+        var actualPrice: String? = avgFilledPrice?.takeIf { it.isNotBlank() } ?: price
        var actualSize: String? = size
        var actualSide: String = side
        var actualOutcome: String? = outcome
+
+        // 有平均成交价时，已成交数量优先用 filled，用于金额计算
+        val sizeForAmount: String? = if (avgFilledPrice != null && avgFilledPrice.isNotBlank() && filled != null && filled.isNotBlank()) {
+            filled
+        } else {
+            null
+        }
        
-        // 如果价格或数量未提供，尝试从订单详情获取
-        if ((actualPrice == null || actualSize == null) && orderId != null && clobApi != null && apiKey != null && apiSecret != null && apiPassphrase != null && walletAddressForApi != null) {
+        // 如果价格、数量或市场方向未提供，尝试从订单详情获取
+        if ((actualPrice == null || actualSize == null || actualOutcome == null) && orderId != null && clobApi != null && apiKey != null && apiSecret != null && apiPassphrase != null && walletAddressForApi != null) {
            try {
                val orderResponse = clobApi.getOrder(orderId)
                if (orderResponse.isSuccessful) {
@@ -147,7 +158,8 @@ class TelegramNotificationService(
                        if (actualSize == null) {
                            actualSize = order.originalSize  // 使用 originalSize 作为订单数量
                        }
-                        actualSide = order.side  // 使用订单详情中的 side
+                        // 注意：不覆盖 side，因为传入的 side（BUY/SELL）是正确的
+                        // actualSide = order.side  // 不要使用订单详情中的 side，因为它可能不准确
                        if (actualOutcome == null) {
                            actualOutcome = order.outcome  // 使用订单详情中的 outcome（市场方向）
                        }
@@ -165,19 +177,28 @@ class TelegramNotificationService(
        
        // 如果仍然没有获取到实际值，使用默认值（这种情况不应该发生，但为了兼容性保留）
        val finalPrice = actualPrice ?: "0"
-        val finalSize = actualSize ?: "0"
+        // 有实际成交价时展示数量用 size_matched（filled），否则用订单数量（original_size）
+        val finalSize = if (avgFilledPrice != null && avgFilledPrice.isNotBlank() && filled != null && filled.isNotBlank()) {
+            filled
+        } else {
+            actualSize ?: "0"
+        }
+        // 金额计算：有实际成交价和已成交数量时用二者乘积，否则用展示价格×订单数量
+        val sizeForCalc = sizeForAmount?.takeIf { it.isNotBlank() } ?: finalSize
        
        // 计算订单金额 = price × size（USDC）
        val amount = try {
            val priceDecimal = finalPrice.toSafeBigDecimal()
-            val sizeDecimal = finalSize.toSafeBigDecimal()
+            val sizeDecimal = sizeForCalc.toSafeBigDecimal()
            priceDecimal.multiply(sizeDecimal).toString()
        } catch (e: Exception) {
            logger.warn("计算订单金额失败: ${e.message}", e)
            null
        }

-        val message = buildOrderSuccessMessage(
+        val unknownAccount = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", currentLocale).orEmpty().ifEmpty { "未知账户" }
+        val calculateFailed = messageSource.getMessage("notification.order.calculate_failed", null, "计算失败", currentLocale).orEmpty().ifEmpty { "计算失败" }
+        val vars = buildOrderSuccessVariables(
            orderId = orderId,
            marketTitle = marketTitle,
            marketId = marketId,
@@ -192,8 +213,12 @@ class TelegramNotificationService(
            locale = currentLocale,
            leaderName = leaderName,
            configName = configName,
-            orderTime = orderTime
+            orderTime = orderTime,
+            availableBalance = availableBalance,
+            unknownAccount = unknownAccount,
+            calculateFailed = calculateFailed
        )
+        val message = notificationTemplateService.renderTemplate("ORDER_SUCCESS", vars)
        sendMessage(message)
    }

@@ -232,7 +257,9 @@ class TelegramNotificationService(
            null
        }

-        val message = buildOrderFailureMessage(
+        val unknownAccount = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", currentLocale).orEmpty().ifEmpty { "未知账户" }
+        val calculateFailed = messageSource.getMessage("notification.order.calculate_failed", null, "计算失败", currentLocale).orEmpty().ifEmpty { "计算失败" }
+        val vars = buildOrderFailureVariables(
            marketTitle = marketTitle,
            marketId = marketId,
            marketSlug = marketSlug,
@@ -244,11 +271,65 @@ class TelegramNotificationService(
            errorMessage = errorMessage,
            accountName = accountName,
            walletAddress = walletAddress,
-            locale = currentLocale
+            locale = currentLocale,
+            unknownAccount = unknownAccount,
+            calculateFailed = calculateFailed
        )
+        val message = notificationTemplateService.renderTemplate("ORDER_FAILED", vars)
        sendMessage(message)
    }

+    /**
+     * 构建订单失败通知的变量 Map
+     */
+    private fun buildOrderFailureVariables(
+        marketTitle: String,
+        marketId: String?,
+        marketSlug: String?,
+        side: String,
+        outcome: String?,
+        price: String,
+        size: String,
+        amount: String?,
+        errorMessage: String,
+        accountName: String?,
+        walletAddress: String?,
+        locale: java.util.Locale,
+        unknownAccount: String,
+        calculateFailed: String
+    ): Map<String, String> {
+        val sideDisplay = when (side.uppercase()) {
+            "BUY" -> messageSource.getMessage("notification.order.side.buy", null, "买入", locale).orEmpty().ifEmpty { "买入" }
+            "SELL" -> messageSource.getMessage("notification.order.side.sell", null, "卖出", locale).orEmpty().ifEmpty { "卖出" }
+            else -> side
+        }
+        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
+        val marketLink = when {
+            !marketSlug.isNullOrBlank() -> "https://polymarket.com/event/$marketSlug"
+            !marketId.isNullOrBlank() && marketId.startsWith("0x") -> "https://polymarket.com/condition/$marketId"
+            else -> ""
+        }
+        val amountDisplay = amount?.let { am ->
+            try {
+                val amountDecimal = am.toSafeBigDecimal()
+                (if (amountDecimal.scale() > 4) amountDecimal.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else amountDecimal.stripTrailingZeros()).toPlainString()
+            } catch (e: Exception) { am }
+        } ?: calculateFailed
+        val shortError = if (errorMessage.length > 500) errorMessage.substring(0, 500) + "..." else errorMessage
+        return mapOf(
+            "market_title" to marketTitle.replace("<", "&lt;").replace(">", "&gt;"),
+            "market_link" to marketLink,
+            "side" to sideDisplay,
+            "outcome" to (outcome?.replace("<", "&lt;")?.replace(">", "&gt;") ?: ""),
+            "price" to formatPrice(price),
+            "quantity" to formatQuantity(size),
+            "amount" to amountDisplay,
+            "account_name" to accountInfo,
+            "error_message" to shortError.replace("<", "&lt;").replace(">", "&gt;"),
+            "time" to DateUtils.formatDateTime()
+        )
+    }
+
    /**
     * 发送订单被过滤通知
     * @param locale 语言设置（可选，如果提供则使用，否则使用 LocaleContextHolder 获取）
@@ -285,7 +366,9 @@ class TelegramNotificationService(
            null
        }

-        val message = buildOrderFilteredMessage(
+        val unknownAccount = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", currentLocale).orEmpty().ifEmpty { "未知账户" }
+        val calculateFailed = messageSource.getMessage("notification.order.calculate_failed", null, "计算失败", currentLocale).orEmpty().ifEmpty { "计算失败" }
+        val vars = buildOrderFilteredVariables(
            marketTitle = marketTitle,
            marketId = marketId,
            marketSlug = marketSlug,
@@ -298,13 +381,75 @@ class TelegramNotificationService(
            filterType = filterType,
            accountName = accountName,
            walletAddress = walletAddress,
-            locale = currentLocale
+            locale = currentLocale,
+            unknownAccount = unknownAccount,
+            calculateFailed = calculateFailed
        )
+        val message = notificationTemplateService.renderTemplate("ORDER_FILTERED", vars)
        sendMessage(message)
    }

+    private fun buildOrderFilteredVariables(
+        marketTitle: String,
+        marketId: String?,
+        marketSlug: String?,
+        side: String,
+        outcome: String?,
+        price: String,
+        size: String,
+        amount: String?,
+        filterReason: String,
+        filterType: String,
+        accountName: String?,
+        walletAddress: String?,
+        locale: java.util.Locale,
+        unknownAccount: String,
+        calculateFailed: String
+    ): Map<String, String> {
+        val sideDisplay = when (side.uppercase()) {
+            "BUY" -> messageSource.getMessage("notification.order.side.buy", null, "买入", locale).orEmpty().ifEmpty { "买入" }
+            "SELL" -> messageSource.getMessage("notification.order.side.sell", null, "卖出", locale).orEmpty().ifEmpty { "卖出" }
+            else -> side
+        }
+        val filterTypeDisplay = when (filterType.uppercase()) {
+            "ORDER_DEPTH" -> messageSource.getMessage("notification.filter.type.order_depth", null, "订单深度不足", locale).orEmpty().ifEmpty { "订单深度不足" }
+            "SPREAD" -> messageSource.getMessage("notification.filter.type.spread", null, "价差过大", locale).orEmpty().ifEmpty { "价差过大" }
+            "ORDERBOOK_DEPTH" -> messageSource.getMessage("notification.filter.type.orderbook_depth", null, "订单簿深度不足", locale).orEmpty().ifEmpty { "订单簿深度不足" }
+            "PRICE_VALIDITY" -> messageSource.getMessage("notification.filter.type.price_validity", null, "价格不合理", locale).orEmpty().ifEmpty { "价格不合理" }
+            "MARKET_STATUS" -> messageSource.getMessage("notification.filter.type.market_status", null, "市场状态不可交易", locale).orEmpty().ifEmpty { "市场状态不可交易" }
+            else -> filterType
+        }
+        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
+        val marketLink = when {
+            !marketSlug.isNullOrBlank() -> "https://polymarket.com/event/$marketSlug"
+            !marketId.isNullOrBlank() && marketId.startsWith("0x") -> "https://polymarket.com/condition/$marketId"
+            else -> ""
+        }
+        val amountDisplay = amount?.let { am ->
+            try {
+                (am.toSafeBigDecimal().let { if (it.scale() > 4) it.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else it.stripTrailingZeros() }.toPlainString())
+            } catch (e: Exception) { am }
+        } ?: calculateFailed
+        return mapOf(
+            "market_title" to marketTitle.replace("<", "&lt;").replace(">", "&gt;"),
+            "market_link" to marketLink,
+            "side" to sideDisplay,
+            "outcome" to (outcome?.replace("<", "&lt;")?.replace(">", "&gt;") ?: ""),
+            "price" to formatPrice(price),
+            "quantity" to formatQuantity(size),
+            "amount" to amountDisplay,
+            "account_name" to accountInfo,
+            "filter_type" to filterTypeDisplay,
+            "filter_reason" to filterReason.replace("<", "&lt;").replace(">", "&gt;"),
+            "time" to DateUtils.formatDateTime()
+        )
+    }
+
    /**
     * 发送加密价差策略下单成功通知（与跟单一致：在收到 WS 订单推送时匹配价差策略订单后调用）
+     * @param price 订单限价
+     * @param avgFilledPrice 平均成交价（可选，有成交时优先展示）
+     * @param filled 已成交数量（可选，与 avgFilledPrice 一起时用于金额计算）
     */
    suspend fun sendCryptoTailOrderSuccessNotification(
        orderId: String?,
@@ -315,6 +460,8 @@ class TelegramNotificationService(
        outcome: String? = null,
        price: String,
        size: String,
+        avgFilledPrice: String? = null,
+        filled: String? = null,
        strategyName: String? = null,
        accountName: String? = null,
        walletAddress: String? = null,
@@ -339,33 +486,95 @@ class TelegramNotificationService(
            logger.warn("获取语言设置失败，使用默认语言: ${e.message}", e)
            java.util.Locale("zh", "CN")
        }
+        val displayPrice = avgFilledPrice?.takeIf { it.isNotBlank() } ?: price
+        val hasAvgFilled = avgFilledPrice != null && avgFilledPrice.isNotBlank() && filled != null && filled.isNotBlank()
+        val sizeForAmount = if (hasAvgFilled) filled else size
+        val quantityDisplay = if (hasAvgFilled) filled else size  // 有实际成交价时展示数量用 size_matched
        val amount = try {
-            val priceDecimal = price.toSafeBigDecimal()
-            val sizeDecimal = size.toSafeBigDecimal()
+            val priceDecimal = displayPrice.toSafeBigDecimal()
+            val sizeDecimal = sizeForAmount.toSafeBigDecimal()
            priceDecimal.multiply(sizeDecimal).toString()
        } catch (e: Exception) {
            logger.warn("计算订单金额失败: ${e.message}", e)
            null
        }
-        val message = buildCryptoTailOrderSuccessMessage(
+        val unknown = messageSource.getMessage("common.unknown", null, "未知", currentLocale).orEmpty().ifEmpty { "未知" }
+        val unknownAccount = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", currentLocale).orEmpty().ifEmpty { "未知账户" }
+        val calculateFailed = messageSource.getMessage("notification.order.calculate_failed", null, "计算失败", currentLocale).orEmpty().ifEmpty { "计算失败" }
+        val vars = buildCryptoTailOrderSuccessVariables(
            orderId = orderId,
            marketTitle = marketTitle,
            marketId = marketId,
            marketSlug = marketSlug,
            side = side,
            outcome = outcome,
-            price = price,
-            size = size,
+            price = displayPrice,
+            size = quantityDisplay.orEmpty(),
            amount = amount,
            strategyName = strategyName,
            accountName = accountName,
            walletAddress = walletAddress,
-            locale = currentLocale,
-            orderTime = orderTime
+            orderTime = orderTime,
+            unknown = unknown,
+            unknownAccount = unknownAccount,
+            calculateFailed = calculateFailed,
+            locale = currentLocale
        )
+        val message = notificationTemplateService.renderTemplate("CRYPTO_TAIL_SUCCESS", vars)
        sendMessage(message)
    }

+    private fun buildCryptoTailOrderSuccessVariables(
+        orderId: String?,
+        marketTitle: String,
+        marketId: String?,
+        marketSlug: String?,
+        side: String,
+        outcome: String?,
+        price: String,
+        size: String,
+        amount: String?,
+        strategyName: String?,
+        accountName: String?,
+        walletAddress: String?,
+        orderTime: Long?,
+        unknown: String,
+        unknownAccount: String,
+        calculateFailed: String,
+        locale: java.util.Locale
+    ): Map<String, String> {
+        val sideDisplay = when (side.uppercase()) {
+            "BUY" -> messageSource.getMessage("notification.order.side.buy", null, "买入", locale).orEmpty().ifEmpty { "买入" }
+            "SELL" -> messageSource.getMessage("notification.order.side.sell", null, "卖出", locale).orEmpty().ifEmpty { "卖出" }
+            else -> side
+        }
+        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
+        val time = if (orderTime != null) DateUtils.formatDateTime(orderTime) else DateUtils.formatDateTime()
+        val marketLink = when {
+            !marketSlug.isNullOrBlank() -> "https://polymarket.com/event/$marketSlug"
+            !marketId.isNullOrBlank() && marketId.startsWith("0x") -> "https://polymarket.com/condition/$marketId"
+            else -> ""
+        }
+        val amountDisplay = amount?.let { am ->
+            try {
+                (am.toSafeBigDecimal().let { if (it.scale() > 4) it.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else it.stripTrailingZeros() }.toPlainString())
+            } catch (e: Exception) { am }
+        } ?: calculateFailed
+        return mapOf(
+            "order_id" to (orderId ?: unknown),
+            "market_title" to marketTitle.replace("<", "&lt;").replace(">", "&gt;"),
+            "market_link" to marketLink,
+            "side" to sideDisplay,
+            "outcome" to (outcome?.replace("<", "&lt;")?.replace(">", "&gt;") ?: ""),
+            "price" to formatPrice(price),
+            "quantity" to formatQuantity(size),
+            "amount" to amountDisplay,
+            "account_name" to accountInfo,
+            "strategy_name" to (strategyName?.takeIf { it.isNotBlank() } ?: unknown),
+            "time" to time
+        )
+    }
+
    /**
     * 构建订单被过滤消息
     */
@@ -482,7 +691,7 @@ class TelegramNotificationService(
 • $sideLabel: <b>$sideDisplay</b>
 • $priceLabel: <code>$priceDisplay</code>
 • $quantityLabel: <code>$sizeDisplay</code> shares
-• $amountLabel: <code>$amountDisplay</code> USDC
+• $amountLabel: <code>${'$'}$amountDisplay</code>
 • $accountLabel: $escapedAccountInfo

 ⚠️ <b>$filterTypeLabel：</b> <code>$filterTypeDisplay</code>
@@ -748,6 +957,76 @@ class TelegramNotificationService(
        }
    }

+    /**
+     * 构建订单成功通知的变量 Map（供模板渲染）
+     */
+    private fun buildOrderSuccessVariables(
+        orderId: String?,
+        marketTitle: String,
+        marketId: String?,
+        marketSlug: String?,
+        side: String,
+        outcome: String?,
+        price: String,
+        size: String,
+        amount: String?,
+        accountName: String?,
+        walletAddress: String?,
+        locale: java.util.Locale,
+        leaderName: String?,
+        configName: String?,
+        orderTime: Long?,
+        availableBalance: String?,
+        unknownAccount: String,
+        calculateFailed: String
+    ): Map<String, String> {
+        val sideDisplay = when (side.uppercase()) {
+            "BUY" -> messageSource.getMessage("notification.order.side.buy", null, "买入", locale).orEmpty().ifEmpty { "买入" }
+            "SELL" -> messageSource.getMessage("notification.order.side.sell", null, "卖出", locale).orEmpty().ifEmpty { "卖出" }
+            else -> side
+        }
+        val unknown = messageSource.getMessage("common.unknown", null, "未知", locale).orEmpty().ifEmpty { "未知" }
+        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
+        val time = if (orderTime != null) DateUtils.formatDateTime(orderTime) else DateUtils.formatDateTime()
+        val marketLink = when {
+            !marketSlug.isNullOrBlank() -> "https://polymarket.com/event/$marketSlug"
+            !marketId.isNullOrBlank() && marketId.startsWith("0x") -> "https://polymarket.com/condition/$marketId"
+            else -> ""
+        }
+        val amountDisplay = when {
+            amount != null -> try {
+                val amountDecimal = amount.toSafeBigDecimal()
+                val formatted = if (amountDecimal.scale() > 4) amountDecimal.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else amountDecimal.stripTrailingZeros()
+                formatted.toPlainString()
+            } catch (e: Exception) { amount ?: calculateFailed }
+            else -> calculateFailed
+        }
+        val availableBalanceDisplay = if (!availableBalance.isNullOrBlank()) {
+            try {
+                val balanceDecimal = availableBalance.toSafeBigDecimal()
+                val formatted = if (balanceDecimal.scale() > 4) balanceDecimal.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else balanceDecimal.stripTrailingZeros()
+                formatted.toPlainString()
+            } catch (e: Exception) { availableBalance ?: "" }
+        } else { "" }
+        val escapedMarketTitle = marketTitle.replace("<", "&lt;").replace(">", "&gt;")
+        val escapedOutcome = outcome?.replace("<", "&lt;")?.replace(">", "&gt;") ?: ""
+        return mapOf(
+            "order_id" to (orderId ?: unknown),
+            "market_title" to escapedMarketTitle,
+            "market_link" to marketLink,
+            "side" to sideDisplay,
+            "outcome" to escapedOutcome,
+            "price" to formatPrice(price),
+            "quantity" to formatQuantity(size),
+            "amount" to amountDisplay,
+            "account_name" to accountInfo,
+            "available_balance" to availableBalanceDisplay,
+            "leader_name" to (leaderName ?: ""),
+            "config_name" to (configName ?: ""),
+            "time" to time
+        )
+    }
+
    /**
     * 构建订单成功消息
     */
@@ -766,7 +1045,8 @@ class TelegramNotificationService(
        locale: java.util.Locale,
        leaderName: String? = null,  // Leader 名称（备注）
        configName: String? = null,  // 跟单配置名
-        orderTime: Long? = null  // 订单创建时间（毫秒时间戳）
+        orderTime: Long? = null,  // 订单创建时间（毫秒时间戳）
+        availableBalance: String? = null  // 可用余额
    ): String {
        
        // 获取多语言文本
@@ -781,6 +1061,7 @@ class TelegramNotificationService(
        val amountLabel = messageSource.getMessage("notification.order.amount", null, "金额", locale)
        val accountLabel = messageSource.getMessage("notification.order.account", null, "账户", locale)
        val timeLabel = messageSource.getMessage("notification.order.time", null, "时间", locale)
+        val availableBalanceLabel = messageSource.getMessage("notification.order.available_balance", null, "可用余额", locale)
        val unknown = messageSource.getMessage("common.unknown", null, "未知", locale)
        val unknownAccount: String = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", locale) ?: "未知账户"
        val calculateFailed = messageSource.getMessage("notification.order.calculate_failed", null, "计算失败", locale)
@@ -879,6 +1160,23 @@ class TelegramNotificationService(
        val priceDisplay = formatPrice(price)
        val sizeDisplay = formatQuantity(size)

+        // 格式化可用余额
+        val availableBalanceDisplay = if (!availableBalance.isNullOrBlank()) {
+            try {
+                val balanceDecimal = availableBalance.toSafeBigDecimal()
+                val formatted = if (balanceDecimal.scale() > 4) {
+                    balanceDecimal.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros()
+                } else {
+                    balanceDecimal.stripTrailingZeros()
+                }
+                "\n• $availableBalanceLabel: <code>${'$'}${formatted.toPlainString()}</code>"
+            } catch (e: Exception) {
+                "\n• $availableBalanceLabel: <code>${'$'}$availableBalance</code>"
+            }
+        } else {
+            ""
+        }
+
        return """$icon <b>$orderCreatedSuccess</b>

 📊 <b>$orderInfo：</b>
@@ -887,8 +1185,8 @@ class TelegramNotificationService(
 • $sideLabel: <b>$sideDisplay</b>
 • $priceLabel: <code>$priceDisplay</code>
 • $quantityLabel: <code>$sizeDisplay</code> shares
-• $amountLabel: <code>$amountDisplay</code> USDC
-• $accountLabel: $escapedAccountInfo$escapedCopyTradingInfo
+• $amountLabel: <code>${'$'}$amountDisplay</code>
+• $accountLabel: $escapedAccountInfo$escapedCopyTradingInfo$availableBalanceDisplay

 ⏰ $timeLabel: <code>$time</code>"""
    }
@@ -966,7 +1264,7 @@ class TelegramNotificationService(
 • $sideLabel: <b>$sideDisplay</b>
 • $priceLabel: <code>$priceDisplay</code>
 • $quantityLabel: <code>$sizeDisplay</code> shares
-• $amountLabel: <code>$amountDisplay</code> USDC
+• $amountLabel: <code>${'$'}$amountDisplay</code>
 • $accountLabel: $escapedAccountInfo

 ⏰ $timeLabel: <code>$time</code>"""
@@ -1083,7 +1381,7 @@ class TelegramNotificationService(
 • $sideLabel: <b>$sideDisplay</b>
 • $priceLabel: <code>$priceDisplay</code>
 • $quantityLabel: <code>$sizeDisplay</code> shares
-• $amountLabel: <code>$amountDisplay</code> USDC
+• $amountLabel: <code>${'$'}$amountDisplay</code>
 • $accountLabel: $escapedAccountInfo

 ⚠️ <b>$errorInfo：</b>
@@ -1095,6 +1393,7 @@ class TelegramNotificationService(
    /**
     * 发送仓位赎回通知
     * @param locale 语言设置（可选，如果提供则使用，否则使用 LocaleContextHolder 获取）
+     * @param availableBalance 可用余额（可选）
     */
    suspend fun sendRedeemNotification(
        accountName: String?,
@@ -1102,7 +1401,8 @@ class TelegramNotificationService(
        transactionHash: String,
        totalRedeemedValue: String,
        positions: List<com.wrbug.polymarketbot.dto.RedeemedPositionInfo>,
-        locale: java.util.Locale? = null
+        locale: java.util.Locale? = null,
+        availableBalance: String? = null
    ) {
        // 获取语言设置（优先使用传入的 locale，否则从 LocaleContextHolder 获取）
        val currentLocale = locale ?: try {
@@ -1112,16 +1412,46 @@ class TelegramNotificationService(
            java.util.Locale("zh", "CN")  // 默认简体中文
        }
        
-        val message = buildRedeemMessage(
+        val unknownAccount = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", currentLocale) ?: "未知账户"
+        val vars = buildRedeemSuccessVariables(
            accountName = accountName,
            walletAddress = walletAddress,
            transactionHash = transactionHash,
            totalRedeemedValue = totalRedeemedValue,
-            positions = positions,
-            locale = currentLocale
+            availableBalance = availableBalance,
+            unknownAccount = unknownAccount
        )
+        val message = notificationTemplateService.renderTemplate("REDEEM_SUCCESS", vars)
        sendMessage(message)
    }
+
+    private fun buildRedeemSuccessVariables(
+        accountName: String?,
+        walletAddress: String?,
+        transactionHash: String,
+        totalRedeemedValue: String,
+        availableBalance: String?,
+        unknownAccount: String
+    ): Map<String, String> {
+        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
+        val totalValueDisplay = try {
+            val d = totalRedeemedValue.toSafeBigDecimal()
+            (if (d.scale() > 4) d.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else d.stripTrailingZeros()).toPlainString()
+        } catch (e: Exception) { totalRedeemedValue }
+        val availableBalanceDisplay = availableBalance?.let { ab ->
+            try {
+                val d = ab.toSafeBigDecimal()
+                (if (d.scale() > 4) d.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else d.stripTrailingZeros()).toPlainString()
+            } catch (e: Exception) { ab }
+        } ?: ""
+        return mapOf(
+            "account_name" to accountInfo,
+            "transaction_hash" to transactionHash.replace("<", "&lt;").replace(">", "&gt;"),
+            "total_value" to totalValueDisplay,
+            "available_balance" to availableBalanceDisplay,
+            "time" to DateUtils.formatDateTime()
+        )
+    }
    
    /**
     * 构建仓位赎回消息
@@ -1132,7 +1462,8 @@ class TelegramNotificationService(
        transactionHash: String,
        totalRedeemedValue: String,
        positions: List<com.wrbug.polymarketbot.dto.RedeemedPositionInfo>,
-        locale: java.util.Locale
+        locale: java.util.Locale,
+        availableBalance: String? = null
    ): String {
        // 获取多语言文本
        val redeemSuccess = messageSource.getMessage("notification.redeem.success", null, "仓位赎回成功", locale)
@@ -1145,6 +1476,7 @@ class TelegramNotificationService(
        val quantityLabel = messageSource.getMessage("notification.order.quantity", null, "数量", locale)
        val valueLabel = messageSource.getMessage("notification.order.amount", null, "金额", locale)
        val timeLabel = messageSource.getMessage("notification.order.time", null, "时间", locale)
+        val availableBalanceLabel = messageSource.getMessage("notification.redeem.available_balance", null, "可用余额", locale)
        val unknownAccount: String = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", locale) ?: "未知账户"
        
        // 构建账户信息（格式：账户名(钱包地址)）
@@ -1183,7 +1515,24 @@ class TelegramNotificationService(
            } catch (e: Exception) {
                position.value
            }
-            "  • ${position.marketId.substring(0, 8)}... (${position.side}): $quantityDisplay shares = $valueDisplay USDC"
+            "  • ${position.marketId.substring(0, 8)}... (${position.side}): $quantityDisplay shares = ${'$'}$valueDisplay"
+        }
+        
+        // 格式化可用余额
+        val availableBalanceDisplay = if (!availableBalance.isNullOrBlank()) {
+            try {
+                val balanceDecimal = availableBalance.toSafeBigDecimal()
+                val formatted = if (balanceDecimal.scale() > 4) {
+                    balanceDecimal.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros()
+                } else {
+                    balanceDecimal.stripTrailingZeros()
+                }
+                "\n• $availableBalanceLabel: <code>${'$'}${formatted.toPlainString()}</code>"
+            } catch (e: Exception) {
+                "\n• $availableBalanceLabel: <code>${'$'}$availableBalance</code>"
+            }
+        } else {
+            ""
        }
        
        return """💸 <b>$redeemSuccess</b>
@@ -1191,14 +1540,130 @@ class TelegramNotificationService(
 📊 <b>$redeemInfo：</b>
 • $accountLabel: $escapedAccountInfo
 • $transactionHashLabel: <code>$escapedTxHash</code>
-• $totalValueLabel: <code>$totalValueDisplay</code> USDC
+• $totalValueLabel: <code>${'$'}$totalValueDisplay</code>$availableBalanceDisplay

 📦 <b>$positionsLabel：</b>
 $positionsText

 ⏰ $timeLabel: <code>$time</code>"""
    }
-    
+
+    /**
+     * 发送仓位已结算（无收益）通知
+     * 用于输的仓位，赎回价值为 0 的情况
+     */
+    suspend fun sendRedeemNoReturnNotification(
+        accountName: String?,
+        walletAddress: String?,
+        transactionHash: String,
+        positions: List<com.wrbug.polymarketbot.dto.RedeemedPositionInfo>,
+        locale: java.util.Locale? = null,
+        availableBalance: String? = null
+    ) {
+        val currentLocale = locale ?: try {
+            LocaleContextHolder.getLocale()
+        } catch (e: Exception) {
+            logger.warn("获取语言设置失败，使用默认语言: ${e.message}", e)
+            java.util.Locale("zh", "CN")
+        }
+
+        val unknownAccount = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", currentLocale) ?: "未知账户"
+        val vars = buildRedeemNoReturnVariables(
+            accountName = accountName,
+            walletAddress = walletAddress,
+            transactionHash = transactionHash,
+            availableBalance = availableBalance,
+            unknownAccount = unknownAccount
+        )
+        val message = notificationTemplateService.renderTemplate("REDEEM_NO_RETURN", vars)
+        sendMessage(message)
+    }
+
+    private fun buildRedeemNoReturnVariables(
+        accountName: String?,
+        walletAddress: String?,
+        transactionHash: String,
+        availableBalance: String?,
+        unknownAccount: String
+    ): Map<String, String> {
+        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
+        val availableBalanceDisplay = availableBalance?.let { ab ->
+            try {
+                val d = ab.toSafeBigDecimal()
+                (if (d.scale() > 4) d.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros() else d.stripTrailingZeros()).toPlainString()
+            } catch (e: Exception) { ab }
+        } ?: ""
+        return mapOf(
+            "account_name" to accountInfo,
+            "transaction_hash" to transactionHash.replace("<", "&lt;").replace(">", "&gt;"),
+            "available_balance" to availableBalanceDisplay,
+            "time" to DateUtils.formatDateTime()
+        )
+    }
+
+    /**
+     * 构建仓位已结算（无收益）消息
+     */
+    private fun buildRedeemNoReturnMessage(
+        accountName: String?,
+        walletAddress: String?,
+        transactionHash: String,
+        positions: List<com.wrbug.polymarketbot.dto.RedeemedPositionInfo>,
+        locale: java.util.Locale,
+        availableBalance: String? = null
+    ): String {
+        val noReturnTitle = messageSource.getMessage("notification.redeem.no_return.title", null, "仓位已结算（无收益）", locale)
+        val noReturnInfo = messageSource.getMessage("notification.redeem.no_return.info", null, "结算信息", locale)
+        val noReturnMessage = messageSource.getMessage("notification.redeem.no_return.message", null, "市场已结算，您的预测未命中，赎回价值为 0。", locale)
+        val accountLabel = messageSource.getMessage("notification.order.account", null, "账户", locale)
+        val transactionHashLabel = messageSource.getMessage("notification.redeem.transaction_hash", null, "交易哈希", locale)
+        val positionsLabel = messageSource.getMessage("notification.redeem.no_return.positions", null, "结算仓位", locale)
+        val timeLabel = messageSource.getMessage("notification.order.time", null, "时间", locale)
+        val availableBalanceLabel = messageSource.getMessage("notification.redeem.available_balance", null, "可用余额", locale)
+        val unknownAccount: String = messageSource.getMessage("notification.order.unknown_account", null, "未知账户", locale) ?: "未知账户"
+
+        val accountInfo = buildAccountInfo(accountName, walletAddress, unknownAccount)
+        val time = DateUtils.formatDateTime()
+
+        val escapedAccountInfo = accountInfo.replace("<", "&lt;").replace(">", "&gt;")
+        val escapedTxHash = transactionHash.replace("<", "&lt;").replace(">", "&gt;")
+
+        val positionsText = positions.joinToString("\n") { position ->
+            val quantityDisplay = formatQuantity(position.quantity)
+            "  • ${position.marketId.substring(0, 8)}... (${position.side}): $quantityDisplay shares"
+        }
+
+        // 格式化可用余额
+        val availableBalanceDisplay = if (!availableBalance.isNullOrBlank()) {
+            try {
+                val balanceDecimal = availableBalance.toSafeBigDecimal()
+                val formatted = if (balanceDecimal.scale() > 4) {
+                    balanceDecimal.setScale(4, java.math.RoundingMode.DOWN).stripTrailingZeros()
+                } else {
+                    balanceDecimal.stripTrailingZeros()
+                }
+                "\n• $availableBalanceLabel: <code>${'$'}${formatted.toPlainString()}</code>"
+            } catch (e: Exception) {
+                "\n• $availableBalanceLabel: <code>${'$'}$availableBalance</code>"
+            }
+        } else {
+            ""
+        }
+
+        return """📋 <b>$noReturnTitle</b>
+
+📊 <b>$noReturnInfo：</b>
+<i>$noReturnMessage</i>
+
+• $accountLabel: $escapedAccountInfo
+• $transactionHashLabel: <code>$escapedTxHash</code>$availableBalanceDisplay
+
+📦 <b>$positionsLabel：</b>
+$positionsText
+
+⏰ $timeLabel: <code>$time</code>"""
+    }
+
    /**
     * 脱敏显示地址（只显示前6位和后4位）
     */
@@ -167,9 +167,8 @@ object Eip712Encoder {
    }
    
    /**
-     * 编码 ExchangeOrder 域分隔符
-     * 参考: @polymarket/order-utils 的 ExchangeOrderBuilder
-     * Domain: { name: "Polymarket CTF Exchange", version: "1", chainId: chainId, verifyingContract: exchangeContract }
+     * 编码 ExchangeOrder V2 域分隔符
+     * Domain: { name: "Polymarket CTF Exchange", version: "2", chainId: chainId, verifyingContract: exchangeContract }
     */
    fun encodeExchangeDomain(
        chainId: Long,
@@ -184,9 +183,9 @@ object Eip712Encoder {
                "verifyingContract" to "address"
            )
        )
-        
+
        val nameHash = encodeString("Polymarket CTF Exchange")
-        val versionHash = encodeString("1")
+        val versionHash = encodeString("2")
        val chainIdBytes = encodeUint256(BigInteger.valueOf(chainId))
        val contractBytes = encodeAddress(verifyingContract)
        
@@ -201,23 +200,21 @@ object Eip712Encoder {
    }
    
    /**
-     * 编码 ExchangeOrder 消息哈希
-     * 参考: @polymarket/order-utils 的 ExchangeOrderBuilder
-     * Order: { salt, maker, signer, taker, tokenId, makerAmount, takerAmount, expiration, nonce, feeRateBps, side, signatureType }
+     * 编码 ExchangeOrder V2 消息哈希
+     * V2 Order: { salt, maker, signer, tokenId, makerAmount, takerAmount, side, signatureType, timestamp, metadata, builder }
     */
    fun encodeExchangeOrder(
        salt: Long,
        maker: String,
        signer: String,
-        taker: String,
        tokenId: String,
        makerAmount: String,
        takerAmount: String,
-        expiration: String,
-        nonce: String,
-        feeRateBps: String,
        side: String,
-        signatureType: Int
+        signatureType: Int,
+        timestamp: String,
+        metadata: String,
+        builder: String
    ): ByteArray {
        val orderTypeHash = encodeType(
            "Order",
@@ -225,57 +222,51 @@ object Eip712Encoder {
                "salt" to "uint256",
                "maker" to "address",
                "signer" to "address",
-                "taker" to "address",
                "tokenId" to "uint256",
                "makerAmount" to "uint256",
                "takerAmount" to "uint256",
-                "expiration" to "uint256",
-                "nonce" to "uint256",
-                "feeRateBps" to "uint256",
                "side" to "uint8",
-                "signatureType" to "uint8"
+                "signatureType" to "uint8",
+                "timestamp" to "uint256",
+                "metadata" to "bytes32",
+                "builder" to "bytes32"
            )
        )
-        
-        // 编码订单字段
+
        val saltBytes = encodeUint256(BigInteger.valueOf(salt))
        val makerBytes = encodeAddress(maker)
        val signerBytes = encodeAddress(signer)
-        val takerBytes = encodeAddress(taker)
        val tokenIdBytes = encodeUint256(BigInteger(tokenId))
        val makerAmountBytes = encodeUint256(BigInteger(makerAmount))
        val takerAmountBytes = encodeUint256(BigInteger(takerAmount))
-        val expirationBytes = encodeUint256(BigInteger(expiration))
-        val nonceBytes = encodeUint256(BigInteger(nonce))
-        val feeRateBpsBytes = encodeUint256(BigInteger(feeRateBps))
-        
-        // side: BUY = 0, SELL = 1 (uint8，但需要编码为 32 字节)
+
        val sideValue = when (side.uppercase()) {
            "BUY" -> 0
            "SELL" -> 1
            else -> throw IllegalArgumentException("side 必须是 BUY 或 SELL")
        }
-        // uint8 类型，但 EIP-712 编码时仍需要 32 字节
        val sideBytes = encodeUint256(BigInteger.valueOf(sideValue.toLong()))
        val signatureTypeBytes = encodeUint256(BigInteger.valueOf(signatureType.toLong()))
-        
-        // 组合所有字段
-        val encoded = ByteArray(32 * 13)  // 13 个字段，每个 32 字节
+
+        val timestampBytes = encodeUint256(BigInteger(timestamp))
+        val metadataBytes = Numeric.hexStringToByteArray(metadata.removePrefix("0x").padStart(64, '0'))
+        val builderBytes = Numeric.hexStringToByteArray(builder.removePrefix("0x").padStart(64, '0'))
+
+        val encoded = ByteArray(32 * 12)  // typeHash + 11 个字段
        var offset = 0
        System.arraycopy(orderTypeHash, 0, encoded, offset, 32); offset += 32
        System.arraycopy(saltBytes, 0, encoded, offset, 32); offset += 32
        System.arraycopy(makerBytes, 0, encoded, offset, 32); offset += 32
        System.arraycopy(signerBytes, 0, encoded, offset, 32); offset += 32
-        System.arraycopy(takerBytes, 0, encoded, offset, 32); offset += 32
        System.arraycopy(tokenIdBytes, 0, encoded, offset, 32); offset += 32
        System.arraycopy(makerAmountBytes, 0, encoded, offset, 32); offset += 32
        System.arraycopy(takerAmountBytes, 0, encoded, offset, 32); offset += 32
-        System.arraycopy(expirationBytes, 0, encoded, offset, 32); offset += 32
-        System.arraycopy(nonceBytes, 0, encoded, offset, 32); offset += 32
-        System.arraycopy(feeRateBpsBytes, 0, encoded, offset, 32); offset += 32
        System.arraycopy(sideBytes, 0, encoded, offset, 32); offset += 32
-        System.arraycopy(signatureTypeBytes, 0, encoded, offset, 32)
-        
+        System.arraycopy(signatureTypeBytes, 0, encoded, offset, 32); offset += 32
+        System.arraycopy(timestampBytes, 0, encoded, offset, 32); offset += 32
+        System.arraycopy(metadataBytes, 0, encoded, offset, 32); offset += 32
+        System.arraycopy(builderBytes, 0, encoded, offset, 32)
+
        return keccak256(encoded)
    }
    
@@ -10,7 +10,7 @@ import java.math.BigInteger
 object EthereumUtils {
    
    // Polymarket 合约地址（Polygon 主网）
-    private val COLLATERAL_TOKEN_ADDRESS = "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174" // USDC
+    private val COLLATERAL_TOKEN_ADDRESS = "0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB" // pUSD
    private val CONDITIONAL_TOKENS_ADDRESS = "0x4D97DCd97eC945f40cF65F87097ACe5EA0476045" // ConditionalTokens
    
    /**
@@ -0,0 +1,5 @@
+-- 添加触发类型字段到加密价差策略触发记录表
+-- AUTO: 自动下单触发
+-- MANUAL: 手动下单触发
+ALTER TABLE crypto_tail_strategy_trigger 
+ADD COLUMN trigger_type VARCHAR(20) DEFAULT 'AUTO' COMMENT '触发类型：AUTO（自动）或 MANUAL（手动）';
@@ -0,0 +1,97 @@
+-- 消息模板表
+CREATE TABLE notification_templates (
+    id BIGINT AUTO_INCREMENT PRIMARY KEY,
+    template_type VARCHAR(50) NOT NULL COMMENT '模板类型',
+    template_content TEXT NOT NULL COMMENT '模板内容，支持 {{variable}} 变量',
+    is_default TINYINT(1) DEFAULT 0 COMMENT '是否使用默认模板（0=自定义，1=默认）',
+    created_at BIGINT NOT NULL,
+    updated_at BIGINT NOT NULL,
+    UNIQUE KEY uk_template_type (template_type)
+) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='消息推送模板';
+
+-- 插入默认模板
+INSERT INTO notification_templates (template_type, template_content, is_default, created_at, updated_at) VALUES
+('ORDER_SUCCESS', '🚀 <b>订单创建成功</b>
+
+📊 <b>订单信息：</b>
+• 订单ID: <code>{{order_id}}</code>
+• 市场: <a href="{{market_link}}">{{market_title}}</a>
+• 市场方向: <b>{{outcome}}</b>
+• 方向: <b>{{side}}</b>
+• 价格: <code>{{price}}</code>
+• 数量: <code>{{quantity}}</code> shares
+• 金额: <code>{{amount}}</code> USDC
+• 账户: {{account_name}}
+• 可用余额: <code>{{available_balance}}</code> USDC
+
+⏰ 时间: <code>{{time}}</code>', 1, UNIX_TIMESTAMP() * 1000, UNIX_TIMESTAMP() * 1000),
+
+('ORDER_FAILED', '❌ <b>订单创建失败</b>
+
+📊 <b>订单信息：</b>
+• 市场: <a href="{{market_link}}">{{market_title}}</a>
+• 市场方向: <b>{{outcome}}</b>
+• 方向: <b>{{side}}</b>
+• 价格: <code>{{price}}</code>
+• 数量: <code>{{quantity}}</code> shares
+• 金额: <code>{{amount}}</code> USDC
+• 账户: {{account_name}}
+
+⚠️ <b>错误信息：</b>
+<code>{{error_message}}</code>
+
+⏰ 时间: <code>{{time}}</code>', 1, UNIX_TIMESTAMP() * 1000, UNIX_TIMESTAMP() * 1000),
+
+('ORDER_FILTERED', '🚫 <b>订单被过滤</b>
+
+📊 <b>订单信息：</b>
+• 市场: <a href="{{market_link}}">{{market_title}}</a>
+• 市场方向: <b>{{outcome}}</b>
+• 方向: <b>{{side}}</b>
+• 价格: <code>{{price}}</code>
+• 数量: <code>{{quantity}}</code> shares
+• 金额: <code>{{amount}}</code> USDC
+• 账户: {{account_name}}
+
+⚠️ <b>过滤类型：</b> <code>{{filter_type}}</code>
+
+📝 <b>过滤原因：</b>
+<code>{{filter_reason}}</code>
+
+⏰ 时间: <code>{{time}}</code>', 1, UNIX_TIMESTAMP() * 1000, UNIX_TIMESTAMP() * 1000),
+
+('CRYPTO_TAIL_SUCCESS', '🚀 <b>加密价差策略下单成功</b>
+
+📊 <b>订单信息：</b>
+• 订单ID: <code>{{order_id}}</code>
+• 策略: {{strategy_name}}
+• 市场: <a href="{{market_link}}">{{market_title}}</a>
+• 市场方向: <b>{{outcome}}</b>
+• 方向: <b>{{side}}</b>
+• 价格: <code>{{price}}</code>
+• 数量: <code>{{quantity}}</code> shares
+• 金额: <code>{{amount}}</code> USDC
+• 账户: {{account_name}}
+
+⏰ 时间: <code>{{time}}</code>', 1, UNIX_TIMESTAMP() * 1000, UNIX_TIMESTAMP() * 1000),
+
+('REDEEM_SUCCESS', '💸 <b>仓位赎回成功</b>
+
+📊 <b>赎回信息：</b>
+• 账户: {{account_name}}
+• 交易哈希: <code>{{transaction_hash}}</code>
+• 赎回总价值: <code>{{total_value}}</code> USDC
+• 可用余额: <code>{{available_balance}}</code> USDC
+
+⏰ 时间: <code>{{time}}</code>', 1, UNIX_TIMESTAMP() * 1000, UNIX_TIMESTAMP() * 1000),
+
+('REDEEM_NO_RETURN', '📋 <b>仓位已结算（无收益）</b>
+
+📊 <b>结算信息：</b>
+<i>市场已结算，您的预测未命中，赎回价值为 0。</i>
+
+• 账户: {{account_name}}
+• 交易哈希: <code>{{transaction_hash}}</code>
+• 可用余额: <code>{{available_balance}}</code> USDC
+
+⏰ 时间: <code>{{time}}</code>', 1, UNIX_TIMESTAMP() * 1000, UNIX_TIMESTAMP() * 1000);
@@ -13,9 +13,18 @@ notification.order.quantity=Quantity
 notification.order.amount=Amount
 notification.order.account=Account
 notification.order.time=Time
+notification.order.available_balance=Available Balance
 notification.order.error_info=Error Information
 notification.order.unknown_account=Unknown Account
 notification.order.calculate_failed=Calculation Failed
+notification.order.filtered=Order Filtered
+notification.order.filter_reason=Filter Reason
+notification.order.filter_type=Filter Type
+notification.filter.type.order_depth=Insufficient Order Depth
+notification.filter.type.spread=Spread Too Large
+notification.filter.type.orderbook_depth=Insufficient Orderbook Depth
+notification.filter.type.price_validity=Invalid Price
+notification.filter.type.market_status=Market Not Tradable
 notification.tail.order.success=Crypto spread strategy order success
 notification.tail.strategy=Strategy
 notification.redeem.success=Position Redeemed Successfully
@@ -26,6 +35,13 @@ notification.redeem.position_count=Position Count
 notification.redeem.positions=Redeemed Positions
 notification.redeem.account=Account
 notification.redeem.time=Time
+notification.redeem.available_balance=Available Balance
+
+# Position Settled (No Return)
+notification.redeem.no_return.title=Position Settled (No Return)
+notification.redeem.no_return.info=Settlement Information
+notification.redeem.no_return.message=Market settled. Your prediction was incorrect. Redemption value is 0.
+notification.redeem.no_return.positions=Settled Positions

 # Auto Redeem related notifications
 notification.auto_redeem.disabled.title=Auto Redeem Disabled
@@ -13,9 +13,18 @@ notification.order.quantity=数量
 notification.order.amount=金额
 notification.order.account=账户
 notification.order.time=时间
+notification.order.available_balance=可用余额
 notification.order.error_info=错误信息
 notification.order.unknown_account=未知账户
 notification.order.calculate_failed=计算失败
+notification.order.filtered=订单被过滤
+notification.order.filter_reason=过滤原因
+notification.order.filter_type=过滤类型
+notification.filter.type.order_depth=订单深度不足
+notification.filter.type.spread=价差过大
+notification.filter.type.orderbook_depth=订单簿深度不足
+notification.filter.type.price_validity=价格不合理
+notification.filter.type.market_status=市场状态不可交易
 notification.tail.order.success=加密价差策略下单成功
 notification.tail.strategy=策略
 notification.redeem.success=仓位赎回成功
@@ -26,6 +35,13 @@ notification.redeem.position_count=仓位数量
 notification.redeem.positions=赎回仓位
 notification.redeem.account=账户
 notification.redeem.time=时间
+notification.redeem.available_balance=可用余额
+
+# 仓位已结算（无收益）
+notification.redeem.no_return.title=仓位已结算（无收益）
+notification.redeem.no_return.info=结算信息
+notification.redeem.no_return.message=市场已结算，您的预测未命中，赎回价值为 0。
+notification.redeem.no_return.positions=结算仓位

 # 自动赎回相关通知
 notification.auto_redeem.disabled.title=自动赎回未开启
@@ -13,9 +13,18 @@ notification.order.quantity=數量
 notification.order.amount=金額
 notification.order.account=賬戶
 notification.order.time=時間
+notification.order.available_balance=可用餘額
 notification.order.error_info=錯誤信息
 notification.order.unknown_account=未知賬戶
 notification.order.calculate_failed=計算失敗
+notification.order.filtered=訂單被過濾
+notification.order.filter_reason=過濾原因
+notification.order.filter_type=過濾類型
+notification.filter.type.order_depth=訂單深度不足
+notification.filter.type.spread=價差過大
+notification.filter.type.orderbook_depth=訂單簿深度不足
+notification.filter.type.price_validity=價格不合理
+notification.filter.type.market_status=市場狀態不可交易
 notification.tail.order.success=加密價差策略下單成功
 notification.tail.strategy=策略
 notification.redeem.success=倉位贖回成功
@@ -26,6 +35,13 @@ notification.redeem.position_count=倉位數量
 notification.redeem.positions=贖回倉位
 notification.redeem.account=賬戶
 notification.redeem.time=時間
+notification.redeem.available_balance=可用餘額
+
+# 倉位已結算（無收益）
+notification.redeem.no_return.title=倉位已結算（無收益）
+notification.redeem.no_return.info=結算信息
+notification.redeem.no_return.message=市場已結算，您的預測未命中，贖回價值為 0。
+notification.redeem.no_return.positions=結算倉位

 # 自動贖回相關通知
 notification.auto_redeem.disabled.title=自動贖回未開啟
@@ -1,4 +1,209 @@
-# PolyHermes 一键部署脚本使用说明
+# PolyHermes One-Click Deployment Script / PolyHermes 一键部署脚本使用说明
+
+[English](#english) | [中文](#中文)
+
+---
+
+<a name="english"></a>
+## English
+
+## ✨ Core Features
+
+- **Run from any directory** - No need to download source code
+- **Online images only** - Pull official images from Docker Hub
+- **Auto-download config** - Download the latest `docker-compose.prod.yml` from GitHub
+- **Interactive configuration** - User-friendly Q&A style configuration wizard
+- **Auto-generate secrets** - All sensitive configurations will auto-generate secure random values on Enter
+
+## 🚀 Quick Start
+
+### One-Click Installation (Recommended)
+
+**Using curl (Recommended):**
+```bash
+mkdir -p ~/polyhermes && cd ~/polyhermes && curl -fsSL https://raw.githubusercontent.com/WrBug/PolyHermes/main/deploy-interactive.sh -o deploy.sh && chmod +x deploy.sh && ./deploy.sh
+```
+
+**Using wget:**
+```bash
+mkdir -p ~/polyhermes && cd ~/polyhermes && wget -O deploy.sh https://raw.githubusercontent.com/WrBug/PolyHermes/main/deploy-interactive.sh && chmod +x deploy.sh && ./deploy.sh
+```
+
+This command will automatically:
+- 📁 Create a dedicated working directory `~/polyhermes`
+- 📥 Download the deployment script
+- ✅ Check Docker environment
+- ⚙️ Configure all parameters interactively (press Enter for defaults)
+- 🔐 Auto-generate secure random secrets
+- 🚀 Download latest images and deploy
+
+**Or run directly via pipe (without saving file):**
+```bash
+# curl method
+mkdir -p ~/polyhermes && cd ~/polyhermes && curl -fsSL https://raw.githubusercontent.com/WrBug/PolyHermes/main/deploy-interactive.sh | bash
+
+# wget method
+mkdir -p ~/polyhermes && cd ~/polyhermes && wget -qO- https://raw.githubusercontent.com/WrBug/PolyHermes/main/deploy-interactive.sh | bash
+```
+
+### Method 1: Download and Run Script Directly
+
+```bash
+# Download script
+curl -O https://raw.githubusercontent.com/WrBug/PolyHermes/main/deploy-interactive.sh
+
+# Add execute permission
+chmod +x deploy-interactive.sh
+
+# Run
+./deploy-interactive.sh
+```
+
+### Method 2: Run in Project Directory
+
+```bash
+git clone https://github.com/WrBug/PolyHermes.git
+cd PolyHermes
+./deploy-interactive.sh
+```
+
+## 📝 Usage Flow
+
+After running the script, you will be guided through the following steps:
+
+```
+Step 1: Environment Check  → Check Docker/Docker Compose
+Step 2: Configuration       → Interactive input (press Enter for defaults)
+Step 3: Get Deploy Config   → Download docker-compose.prod.yml from GitHub
+Step 4: Generate Env File   → Auto-generate .env
+Step 5: Pull Docker Images  → Pull latest images from Docker Hub
+Step 6: Deploy Services     → Start containers
+Step 7: Health Check        → Verify services are running properly
+```
+
+## ⚡ Simplest Usage
+
+**Press Enter for all configuration items to use default values**, the script will automatically:
+- Use port 80 (application) and 3307 (MySQL)
+- Generate 32-character database password
+- Generate 128-character JWT secret
+- Generate 64-character admin reset key
+- Generate 64-character encryption key
+- Configure reasonable log levels
+
+### Interactive Example
+
+The script will prompt you for configuration one by one, **press Enter to skip and use default values**:
+
+```
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  Step 2: Configuration
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+💡 All configurations are optional, press Enter to use default or auto-generated values
+
+⚠ Secret config: Press Enter to auto-generate secure random secrets
+⚠ Other config: Press Enter to use default values in parentheses
+
+【Basic Configuration】
+Will configure: Server port, MySQL port, Timezone
+➤ Server port [Default: 80]: ⏎
+➤ MySQL port (external access) [Default: 3307]: ⏎
+➤ Timezone [Default: Asia/Shanghai]: ⏎
+
+【Database Configuration】
+Will configure: Database username, Database password
+➤ Database username [Default: root]: ⏎
+➤ Database password [Enter to auto-generate]: ⏎
+[✓] Database password auto-generated (32 characters)
+
+【Security Configuration】
+Will configure: JWT secret, Admin password reset key, Data encryption key
+➤ JWT secret [Enter to auto-generate]: ⏎
+[✓] JWT secret auto-generated (128 characters)
+➤ Admin password reset key [Enter to auto-generate]: ⏎
+[✓] Admin reset key auto-generated (64 characters)
+➤ Encryption key (for API Key encryption) [Enter to auto-generate]: ⏎
+[✓] Encryption key auto-generated (64 characters)
+
+【Log Configuration】
+Will configure: Root log level, Application log level
+Available levels: TRACE, DEBUG, INFO, WARN, ERROR, OFF
+➤ Root log level (third-party libs) [Default: WARN]: ⏎
+➤ Application log level [Default: INFO]: ⏎
+
+【Other Configuration】
+Will configure: Runtime environment, Auto-update policy, GitHub repo
+➤ Spring Profile [Default: prod]: ⏎
+➤ Allow prerelease updates (true/false) [Default: false]: ⏎
+➤ GitHub repository [Default: WrBug/PolyHermes]: ⏎
+```
+
+## 🔧 Files Generated by Script
+
+After running, the script will generate in the current directory:
+
+1. **docker-compose.prod.yml** - Docker Compose config downloaded from GitHub (always latest)
+2. **.env** - Environment variables file auto-generated based on your configuration
+
+These two files contain all the configuration needed to run PolyHermes.
+
+## 🌐 Post-Deployment Management
+
+### Quick Update (Recommended)
+
+If you already have configuration files, running the script again will detect and ask:
+
+```bash
+./deploy-interactive.sh
+```
+
+```
+【Existing Configuration Detected】
+Found existing .env configuration file
+
+Use existing configuration to update images directly? [Y/n]: ⏎
+```
+
+- **Press Enter or input Y**: Use existing config, pull latest images and update
+- **Input N**: Reconfigure (existing config will be backed up)
+
+### Manual Management Commands
+
+```bash
+# View service status
+docker compose -f docker-compose.prod.yml ps
+
+# View logs
+docker compose -f docker-compose.prod.yml logs -f
+
+# Restart services
+docker compose -f docker-compose.prod.yml restart
+
+# Stop services
+docker compose -f docker-compose.prod.yml down
+
+# Update to latest version
+docker pull wrbug/polyhermes:latest
+docker compose -f docker-compose.prod.yml up -d
+```
+
+## 🔐 Security Recommendations
+
+- **Protect .env file**: Contains sensitive information, never commit to version control
+- **Backup database regularly**: Data is stored in Docker volume `mysql-data`
+- **Configure HTTPS for production**: Recommend using Nginx or Caddy as reverse proxy
+
+## 📞 Support
+
+- [GitHub Repository](https://github.com/WrBug/PolyHermes)
+- [Issue Feedback](https://github.com/WrBug/PolyHermes/issues)
+- [Full Deployment Documentation](docs/zh/DEPLOYMENT_GUIDE.md)
+
+---
+
+<a name="中文"></a>
+## 中文

 ## ✨ 核心特性

@@ -1,18 +1,19 @@
 #!/bin/bash

 # ========================================
+# PolyHermes Interactive Deploy Script
 # PolyHermes 交互式一键部署脚本
 # ========================================
-# 功能：
-# - 交互式配置环境变量
-# - 自动生成安全密钥
-# - 使用 Docker Hub 线上镜像部署
-# - 支持配置预检和回滚
+# Features / 功能：
+# - Interactive env config / 交互式配置环境变量
+# - Auto-generate secrets / 自动生成安全密钥
+# - Deploy via Docker Hub images / 使用 Docker Hub 线上镜像部署
+# - Config check and rollback / 支持配置预检和回滚
 # ========================================

 set -e

-# 颜色输出
+# Colors / 颜色输出
 RED='\033[0;31m'
 GREEN='\033[0;32m'
 YELLOW='\033[1;33m'
@@ -20,7 +21,14 @@ BLUE='\033[0;34m'
 CYAN='\033[0;36m'
 NC='\033[0m' # No Color

-# 打印函数
+# Language: LANG=zh* → prompts in Chinese only; else show "中文 / English"
+# 语言：LANG 为 zh* 时仅中文，否则显示「中文 / English」
+USE_ZH_ONLY=false
+case "${LANG:-}" in
+    zh*) USE_ZH_ONLY=true ;;
+esac
+
+# Print functions / 打印函数
 info() {
    echo -e "${GREEN}[✓]${NC} $1"
 }
@@ -37,6 +45,17 @@ title() {
    echo -e "${CYAN}${1}${NC}"
 }

+# Bilingual: 中文 / English (or Chinese only when LANG=zh*)
+bilingual() {
+    local zh="$1"
+    local en="$2"
+    if [ "$USE_ZH_ONLY" = true ]; then
+        echo "$zh"
+    else
+        echo "$zh / $en"
+    fi
+}
+
 # 生成随机密钥
 generate_secret() {
    local length=${1:-32}
@@ -47,54 +66,57 @@ generate_secret() {
    fi
 }

-# 生成随机端口号（10000-60000之间）
+# 生成随机端口号（10000-60000之间）/ Generate random port (10000-60000)
 generate_random_port() {
    echo $((10000 + RANDOM % 50001))
 }

-# 读取用户输入（支持默认值）
+# 读取用户输入（支持默认值）/ Read user input (with default)
 read_input() {
    local prompt="$1"
    local default="$2"
    local is_secret="$3"
    local value=""
    
-    # 构建提示信息（不使用颜色，因为 read -p 可能不支持）
    local prompt_text=""
    if [ -n "$default" ]; then
        if [ "$is_secret" = "secret" ]; then
-            prompt_text="${prompt} [回车自动生成]: "
+            if [ "$USE_ZH_ONLY" = true ]; then
+                prompt_text="${prompt} [回车自动生成]: "
+            else
+                prompt_text="${prompt} [Enter to auto-generate]: "
+            fi
        else
-            prompt_text="${prompt} [默认: ${default}]: "
+            if [ "$USE_ZH_ONLY" = true ]; then
+                prompt_text="${prompt} [默认: ${default}]: "
+            else
+                prompt_text="${prompt} [Default: ${default}]: "
+            fi
        fi
    else
        prompt_text="${prompt}: "
    fi
    
-    # 使用 read -p 确保提示正确显示
    read -r -p "$prompt_text" value
    
-    # 如果用户没有输入，使用默认值
    if [ -z "$value" ]; then
        if [ "$is_secret" = "secret" ] && [ -z "$default" ]; then
-            # 自动生成密钥
            case "$prompt" in
-                *JWT*)
+                *JWT*|*jwt*)
                    value=$(generate_secret 64)
-                    # 输出到 stderr，避免被捕获到返回值中
-                    info "已自动生成 JWT 密钥（128字符）" >&2
+                    info "$(bilingual "已自动生成 JWT 密钥（128字符）" "JWT secret auto-generated (128 chars)")" >&2
                    ;;
-                *管理员*|*ADMIN*)
+                *管理员*|*ADMIN*|*admin*|*reset*|*Reset*)
                    value=$(generate_secret 32)
-                    info "已自动生成管理员重置密钥（64字符）" >&2
+                    info "$(bilingual "已自动生成管理员重置密钥（64字符）" "Admin reset key auto-generated (64 chars)")" >&2
                    ;;
-                *加密*|*CRYPTO*)
+                *加密*|*CRYPTO*|*crypto*|*Encryption*)
                    value=$(generate_secret 32)
-                    info "已自动生成加密密钥（64字符）" >&2
+                    info "$(bilingual "已自动生成加密密钥（64字符）" "Encryption key auto-generated (64 chars)")" >&2
                    ;;
-                *数据库密码*|*DB_PASSWORD*)
+                *数据库密码*|*DB_PASSWORD*|*database*|*Database*)
                    value=$(generate_secret 16)
-                    info "已自动生成数据库密码（32字符）" >&2
+                    info "$(bilingual "已自动生成数据库密码（32字符）" "Database password auto-generated (32 chars)")" >&2
                    ;;
                *)
                    value="$default"
@@ -108,126 +130,115 @@ read_input() {
    echo "$value"
 }

-# 检查 Docker 环境
+# 检查 Docker 环境 / Check Docker environment
 check_docker() {
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  步骤 1: 环境检查"
+    title "  $(bilingual "步骤 1: 环境检查" "Step 1: Environment Check")"
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    
-    # 检查 Docker
    if ! command -v docker &> /dev/null; then
-        error "Docker 未安装"
+        error "$(bilingual "Docker 未安装" "Docker is not installed")"
        echo ""
-        info "请先安装 Docker："
+        info "$(bilingual "请先安装 Docker：" "Please install Docker first:")"
        info "  macOS: brew install docker"
        info "  Ubuntu/Debian: apt-get install docker.io"
        info "  CentOS/RHEL: yum install docker"
        exit 1
    fi
-    info "Docker 已安装: $(docker --version | head -1)"
+    info "$(bilingual "Docker 已安装" "Docker installed"): $(docker --version | head -1)"
    
-    # 检查 Docker Compose
    if docker compose version &> /dev/null 2>&1; then
-        info "Docker Compose 已安装: $(docker compose version)"
+        info "$(bilingual "Docker Compose 已安装" "Docker Compose installed"): $(docker compose version)"
    elif command -v docker-compose &> /dev/null; then
-        info "Docker Compose 已安装: $(docker-compose --version)"
+        info "$(bilingual "Docker Compose 已安装" "Docker Compose installed"): $(docker-compose --version)"
    else
-        error "Docker Compose 未安装"
+        error "$(bilingual "Docker Compose 未安装" "Docker Compose is not installed")"
        echo ""
-        info "请先安装 Docker Compose："
+        info "$(bilingual "请先安装 Docker Compose：" "Please install Docker Compose:")"
        info "  https://docs.docker.com/compose/install/"
        exit 1
    fi
    
-    # 检查 Docker 守护进程
    if ! docker info &> /dev/null; then
-        error "Docker 守护进程未运行"
-        info "请启动 Docker 服务："
-        info "  macOS: 打开 Docker Desktop"
+        error "$(bilingual "Docker 守护进程未运行" "Docker daemon is not running")"
+        info "$(bilingual "请启动 Docker 服务：" "Please start Docker:")"
+        info "  $(bilingual "macOS: 打开 Docker Desktop" "macOS: Open Docker Desktop")"
        info "  Linux: systemctl start docker"
        exit 1
    fi
-    info "Docker 守护进程运行正常"
+    info "$(bilingual "Docker 守护进程运行正常" "Docker daemon is running")"
    
    echo ""
 }

-# 交互式配置收集
+# 交互式配置收集 / Interactive configuration
 collect_configuration() {
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  步骤 2: 配置收集"
+    title "  $(bilingual "步骤 2: 配置收集" "Step 2: Configuration")"
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    echo ""
-    info "💡 所有配置项均为可选，直接按回车即可使用默认值或自动生成"
+    info "$(bilingual "💡 所有配置项均为可选，直接按回车即可使用默认值或自动生成" "💡 All options are optional, press Enter for default or auto-generated values")"
    echo ""
-    warn "密钥配置：回车将自动生成安全的随机密钥"
-    warn "其他配置：回车将使用括号中的默认值"
+    warn "$(bilingual "密钥配置：回车将自动生成安全的随机密钥" "Secrets: Enter to auto-generate secure random keys")"
+    warn "$(bilingual "其他配置：回车将使用括号中的默认值" "Other: Enter to use default value in brackets")"
    echo ""
    
-    # 基础配置
-    title "【基础配置】"
-    echo -e "${CYAN}将配置：服务器端口、MySQL端口、时区${NC}"
-    # 生成随机端口作为默认值
+    title "$(bilingual "【基础配置】" "【Basic】")"
+    echo -e "${CYAN}$(bilingual "将配置：服务器端口、MySQL端口、时区" "Server port, MySQL port, Timezone")${NC}"
    DEFAULT_PORT=$(generate_random_port)
-    SERVER_PORT=$(read_input "➤ 服务器端口" "$DEFAULT_PORT")
-    MYSQL_PORT=$(read_input "➤ MySQL 端口（外部访问）" "3307")
-    TZ=$(read_input "➤ 时区" "Asia/Shanghai")
+    SERVER_PORT=$(read_input "$(bilingual "➤ 服务器端口" "➤ Server port")" "$DEFAULT_PORT")
+    MYSQL_PORT=$(read_input "$(bilingual "➤ MySQL 端口（外部访问）" "➤ MySQL port (external)")" "3307")
+    TZ=$(read_input "$(bilingual "➤ 时区" "➤ Timezone")" "Asia/Shanghai")
    echo ""
    
-    # 数据库配置
-    title "【数据库配置】"
-    echo -e "${CYAN}将配置：数据库用户名、数据库密码${NC}"
-    echo -e "${YELLOW}💡 提示：密码留空将自动生成 32 字符的安全随机密码${NC}"
-    DB_USERNAME=$(read_input "➤ 数据库用户名" "root")
-    DB_PASSWORD=$(read_input "➤ 数据库密码" "" "secret")
+    title "$(bilingual "【数据库配置】" "【Database】")"
+    echo -e "${CYAN}$(bilingual "将配置：数据库用户名、数据库密码" "Database username, password")${NC}"
+    echo -e "${YELLOW}$(bilingual "💡 提示：密码留空将自动生成 32 字符的安全随机密码" "💡 Leave password empty to auto-generate 32-char password")${NC}"
+    DB_USERNAME=$(read_input "$(bilingual "➤ 数据库用户名" "➤ Database username")" "root")
+    DB_PASSWORD=$(read_input "$(bilingual "➤ 数据库密码" "➤ Database password")" "" "secret")
    echo ""
    
-    # 安全配置
-    title "【安全配置】"
-    echo -e "${CYAN}将配置：JWT密钥、管理员密码重置密钥、数据加密密钥${NC}"
-    echo -e "${YELLOW}💡 提示：留空将自动生成高强度随机密钥（推荐）${NC}"
-    JWT_SECRET=$(read_input "➤ JWT 密钥" "" "secret")
-    ADMIN_RESET_PASSWORD_KEY=$(read_input "➤ 管理员密码重置密钥" "" "secret")
-    CRYPTO_SECRET_KEY=$(read_input "➤ 加密密钥（用于加密 API Key）" "" "secret")
+    title "$(bilingual "【安全配置】" "【Security】")"
+    echo -e "${CYAN}$(bilingual "将配置：JWT密钥、管理员密码重置密钥、数据加密密钥" "JWT secret, Admin reset key, Encryption key")${NC}"
+    echo -e "${YELLOW}$(bilingual "💡 提示：留空将自动生成高强度随机密钥（推荐）" "💡 Leave empty to auto-generate strong keys (recommended)")${NC}"
+    JWT_SECRET=$(read_input "$(bilingual "➤ JWT 密钥" "➤ JWT secret")" "" "secret")
+    ADMIN_RESET_PASSWORD_KEY=$(read_input "$(bilingual "➤ 管理员密码重置密钥" "➤ Admin password reset key")" "" "secret")
+    CRYPTO_SECRET_KEY=$(read_input "$(bilingual "➤ 加密密钥（用于加密 API Key）" "➤ Encryption key (for API Key)")" "" "secret")
    echo ""
    
-    # 日志配置
-    title "【日志配置】"
-    echo -e "${CYAN}将配置：Root日志级别、应用日志级别${NC}"
-    echo -e "${YELLOW}可选级别: TRACE, DEBUG, INFO, WARN, ERROR, OFF${NC}"
-    LOG_LEVEL_ROOT=$(read_input "➤ Root 日志级别（第三方库）" "WARN")
-    LOG_LEVEL_APP=$(read_input "➤ 应用日志级别" "INFO")
+    title "$(bilingual "【日志配置】" "【Logging】")"
+    echo -e "${CYAN}$(bilingual "将配置：Root日志级别、应用日志级别" "Root log level, App log level")${NC}"
+    echo -e "${YELLOW}$(bilingual "可选级别: TRACE, DEBUG, INFO, WARN, ERROR, OFF" "Levels: TRACE, DEBUG, INFO, WARN, ERROR, OFF")${NC}"
+    LOG_LEVEL_ROOT=$(read_input "$(bilingual "➤ Root 日志级别（第三方库）" "➤ Root log level (3rd party)")" "WARN")
+    LOG_LEVEL_APP=$(read_input "$(bilingual "➤ 应用日志级别" "➤ App log level")" "INFO")
    echo ""
    
-    # 自动设置不需要用户输入的配置
    SPRING_PROFILES_ACTIVE="prod"
    ALLOW_PRERELEASE="false"
    GITHUB_REPO="WrBug/PolyHermes"
 }

-# 下载 docker-compose.prod.yml（如果不存在）
+# 下载 docker-compose.prod.yml（如果不存在）/ Download docker-compose.prod.yml if missing
 download_docker_compose_file() {
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  步骤 3: 获取部署配置"
+    title "  $(bilingual "步骤 3: 获取部署配置" "Step 3: Get Deploy Config")"
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    
    if [ -f "docker-compose.prod.yml" ]; then
-        info "检测到现有 docker-compose.prod.yml，跳过下载"
+        info "$(bilingual "检测到现有 docker-compose.prod.yml，跳过下载" "Existing docker-compose.prod.yml found, skip download")"
        echo ""
        return 0
    fi
    
-    info "正在从 GitHub 下载 docker-compose.prod.yml..."
+    info "$(bilingual "正在从 GitHub 下载 docker-compose.prod.yml..." "Downloading docker-compose.prod.yml from GitHub...")"
    
-    # GitHub raw 文件链接
    local compose_url="https://raw.githubusercontent.com/WrBug/PolyHermes/main/docker-compose.prod.yml"
    
-    # 尝试下载
    if curl -fsSL "$compose_url" -o docker-compose.prod.yml; then
-        info "docker-compose.prod.yml 下载成功"
+        info "$(bilingual "docker-compose.prod.yml 下载成功" "docker-compose.prod.yml downloaded")"
    else
-        error "docker-compose.prod.yml 下载失败"
-        warn "请检查网络连接或手动下载："
+        error "$(bilingual "docker-compose.prod.yml 下载失败" "Failed to download docker-compose.prod.yml")"
+        warn "$(bilingual "请检查网络连接或手动下载：" "Check network or download manually:")"
        warn "  $compose_url"
        exit 1
    fi
@@ -235,28 +246,26 @@ download_docker_compose_file() {
    echo ""
 }

-# 生成 .env 文件
+# 生成 .env 文件 / Generate .env file
 generate_env_file() {
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  步骤 4: 生成环境变量文件"
+    title "  $(bilingual "步骤 4: 生成环境变量文件" "Step 4: Generate .env")"
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    
-    # 备份现有 .env 文件
    if [ -f ".env" ]; then
        BACKUP_FILE=".env.backup.$(date +%Y%m%d_%H%M%S)"
        cp .env "$BACKUP_FILE"
-        warn "已备份现有配置文件到: $BACKUP_FILE"
+        warn "$(bilingual "已备份现有配置文件到" "Backed up existing config to"): $BACKUP_FILE"
    fi
    
-    # 生成新的 .env 文件
    cat > .env <<EOF
 # ========================================
-# PolyHermes 生产环境配置
-# 生成时间: $(date '+%Y-%m-%d %H:%M:%S')
+# PolyHermes Production Config / 生产环境配置
+# Generated / 生成时间: $(date '+%Y-%m-%d %H:%M:%S')
 # ========================================

 # ============================================
-# 基础配置
+# Basic / 基础配置
 # ============================================
 TZ=${TZ}
 SPRING_PROFILES_ACTIVE=${SPRING_PROFILES_ACTIVE}
@@ -264,112 +273,107 @@ SERVER_PORT=${SERVER_PORT}
 MYSQL_PORT=${MYSQL_PORT}

 # ============================================
-# 数据库配置
+# Database / 数据库配置
 # ============================================
 DB_URL=jdbc:mysql://mysql:3306/polyhermes?useSSL=false&serverTimezone=UTC&characterEncoding=utf8&allowPublicKeyRetrieval=true
 DB_USERNAME=${DB_USERNAME}
 DB_PASSWORD=${DB_PASSWORD}

 # ============================================
-# 安全配置（请妥善保管）
+# Security (keep safe) / 安全配置（请妥善保管）
 # ============================================
 JWT_SECRET=${JWT_SECRET}
 ADMIN_RESET_PASSWORD_KEY=${ADMIN_RESET_PASSWORD_KEY}
 CRYPTO_SECRET_KEY=${CRYPTO_SECRET_KEY}

 # ============================================
-# 日志配置
+# Logging / 日志配置
 # ============================================
 LOG_LEVEL_ROOT=${LOG_LEVEL_ROOT}
 LOG_LEVEL_APP=${LOG_LEVEL_APP}

 # ============================================
-# 其他配置
+# Other / 其他配置
 # ============================================
 ALLOW_PRERELEASE=${ALLOW_PRERELEASE}
 GITHUB_REPO=${GITHUB_REPO}
 EOF
    
-    info "配置文件已生成: .env"
+    info "$(bilingual "配置文件已生成" "Config file generated"): .env"
    echo ""
    
-    # 显示配置摘要
-    title "【配置摘要】"
-    echo "  服务器端口: ${SERVER_PORT}"
-    echo "  MySQL 端口: ${MYSQL_PORT}"
-    echo "  时区: ${TZ}"
-    echo "  数据库用户: ${DB_USERNAME}"
-    echo "  数据库密码: ${DB_PASSWORD:0:8}... (已隐藏)"
-    echo "  JWT 密钥: ${JWT_SECRET:0:16}... (已隐藏)"
-    echo "  管理员重置密钥: ${ADMIN_RESET_PASSWORD_KEY:0:16}... (已隐藏)"
-    echo "  加密密钥: ${CRYPTO_SECRET_KEY:0:16}... (已隐藏)"
-    echo "  日志级别: Root=${LOG_LEVEL_ROOT}, App=${LOG_LEVEL_APP}"
+    title "$(bilingual "【配置摘要】" "【Config Summary】")"
+    echo "  $(bilingual "服务器端口" "Server port"): ${SERVER_PORT}"
+    echo "  $(bilingual "MySQL 端口" "MySQL port"): ${MYSQL_PORT}"
+    echo "  $(bilingual "时区" "Timezone"): ${TZ}"
+    echo "  $(bilingual "数据库用户" "DB user"): ${DB_USERNAME}"
+    echo "  $(bilingual "数据库密码" "DB password"): ${DB_PASSWORD:0:8}... $(bilingual "(已隐藏)" "(hidden)")"
+    echo "  $(bilingual "JWT 密钥" "JWT secret"): ${JWT_SECRET:0:16}... $(bilingual "(已隐藏)" "(hidden)")"
+    echo "  $(bilingual "管理员重置密钥" "Admin reset key"): ${ADMIN_RESET_PASSWORD_KEY:0:16}... $(bilingual "(已隐藏)" "(hidden)")"
+    echo "  $(bilingual "加密密钥" "Encryption key"): ${CRYPTO_SECRET_KEY:0:16}... $(bilingual "(已隐藏)" "(hidden)")"
+    echo "  $(bilingual "日志级别" "Log level"): Root=${LOG_LEVEL_ROOT}, App=${LOG_LEVEL_APP}"
    echo ""
 }

-# 拉取镜像
+# 拉取镜像 / Pull images
 pull_images() {
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  步骤 5: 拉取 Docker 镜像"
+    title "  $(bilingual "步骤 5: 拉取 Docker 镜像" "Step 5: Pull Docker Images")"
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    
-    info "正在从 Docker Hub 拉取最新镜像..."
+    info "$(bilingual "正在从 Docker Hub 拉取最新镜像..." "Pulling latest images from Docker Hub...")"
    
-    # 拉取应用镜像
    if docker pull wrbug/polyhermes:latest; then
-        info "应用镜像拉取成功: wrbug/polyhermes:latest"
+        info "$(bilingual "应用镜像拉取成功" "App image pulled"): wrbug/polyhermes:latest"
    else
-        error "应用镜像拉取失败"
-        warn "可能的原因："
-        warn "  1. 网络连接问题"
-        warn "  2. Docker Hub 服务异常"
-        warn "  3. 镜像不存在"
+        error "$(bilingual "应用镜像拉取失败" "Failed to pull app image")"
+        warn "$(bilingual "可能的原因：" "Possible reasons:")"
+        warn "  1. $(bilingual "网络连接问题" "Network issue")"
+        warn "  2. $(bilingual "Docker Hub 服务异常" "Docker Hub unavailable")"
+        warn "  3. $(bilingual "镜像不存在" "Image not found")"
        exit 1
    fi
    
-    # 拉取 MySQL 镜像
    if docker pull mysql:8.2; then
-        info "MySQL 镜像拉取成功: mysql:8.2"
+        info "$(bilingual "MySQL 镜像拉取成功" "MySQL image pulled"): mysql:8.2"
    else
-        warn "MySQL 镜像拉取失败，将在启动时自动下载"
+        warn "$(bilingual "MySQL 镜像拉取失败，将在启动时自动下载" "MySQL pull failed, will download on start")"
    fi
    
    echo ""
 }

-# 部署服务
+# 部署服务 / Deploy services
 deploy_services() {
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  步骤 6: 部署服务"
+    title "  $(bilingual "步骤 6: 部署服务" "Step 6: Deploy Services")"
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    
-    # 停止现有服务
    if docker compose -f docker-compose.prod.yml ps -q 2>/dev/null | grep -q .; then
-        warn "检测到正在运行的服务，正在停止..."
+        warn "$(bilingual "检测到正在运行的服务，正在停止..." "Stopping existing services...")"
        docker compose -f docker-compose.prod.yml down
-        info "已停止现有服务"
+        info "$(bilingual "已停止现有服务" "Stopped existing services")"
    fi
    
-    # 启动服务
-    info "正在启动服务..."
+    info "$(bilingual "正在启动服务..." "Starting services...")"
    if docker compose -f docker-compose.prod.yml up -d; then
-        info "服务启动成功"
+        info "$(bilingual "服务启动成功" "Services started")"
    else
-        error "服务启动失败"
-        error "请检查日志: docker compose -f docker-compose.prod.yml logs"
+        error "$(bilingual "服务启动失败" "Failed to start services")"
+        error "$(bilingual "请检查日志" "Check logs"): docker compose -f docker-compose.prod.yml logs"
        exit 1
    fi
    
    echo ""
 }

-# 健康检查
+# 健康检查 / Health check
 health_check() {
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  步骤 7: 健康检查"
+    title "  $(bilingual "步骤 7: 健康检查" "Step 7: Health Check")"
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    
-    info "等待服务启动（最多等待 60 秒）..."
+    info "$(bilingual "等待服务启动（最多等待 60 秒）..." "Waiting for services (up to 60s)...")"
    
    local max_attempts=12
    local attempt=0
@@ -377,13 +381,11 @@ health_check() {
    while [ $attempt -lt $max_attempts ]; do
        attempt=$((attempt + 1))
        
-        # 检查容器状态
        if docker compose -f docker-compose.prod.yml ps | grep -q "Up"; then
-            info "容器运行正常"
+            info "$(bilingual "容器运行正常" "Containers are up")"
            
-            # 检查应用是否响应
            if curl -s -o /dev/null -w "%{http_code}" http://localhost:${SERVER_PORT} | grep -q "200\|302\|401"; then
-                info "应用响应正常"
+                info "$(bilingual "应用响应正常" "App is responding")"
                echo ""
                return 0
            fi
@@ -394,79 +396,76 @@ health_check() {
    done
    
    echo ""
-    warn "健康检查超时，请手动检查服务状态"
-    warn "查看日志: docker compose -f docker-compose.prod.yml logs -f"
+    warn "$(bilingual "健康检查超时，请手动检查服务状态" "Health check timeout, please check services manually")"
+    warn "$(bilingual "查看日志" "View logs"): docker compose -f docker-compose.prod.yml logs -f"
    echo ""
 }

-# 显示部署信息
+# 显示部署信息 / Show deployment info
 show_deployment_info() {
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
-    title "  部署完成！"
+    title "  $(bilingual "部署完成！" "Deployment Complete!")"
    title "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
    echo ""
    
-    info "访问地址: ${GREEN}http://localhost:${SERVER_PORT}${NC}"
+    info "$(bilingual "访问地址" "Access URL"): ${GREEN}http://localhost:${SERVER_PORT}${NC}"
    echo ""
    
-    title "【常用命令】"
-    echo -e "  查看服务状态: ${CYAN}docker compose -f docker-compose.prod.yml ps${NC}"
-    echo -e "  查看日志: ${CYAN}docker compose -f docker-compose.prod.yml logs -f${NC}"
-    echo -e "  停止服务: ${CYAN}docker compose -f docker-compose.prod.yml down${NC}"
-    echo -e "  重启服务: ${CYAN}docker compose -f docker-compose.prod.yml restart${NC}"
-    echo -e "  更新镜像: ${CYAN}docker pull wrbug/polyhermes:latest && docker compose -f docker-compose.prod.yml up -d${NC}"
+    title "$(bilingual "【常用命令】" "【Common Commands】")"
+    echo -e "  $(bilingual "查看服务状态" "Status"): ${CYAN}docker compose -f docker-compose.prod.yml ps${NC}"
+    echo -e "  $(bilingual "查看日志" "Logs"): ${CYAN}docker compose -f docker-compose.prod.yml logs -f${NC}"
+    echo -e "  $(bilingual "停止服务" "Stop"): ${CYAN}docker compose -f docker-compose.prod.yml down${NC}"
+    echo -e "  $(bilingual "重启服务" "Restart"): ${CYAN}docker compose -f docker-compose.prod.yml restart${NC}"
+    echo -e "  $(bilingual "更新镜像" "Update"): ${CYAN}docker pull wrbug/polyhermes:latest && docker compose -f docker-compose.prod.yml up -d${NC}"
    echo ""
    
-    title "【数据库连接信息】"
-    echo -e "  主机: ${CYAN}localhost${NC}"
-    echo -e "  端口: ${CYAN}${MYSQL_PORT}${NC}"
-    echo -e "  数据库: ${CYAN}polyhermes${NC}"
-    echo -e "  用户名: ${CYAN}${DB_USERNAME}${NC}"
-    echo -e "  密码: ${CYAN}${DB_PASSWORD}${NC}"
+    title "$(bilingual "【数据库连接信息】" "【Database Connection】")"
+    echo -e "  $(bilingual "主机" "Host"): ${CYAN}localhost${NC}"
+    echo -e "  $(bilingual "端口" "Port"): ${CYAN}${MYSQL_PORT}${NC}"
+    echo -e "  $(bilingual "数据库" "Database"): ${CYAN}polyhermes${NC}"
+    echo -e "  $(bilingual "用户名" "Username"): ${CYAN}${DB_USERNAME}${NC}"
+    echo -e "  $(bilingual "密码" "Password"): ${CYAN}${DB_PASSWORD}${NC}"
    echo ""
    
-    title "【管理员重置密钥】"
-    echo -e "  重置密钥: ${CYAN}${ADMIN_RESET_PASSWORD_KEY}${NC}"
-    echo -e "  ${YELLOW}💡 此密钥用于重置管理员密码，请妥善保管${NC}"
+    title "$(bilingual "【管理员重置密钥】" "【Admin Reset Key】")"
+    echo -e "  $(bilingual "重置密钥" "Reset key"): ${CYAN}${ADMIN_RESET_PASSWORD_KEY}${NC}"
+    echo -e "  ${YELLOW}$(bilingual "💡 此密钥用于重置管理员密码，请妥善保管" "💡 Keep this key safe; it is used to reset admin password")${NC}"
    echo ""
    
-    warn "重要提示："
-    warn "  1. 请妥善保管 .env 文件，勿提交到版本控制系统"
-    warn "  2. 定期备份数据库数据（位于 Docker volume: polyhermes_mysql-data）"
-    warn "  3. 生产环境建议配置反向代理（如 Nginx）并启用 HTTPS"
+    warn "$(bilingual "重要提示：" "Important:")"
+    warn "  1. $(bilingual "请妥善保管 .env 文件，勿提交到版本控制系统" "Keep .env secure; do not commit to version control")"
+    warn "  2. $(bilingual "定期备份数据库数据（位于 Docker volume: polyhermes_mysql-data）" "Back up DB regularly (Docker volume: polyhermes_mysql-data)")"
+    warn "  3. $(bilingual "生产环境建议配置反向代理（如 Nginx）并启用 HTTPS" "Use a reverse proxy (e.g. Nginx) and HTTPS in production")"
    echo ""
 }

-# 主函数
+# 主函数 / Main
 main() {
    clear
    
    echo ""
    title "========================================="
-    title "   PolyHermes 交互式一键部署脚本   "
+    title "   $(bilingual "PolyHermes 交互式一键部署脚本" "PolyHermes Interactive Deploy")   "
    title "========================================="
    echo ""
    
-    # 执行部署流程
    check_docker
    
-    # 检查是否已存在 .env 文件
    if [ -f ".env" ]; then
        echo ""
-        title "【检测到现有配置】"
-        info "发现已存在的 .env 配置文件"
+        title "$(bilingual "【检测到现有配置】" "【Existing Config Found】")"
+        info "$(bilingual "发现已存在的 .env 配置文件" "Found existing .env file")"
        echo ""
-        echo -ne "${YELLOW}是否使用现有配置直接更新镜像？[Y/n]: ${NC}"
+        echo -ne "${YELLOW}$(bilingual "是否使用现有配置直接更新镜像？[Y/n]" "Use existing config to update images? [Y/n]"): ${NC}"
        read -r use_existing
        use_existing=${use_existing:-Y}
        
        if [[ "$use_existing" =~ ^[Yy]$ ]]; then
-            info "将使用现有配置，跳过配置步骤"
+            info "$(bilingual "将使用现有配置，跳过配置步骤" "Using existing config, skipping configuration")"
            echo ""
-            # 从现有 .env 文件读取必要的变量
            source .env 2>/dev/null || true
        else
-            warn "将重新配置，现有配置将被备份"
+            warn "$(bilingual "将重新配置，现有配置将被备份" "Will reconfigure; existing config will be backed up")"
            echo ""
            collect_configuration
        fi
@@ -476,21 +475,18 @@ main() {
    
    download_docker_compose_file
    
-    # 只有在重新配置时才生成新的 .env 文件
    if [[ ! "$use_existing" =~ ^[Yy]$ ]] || [ ! -f ".env" ]; then
        generate_env_file
    fi
    
-    # 确认部署
    echo ""
-    title "【确认部署】"
-    echo -ne "${YELLOW}是否开始部署？[Y/n]（回车默认为是）: ${NC}"
+    title "$(bilingual "【确认部署】" "【Confirm Deploy】")"
+    echo -ne "${YELLOW}$(bilingual "是否开始部署？[Y/n]（回车默认为是）" "Start deployment? [Y/n] (Enter = Yes)"): ${NC}"
    read -r confirm
    
-    # 默认为 Y，只有明确输入 n/N 才取消
    confirm=${confirm:-Y}
    if [[ "$confirm" =~ ^[Nn]$ ]]; then
-        warn "部署已取消"
+        warn "$(bilingual "部署已取消" "Deployment cancelled")"
        exit 0
    fi
    
@@ -500,11 +496,11 @@ main() {
    health_check
    show_deployment_info
    
-    info "部署流程已完成！"
+    info "$(bilingual "部署流程已完成！" "Deployment finished!")"
 }

-# 捕获 Ctrl+C
-trap 'echo ""; warn "部署已中断"; exit 1' INT
+# 捕获 Ctrl+C / Handle Ctrl+C
+trap 'echo ""; warn "$(bilingual "部署已中断" "Deployment interrupted")"; exit 1' INT

-# 运行主函数
+# 运行主函数 / Run main
 main "$@"
@@ -29,6 +29,7 @@ import CopyTradingSellOrders from './pages/CopyTradingSellOrders'
 import CopyTradingMatchedOrders from './pages/CopyTradingMatchedOrders'
 import FilteredOrdersList from './pages/FilteredOrdersList'
 import SystemSettings from './pages/SystemSettings'
+import NotificationSettingsPage from './pages/NotificationSettingsPage'
 import ApiHealthStatus from './pages/ApiHealthStatus'
 import RpcNodeSettings from './pages/RpcNodeSettings'
 import Announcements from './pages/Announcements'
@@ -40,6 +41,7 @@ import { wsManager } from './services/websocket'
 import type { OrderPushMessage } from './types'
 import { apiService } from './services/api'
 import { hasToken } from './utils'
+import ClobMigrationModal, { STORAGE_KEY as CLOB_MIGRATION_KEY } from './components/ClobMigrationModal'

 /**
 * 路由保护组件
@@ -63,6 +65,7 @@ function App() {
  const { t, i18n } = useTranslation()
  const [isFirstUse, setIsFirstUse] = useState<boolean | null>(null)
  const [checking, setChecking] = useState(true)
+  const [clobMigrationVisible, setClobMigrationVisible] = useState(false)
  
  // 根据当前语言设置 Ant Design 的 locale
  const getAntdLocale = () => {
@@ -116,28 +119,37 @@ function App() {
      }
    }
    
-    // 优先使用订单详情中的数据，如果没有则使用 WebSocket 消息中的数据
-    const price = orderDetail ? parseFloat(orderDetail.price).toFixed(4) : parseFloat(order.price).toFixed(4)
-    const size = orderDetail ? parseFloat(orderDetail.size).toFixed(2) : parseFloat(order.original_size).toFixed(2)
-    const filled = orderDetail ? parseFloat(orderDetail.filled).toFixed(2) : parseFloat(order.size_matched).toFixed(2)
+    // 实际成交价 = original_size*price/size_matched；有成交时数量用 size_matched
+    const size = orderDetail ? orderDetail.size : order.original_size
+    const filled = orderDetail ? orderDetail.filled : order.size_matched
+    const sizeNum = parseFloat(size).toFixed(2)
+    const filledNum = parseFloat(filled).toFixed(2)
+    const hasFilled = parseFloat(filled) > 0
+    const price = orderDetail
+      ? (orderDetail.avgFilledPrice ?? orderDetail.price)
+      : (hasFilled
+          ? (parseFloat(order.original_size) * parseFloat(order.price) / parseFloat(order.size_matched)).toString()
+          : order.price)
+    const priceStr = parseFloat(price).toFixed(4)
    const status = orderDetail?.status || 'UNKNOWN'
-    
+    // 有成交时展示数量用 size_matched（filled），否则用 original_size
+    const displaySize = (orderDetail?.avgFilledPrice || (orderDetail == null && hasFilled)) ? filledNum : sizeNum
+
    // 构建描述信息
-    let description = `${t('order.market')}: ${marketName}\n${sideText} ${size} @ ${price}`
+    let description = `${t('order.market')}: ${marketName}\n${sideText} ${displaySize} @ ${priceStr}`
    
    // 如果有订单详情，显示更详细的信息
    if (orderDetail) {
      description += `\n${t('order.status')}: ${status}`
-      if (parseFloat(filled) > 0) {
-        description += ` | ${t('order.filled')}: ${filled}`
+      if (parseFloat(filledNum) > 0) {
+        description += ` | ${t('order.filled')}: ${filledNum}`
      }
-      const remaining = (parseFloat(size) - parseFloat(filled)).toFixed(2)
+      const remaining = (parseFloat(sizeNum) - parseFloat(filledNum)).toFixed(2)
      if (parseFloat(remaining) > 0) {
        description += ` | ${t('order.remaining')}: ${remaining}`
      }
    } else if (order.type === 'UPDATE' && parseFloat(order.size_matched) > 0) {
-      // 如果没有订单详情，使用 WebSocket 消息中的已成交数量
-      description += `\n${t('order.filled')}: ${filled}`
+      description += `\n${t('order.filled')}: ${filledNum}`
    }
    
    // 根据订单类型选择通知类型
@@ -189,6 +201,13 @@ function App() {
      wsManager.disconnect()
    }
  }, [checking, isFirstUse])
+
+  // 已登录且未查看过 CLOB V2 迁移提醒时显示弹窗
+  useEffect(() => {
+    if (!checking && isFirstUse === false && hasToken() && !localStorage.getItem(CLOB_MIGRATION_KEY)) {
+      setClobMigrationVisible(true)
+    }
+  }, [checking, isFirstUse])
  
  // 订阅订单推送并显示全局通知
  useEffect(() => {
@@ -268,11 +287,13 @@ function App() {
          <Route path="/users" element={<ProtectedRoute><UserList /></ProtectedRoute>} />
          <Route path="/announcements" element={<ProtectedRoute><Announcements /></ProtectedRoute>} />
          <Route path="/system-settings" element={<ProtectedRoute><SystemSettings /></ProtectedRoute>} />
+          <Route path="/system-settings/notification" element={<ProtectedRoute><NotificationSettingsPage /></ProtectedRoute>} />
          <Route path="/system-settings/rpc-nodes" element={<ProtectedRoute><RpcNodeSettings /></ProtectedRoute>} />          <Route path="/system-settings/api-health" element={<ProtectedRoute><ApiHealthStatus /></ProtectedRoute>} />
          
          {/* 默认重定向到登录页 */}
          <Route path="*" element={<Navigate to="/login" replace />} />
        </Routes>
+        <ClobMigrationModal open={clobMigrationVisible} onClose={() => setClobMigrationVisible(false)} />
      </BrowserRouter>
    </ConfigProvider>
  )
@@ -525,7 +525,7 @@ const AccountImportForm: React.FC<AccountImportFormProps> = ({
                        </Space>
                        {!option.error && (
                          <span style={{ fontSize: 13, fontWeight: 500, color: 'var(--ant-color-primary)' }}>
-                            {formatUSDC(option.totalBalance)} USDC
+                            ${formatUSDC(option.totalBalance)}
                          </span>
                        )}
                      </div>
@@ -247,7 +247,7 @@ const AccountSetupStatusBlock: React.FC<AccountSetupStatusBlockProps> = ({
              const displayText = isUnlimited
                ? t('accountSetup.approvalDetails.unlimited')
                : isApproved
-                  ? `${parseFloat(allowance).toFixed(2)} USDC`
+                  ? `$${parseFloat(allowance).toFixed(2)}`
                  : t('accountSetup.approvalDetails.notApproved')
              return (
                <div
@@ -0,0 +1,64 @@
+import { Modal, Button, Space } from 'antd'
+import { SwapOutlined } from '@ant-design/icons'
+import { useTranslation } from 'react-i18next'
+import { useNavigate } from 'react-router-dom'
+
+const STORAGE_KEY = 'clob_v2_migration_dismissed'
+
+interface ClobMigrationModalProps {
+  open: boolean
+  onClose: () => void
+}
+
+const ClobMigrationModal: React.FC<ClobMigrationModalProps> = ({ open, onClose }) => {
+  const { t } = useTranslation()
+  const navigate = useNavigate()
+
+  const handleClose = (dontRemind = false) => {
+    if (dontRemind) {
+      localStorage.setItem(STORAGE_KEY, 'true')
+    }
+    onClose()
+  }
+
+  const handleGoToAccounts = () => {
+    localStorage.setItem(STORAGE_KEY, 'true')
+    onClose()
+    navigate('/accounts')
+  }
+
+  return (
+    <Modal
+      title={
+        <div style={{ display: 'flex', alignItems: 'center', gap: 8 }}>
+          <SwapOutlined style={{ color: '#fa8c16' }} />
+          <span>{t('clobMigration.title')}</span>
+        </div>
+      }
+      open={open}
+      onCancel={() => handleClose()}
+      footer={
+        <Space>
+          <Button onClick={() => handleClose(true)}>
+            {t('clobMigration.dontRemind')}
+          </Button>
+          <Button onClick={() => handleClose()}>
+            {t('common.later')}
+          </Button>
+          <Button type="primary" onClick={handleGoToAccounts}>
+            {t('clobMigration.goToAccounts')}
+          </Button>
+        </Space>
+      }
+      closable
+      maskClosable={false}
+    >
+      <p style={{ fontSize: 14, lineHeight: 1.8, color: 'rgba(0, 0, 0, 0.65)' }}>
+        {t('clobMigration.description')}
+      </p>
+    </Modal>
+  )
+}
+
+export default ClobMigrationModal
+export { STORAGE_KEY }
@@ -207,6 +207,11 @@ const Layout: React.FC<LayoutProps> = ({ children }) => {
          icon: <SettingOutlined />,
          label: t('menu.systemOverview') || '通用设置'
        },
+        {
+          key: '/system-settings/notification',
+          icon: <NotificationOutlined />,
+          label: t('menu.notifications') || '消息推送设置'
+        },
        {
          key: '/system-settings/rpc-nodes',
          icon: <ApiOutlined />,
@@ -42,7 +42,8 @@
    "pageOf": "Page",
    "ascending": "Ascending",
    "descending": "Descending",
-    "day": "day"
+    "day": "day",
+    "orders": "orders"
  },
  "account": {
    "title": "Account Management",
@@ -176,7 +177,8 @@
    "updateFailed": "Failed to update account",
    "getDetailFailedForEdit": "Failed to get account detail",
    "loading": "Loading...",
-    "fetchFailed": "Failed to get account list"
+    "fetchFailed": "Failed to get account list",
+    "noData": "No account data"
  },
  "accountImport": {
    "title": "Import Account",
@@ -660,7 +662,8 @@
    "deleteSuccess": "User deleted successfully",
    "deleteFailed": "Failed to delete user",
    "deleteConfirm": "Are you sure you want to delete this user?",
-    "total": "Total {{total}} items"
+    "total": "Total {{total}} items",
+    "noData": "No user data"
  },
  "statistics": {
    "title": "Statistics",
@@ -1121,7 +1124,9 @@
    "updateStatusFailed": "Failed to update copy trading status",
    "deleteSuccess": "Copy trading deleted successfully",
    "deleteFailed": "Failed to delete copy trading",
-    "deleteConfirm": "Are you sure you want to delete this copy trading relationship?"
+    "deleteConfirm": "Are you sure you want to delete this copy trading relationship?",
+    "profitRate": "Profit Rate",
+    "noData": "No copy trading configuration"
  },
  "notificationSettings": {
    "title": "Notification Settings",
@@ -1162,7 +1167,95 @@
    "getChatIdsFailed": "Failed to get Chat IDs",
    "getChatIdsNoToken": "Please enter Bot Token first",
    "getChatIdsNoMessage": "Chat ID not found, please send a message to the bot first (e.g., /start), then retry",
-    "getChatIdsButton": "Get Chat ID"
+    "getChatIdsButton": "Get Chat ID",
+    "botConfig": "Bot Configuration",
+    "templateConfig": "Template Configuration",
+    "templates": {
+      "title": "Message Template Configuration",
+      "templateType": "Template Type",
+      "templateContent": "Template Content",
+      "isDefault": "Default Template",
+      "isCustom": "Custom Template",
+      "resetToDefault": "Reset to Default",
+      "resetConfirm": "Are you sure you want to reset to default? Your custom content will be lost.",
+      "resetSuccess": "Reset successfully",
+      "resetFailed": "Reset failed",
+      "saveSuccess": "Saved successfully",
+      "saveFailed": "Save failed",
+      "testSuccess": "Test message sent successfully, please check Telegram",
+      "testFailed": "Failed to send test message",
+      "variables": "Available Variables",
+      "clickToCopy": "Click to copy",
+      "copied": "Copied",
+      "commonVariables": "Common Variables",
+      "orderVariables": "Order Variables",
+      "copyTradingVariables": "Copy Trading Variables",
+      "redeemVariables": "Redeem Variables",
+      "errorVariables": "Error Variables",
+      "filterVariables": "Filter Variables",
+      "strategyVariables": "Strategy Variables",
+      "contentPlaceholder": "Enter template content here, use {{variable}} to insert dynamic content",
+      "variableLabels": {
+        "account_name": "Account Name",
+        "wallet_address": "Wallet Address",
+        "time": "Time",
+        "order_id": "Order ID",
+        "market_title": "Market Title",
+        "market_link": "Market Link",
+        "side": "Side",
+        "outcome": "Outcome",
+        "price": "Price",
+        "quantity": "Quantity",
+        "amount": "Amount",
+        "available_balance": "Available Balance",
+        "leader_name": "Leader Name",
+        "config_name": "Copy Trading Config Name",
+        "error_message": "Error Message",
+        "filter_type": "Filter Type",
+        "filter_reason": "Filter Reason",
+        "strategy_name": "Strategy Name",
+        "transaction_hash": "Transaction Hash",
+        "total_value": "Total Redeem Value"
+      },
+      "variableDescriptions": {
+        "account_name": "Account name executing the order",
+        "wallet_address": "Wallet address (masked)",
+        "time": "Notification send time",
+        "order_id": "Unique order identifier",
+        "market_title": "Market/Event name",
+        "market_link": "Polymarket market link",
+        "side": "Order direction (Buy/Sell)",
+        "outcome": "Market outcome (YES/NO, etc.)",
+        "price": "Order price",
+        "quantity": "Order quantity (shares)",
+        "amount": "Order amount (USDC)",
+        "available_balance": "Account available balance (USDC)",
+        "leader_name": "Leader name/alias being copied",
+        "config_name": "Copy trading configuration name",
+        "error_message": "Order failure reason",
+        "filter_type": "Type of order filter",
+        "filter_reason": "Detailed reason for order filtering",
+        "strategy_name": "Crypto spread strategy name",
+        "transaction_hash": "Redeem transaction hash",
+        "total_value": "Total redeem value (USDC)"
+      }
+    },
+    "templateTypes": {
+      "ORDER_SUCCESS": "Order Success",
+      "ORDER_FAILED": "Order Failed",
+      "ORDER_FILTERED": "Order Filtered",
+      "CRYPTO_TAIL_SUCCESS": "Crypto Spread Strategy Success",
+      "REDEEM_SUCCESS": "Position Redeem Success",
+      "REDEEM_NO_RETURN": "Position Settled (No Return)"
+    },
+    "templateTypeDescriptions": {
+      "ORDER_SUCCESS": "Notification sent when order is successfully created",
+      "ORDER_FAILED": "Notification sent when order creation fails",
+      "ORDER_FILTERED": "Notification sent when order is filtered by risk control",
+      "CRYPTO_TAIL_SUCCESS": "Notification sent when crypto spread strategy order succeeds",
+      "REDEEM_SUCCESS": "Notification sent when position is successfully redeemed",
+      "REDEEM_NO_RETURN": "Notification sent when position is settled with no return"
+    }
  },
  "telegramConfig": {
    "title": "Telegram Configuration Guide",
@@ -1351,6 +1444,8 @@
    "title": "Backtest",
    "taskName": "Task Name",
    "leader": "Leader",
+    "balance": "Balance (Init→Final)",
+    "profit": "Profit (Amount/Rate)",
    "initialBalance": "Initial Balance",
    "backtestDays": "Backtest Days",
    "status": "Status",
@@ -1399,6 +1494,7 @@
    "createCopyTradingSuccess": "Copy trading config created successfully",
    "noTasks": "No backtest tasks",
    "noTrades": "No trade records",
+    "noData": "No backtest data",
    "fetchTasksFailed": "Failed to fetch task list",
    "fetchTaskDetailFailed": "Failed to fetch task detail",
    "fetchTradesFailed": "Failed to fetch trade records",
@@ -1496,7 +1592,9 @@
      "strategyName": "Strategy Name",
      "account": "Account",
      "market": "Market",
+      "marketAndTime": "Market / Time",
      "timeWindow": "Time Window",
+      "config": "Config",
      "priceRange": "Price Range",
      "amountMode": "Amount Mode",
      "ratio": "Ratio",
@@ -1509,6 +1607,7 @@
      "disable": "Disable",
      "delete": "Delete",
      "viewTriggers": "Orders",
+      "viewPnlCurve": "PnL Curve",
      "deleteConfirm": "Delete this strategy?",
      "fetchFailed": "Failed to fetch list",
      "configGuide": "Configuration Guide"
@@ -1576,6 +1675,20 @@
      "emptySuccess": "No success records",
      "emptyFail": "No failed records",
      "totalCount": "{count} record(s)"
+    },
+    "pnlCurve": {
+      "title": "PnL Curve",
+      "totalPnl": "Total PnL",
+      "settledCount": "Settled",
+      "winRate": "Win Rate",
+      "maxDrawdown": "Max Drawdown",
+      "timeRange": "Time Range",
+      "today": "Today",
+      "last7Days": "Last 7 Days",
+      "last30Days": "Last 30 Days",
+      "all": "All",
+      "customRange": "Custom",
+      "empty": "No settled orders yet, cannot show PnL curve"
    }
  },
  "cryptoTailMonitor": {
@@ -1644,6 +1757,58 @@
      "switchToLatest": "Switch to Latest Period",
      "periodEnded": "Current period has ended",
      "newPeriodAvailable": "New period has started"
+    },
+    "manualOrder": {
+      "title": "Manual Order",
+      "buttonUp": "Buy Up",
+      "buttonDown": "Buy Down",
+      "confirmTitle": "Manual Order Confirmation",
+      "marketTitle": "Market Title",
+      "direction": "Direction",
+      "directionUp": "Up",
+      "directionDown": "Down",
+      "orderPrice": "Order Price",
+      "orderSize": "Order Size",
+      "totalAmount": "Total Amount",
+      "account": "Account",
+      "cancel": "Cancel",
+      "confirm": "Confirm Order",
+      "orderUnit": "USDC",
+      "sizeUnit": "shares",
+      "statusNotOrdered": "Not Ordered",
+      "statusOrdered": "This period has been ordered",
+      "statusOrderedAuto": "This period has been auto-ordered",
+      "statusOrderedManual": "This period has been manually ordered",
+      "errorInsufficientBalance": "Insufficient account balance, available: {balance} USDC",
+      "errorPriceOutOfRange": "Price must be between 0 and 1",
+      "errorMinSize": "Size cannot be less than 1 share",
+      "errorExceedsBalance": "Total amount exceeds available balance",
+      "errorPriceRequired": "Please enter order price",
+      "errorSizeRequired": "Please enter order size",
+      "success": "Manual order successful",
+      "failed": "Manual order failed: {{reason}}",
+      "errorSigning": "Signing failed: {reason}",
+      "errorNetwork": "Network error, please try again later",
+      "priceNotLoaded": "Price data not loaded",
+      "insufficientBalance": "Insufficient balance, available amount less than 1 USDC",
+      "fetchBalanceFailed": "Failed to fetch account balance",
+      "availableBalance": "Available Balance",
+      "fetchLatestPrice": "Latest Price",
+      "priceUpdated": "Price updated",
+      "maxSize": "Max",
+      "invalidPriceOrBalance": "Invalid price or balance",
+      "insufficientBalanceForMax": "Insufficient balance for max size",
+      "maxSizeUpdated": "Updated to max size",
+      "periodChanged": "Period has changed, popup closed"
    }
+  },
+  "clobMigration": {
+    "title": "CLOB 2.0 Migration Notice",
+    "description": "Polymarket CLOB has been upgraded to V2. Please go to the Accounts page to complete the USDC migration to ensure trading functions properly.",
+    "goToAccounts": "Go to Accounts",
+    "dontRemind": "Don't remind again",
+    "accountGuide": "CLOB V2 requires pUSD for trading. Click the USDC.e → pUSD button in the account actions to complete the migration.",
+    "accountGuideButton": "USDC.e → pUSD",
+    "dismissGuide": "Got it"
  }
 }
@@ -42,7 +42,8 @@
    "copyFailed": "复制失败",
    "ascending": "升序",
    "descending": "降序",
-    "day": "天"
+    "day": "天",
+    "orders": "单"
  },
  "login": {
    "title": "登录",
@@ -176,7 +177,8 @@
    "updateFailed": "更新账户失败",
    "getDetailFailedForEdit": "获取账户详情失败",
    "loading": "加载中...",
-    "fetchFailed": "获取账户列表失败"
+    "fetchFailed": "获取账户列表失败",
+    "noData": "暂无账户数据"
  },
  "accountImport": {
    "title": "导入账户",
@@ -660,7 +662,8 @@
    "deleteSuccess": "删除用户成功",
    "deleteFailed": "删除用户失败",
    "deleteConfirm": "确定要删除这个用户吗？",
-    "total": "共 {{total}} 条"
+    "total": "共 {{total}} 条",
+    "noData": "暂无用户数据"
  },
  "statistics": {
    "title": "统计信息",
@@ -1121,7 +1124,9 @@
    "updateStatusFailed": "更新跟单状态失败",
    "deleteSuccess": "删除跟单成功",
    "deleteFailed": "删除跟单失败",
-    "deleteConfirm": "确定要删除这个跟单关系吗？"
+    "deleteConfirm": "确定要删除这个跟单关系吗？",
+    "profitRate": "收益率",
+    "noData": "暂无跟单配置"
  },
  "notificationSettings": {
    "title": "消息推送设置",
@@ -1162,7 +1167,95 @@
    "getChatIdsFailed": "获取 Chat IDs 失败",
    "getChatIdsNoToken": "请先填写 Bot Token",
    "getChatIdsNoMessage": "未找到 Chat ID，请先向机器人发送一条消息（如 /start），然后重试",
-    "getChatIdsButton": "获取 Chat ID"
+    "getChatIdsButton": "获取 Chat ID",
+    "botConfig": "机器人配置",
+    "templateConfig": "模板配置",
+    "templates": {
+      "title": "消息模板配置",
+      "templateType": "模板类型",
+      "templateContent": "模板内容",
+      "isDefault": "默认模板",
+      "isCustom": "自定义模板",
+      "resetToDefault": "重置为默认",
+      "resetConfirm": "确定要重置为默认模板吗？您的自定义内容将丢失。",
+      "resetSuccess": "重置成功",
+      "resetFailed": "重置失败",
+      "saveSuccess": "保存成功",
+      "saveFailed": "保存失败",
+      "testSuccess": "测试消息发送成功，请检查 Telegram",
+      "testFailed": "测试消息发送失败",
+      "variables": "可用变量",
+      "clickToCopy": "点击复制",
+      "copied": "已复制",
+      "commonVariables": "通用变量",
+      "orderVariables": "订单变量",
+      "copyTradingVariables": "跟单变量",
+      "redeemVariables": "赎回变量",
+      "errorVariables": "错误变量",
+      "filterVariables": "过滤变量",
+      "strategyVariables": "策略变量",
+      "contentPlaceholder": "在此输入模板内容，使用 {{变量名}} 插入动态内容",
+      "variableLabels": {
+        "account_name": "账户名称",
+        "wallet_address": "钱包地址",
+        "time": "时间",
+        "order_id": "订单ID",
+        "market_title": "市场标题",
+        "market_link": "市场链接",
+        "side": "方向",
+        "outcome": "市场方向",
+        "price": "价格",
+        "quantity": "数量",
+        "amount": "金额",
+        "available_balance": "可用余额",
+        "leader_name": "Leader 名称",
+        "config_name": "跟单配置名",
+        "error_message": "错误信息",
+        "filter_type": "过滤类型",
+        "filter_reason": "过滤原因",
+        "strategy_name": "策略名称",
+        "transaction_hash": "交易哈希",
+        "total_value": "赎回总价值"
+      },
+      "variableDescriptions": {
+        "account_name": "执行订单的账户名称",
+        "wallet_address": "钱包地址（已脱敏）",
+        "time": "通知发送时间",
+        "order_id": "订单唯一标识",
+        "market_title": "市场/事件名称",
+        "market_link": "Polymarket 市场链接",
+        "side": "订单方向（买入/卖出）",
+        "outcome": "市场方向（YES/NO 等）",
+        "price": "订单价格",
+        "quantity": "订单数量（shares）",
+        "amount": "订单金额（USDC）",
+        "available_balance": "账户可用余额（USDC）",
+        "leader_name": "跟单的 Leader 名称/备注",
+        "config_name": "跟单配置名称",
+        "error_message": "订单失败原因",
+        "filter_type": "订单被过滤的类型",
+        "filter_reason": "订单被过滤的详细原因",
+        "strategy_name": "加密价差策略名称",
+        "transaction_hash": "赎回交易的哈希值",
+        "total_value": "赎回的总价值（USDC）"
+      }
+    },
+    "templateTypes": {
+      "ORDER_SUCCESS": "订单成功通知",
+      "ORDER_FAILED": "订单失败通知",
+      "ORDER_FILTERED": "订单过滤通知",
+      "CRYPTO_TAIL_SUCCESS": "加密价差策略成功通知",
+      "REDEEM_SUCCESS": "仓位赎回成功通知",
+      "REDEEM_NO_RETURN": "仓位结算（无收益）通知"
+    },
+    "templateTypeDescriptions": {
+      "ORDER_SUCCESS": "订单创建成功时发送的通知",
+      "ORDER_FAILED": "订单创建失败时发送的通知",
+      "ORDER_FILTERED": "订单被风控过滤时发送的通知",
+      "CRYPTO_TAIL_SUCCESS": "加密价差策略下单成功时发送的通知",
+      "REDEEM_SUCCESS": "仓位赎回成功时发送的通知",
+      "REDEEM_NO_RETURN": "仓位结算但无收益时发送的通知"
+    }
  },
  "telegramConfig": {
    "title": "Telegram 配置说明",
@@ -1351,6 +1444,8 @@
    "title": "回测",
    "taskName": "任务名称",
    "leader": "Leader",
+    "balance": "资金 (初始→最终)",
+    "profit": "收益 (金额/比例)",
    "initialBalance": "初始资金",
    "backtestDays": "回测天数",
    "status": "状态",
@@ -1399,6 +1494,7 @@
    "createCopyTradingSuccess": "跟单配置创建成功",
    "noTasks": "暂无回测任务",
    "noTrades": "暂无交易记录",
+    "noData": "暂无回测数据",
    "fetchTasksFailed": "获取任务列表失败",
    "fetchTaskDetailFailed": "获取任务详情失败",
    "fetchTradesFailed": "获取交易记录失败",
@@ -1496,7 +1592,9 @@
      "strategyName": "策略名称",
      "account": "账户",
      "market": "关联市场",
+      "marketAndTime": "市场/时间",
      "timeWindow": "时间区间",
+      "config": "配置",
      "priceRange": "价格区间",
      "amountMode": "投入方式",
      "ratio": "比例",
@@ -1509,6 +1607,7 @@
      "disable": "停用",
      "delete": "删除",
      "viewTriggers": "订单",
+      "viewPnlCurve": "收益曲线",
      "deleteConfirm": "确定删除该策略？",
      "fetchFailed": "获取列表失败",
      "configGuide": "配置指南"
@@ -1576,6 +1675,20 @@
      "emptySuccess": "暂无成功记录",
      "emptyFail": "暂无失败记录",
      "totalCount": "共 {count} 条"
+    },
+    "pnlCurve": {
+      "title": "收益曲线",
+      "totalPnl": "总收益",
+      "settledCount": "已结算笔数",
+      "winRate": "胜率",
+      "maxDrawdown": "最大回撤",
+      "timeRange": "时间范围",
+      "today": "今日",
+      "last7Days": "近7天",
+      "last30Days": "近30天",
+      "all": "全部",
+      "customRange": "自定义",
+      "empty": "暂无已结算订单，无法展示收益曲线"
    }
  },
  "cryptoTailMonitor": {
@@ -1644,6 +1757,58 @@
      "switchToLatest": "切换到最新周期",
      "periodEnded": "当前周期已结束",
      "newPeriodAvailable": "新周期已开始"
+    },
+    "manualOrder": {
+      "title": "手动下单",
+      "buttonUp": "买入 Up",
+      "buttonDown": "买入 Down",
+      "confirmTitle": "手动下单确认",
+      "marketTitle": "市场标题",
+      "direction": "方向",
+      "directionUp": "Up",
+      "directionDown": "Down",
+      "orderPrice": "下单价格",
+      "orderSize": "下单数量",
+      "totalAmount": "总金额",
+      "account": "账户",
+      "cancel": "取消",
+      "confirm": "确认下单",
+      "orderUnit": "USDC",
+      "sizeUnit": "张",
+      "statusNotOrdered": "未下单",
+      "statusOrdered": "本周期已下单",
+      "statusOrderedAuto": "本周期已自动下单",
+      "statusOrderedManual": "本周期已手动下单",
+      "errorInsufficientBalance": "账户余额不足，可用余额：{{balance}} USDC",
+      "errorPriceOutOfRange": "价格必须在 0~1 之间",
+      "errorMinSize": "数量不能少于 1 张",
+      "errorExceedsBalance": "总金额超过可用余额",
+      "errorPriceRequired": "请输入下单价格",
+      "errorSizeRequired": "请输入下单数量",
+      "success": "手动下单成功",
+      "failed": "手动下单失败：{{reason}}",
+      "errorSigning": "签名失败：{{reason}}",
+      "errorNetwork": "网络错误，请稍后重试",
+      "priceNotLoaded": "价格数据未加载",
+      "insufficientBalance": "余额不足，可用金额少于 1 USDC",
+      "fetchBalanceFailed": "获取账户余额失败",
+      "availableBalance": "可用余额",
+      "fetchLatestPrice": "获取最新价",
+      "priceUpdated": "价格已更新",
+      "maxSize": "最大",
+      "invalidPriceOrBalance": "价格或余额无效",
+      "insufficientBalanceForMax": "余额不足以购买最大数量",
+      "maxSizeUpdated": "已更新为最大数量",
+      "periodChanged": "周期已切换，弹窗已关闭"
    }
+  },
+  "clobMigration": {
+    "title": "CLOB 2.0 迁移提醒",
+    "description": "Polymarket CLOB 已升级至 V2 版本，您需要前往账户页完成 USDC 迁移操作，以确保交易功能正常使用。",
+    "goToAccounts": "前往账户页",
+    "dontRemind": "不再提醒",
+    "accountGuide": "CLOB V2 需要 pUSD 进行交易，请点击账户操作栏中的 USDC.e → pUSD 按钮完成迁移。",
+    "accountGuideButton": "USDC.e → pUSD",
+    "dismissGuide": "知道了"
  }
 }
@@ -42,7 +42,8 @@
    "pageOf": "第",
    "ascending": "升序",
    "descending": "降序",
-    "day": "天"
+    "day": "天",
+    "orders": "單"
  },
  "account": {
    "title": "賬戶管理",
@@ -176,7 +177,8 @@
    "updateFailed": "更新賬戶失敗",
    "getDetailFailedForEdit": "獲取賬戶詳情失敗",
    "loading": "加載中...",
-    "fetchFailed": "獲取賬戶列表失敗"
+    "fetchFailed": "獲取賬戶列表失敗",
+    "noData": "暫無賬戶數據"
  },
  "accountImport": {
    "title": "導入賬戶",
@@ -660,7 +662,8 @@
    "deleteSuccess": "刪除用戶成功",
    "deleteFailed": "刪除用戶失敗",
    "deleteConfirm": "確定要刪除這個用戶嗎？",
-    "total": "共 {{total}} 條"
+    "total": "共 {{total}} 條",
+    "noData": "暫無用戶數據"
  },
  "statistics": {
    "title": "統計信息",
@@ -1121,7 +1124,9 @@
    "updateStatusFailed": "更新跟單狀態失敗",
    "deleteSuccess": "刪除跟單成功",
    "deleteFailed": "刪除跟單失敗",
-    "deleteConfirm": "確定要刪除這個跟單關係嗎？"
+    "deleteConfirm": "確定要刪除這個跟單關係嗎？",
+    "profitRate": "收益率",
+    "noData": "暫無跟單配置"
  },
  "notificationSettings": {
    "title": "消息推送設置",
@@ -1162,7 +1167,95 @@
    "getChatIdsFailed": "獲取 Chat IDs 失敗",
    "getChatIdsNoToken": "請先填寫 Bot Token",
    "getChatIdsNoMessage": "未找到 Chat ID，請先向機器人發送一條消息（如 /start），然後重試",
-    "getChatIdsButton": "獲取 Chat ID"
+    "getChatIdsButton": "獲取 Chat ID",
+    "botConfig": "機器人配置",
+    "templateConfig": "模板配置",
+    "templates": {
+      "title": "消息模板配置",
+      "templateType": "模板類型",
+      "templateContent": "模板內容",
+      "isDefault": "默認模板",
+      "isCustom": "自定義模板",
+      "resetToDefault": "重置為默認",
+      "resetConfirm": "確定要重置為默認模板嗎？您的自定義內容將丟失。",
+      "resetSuccess": "重置成功",
+      "resetFailed": "重置失敗",
+      "saveSuccess": "保存成功",
+      "saveFailed": "保存失敗",
+      "testSuccess": "測試消息發送成功，請檢查 Telegram",
+      "testFailed": "測試消息發送失敗",
+      "variables": "可用變量",
+      "clickToCopy": "點擊複製",
+      "copied": "已複製",
+      "commonVariables": "通用變量",
+      "orderVariables": "訂單變量",
+      "copyTradingVariables": "跟單變量",
+      "redeemVariables": "贖回變量",
+      "errorVariables": "錯誤變量",
+      "filterVariables": "過濾變量",
+      "strategyVariables": "策略變量",
+      "contentPlaceholder": "在此輸入模板內容，使用 {{變量名}} 插入動態內容",
+      "variableLabels": {
+        "account_name": "賬戶名稱",
+        "wallet_address": "錢包地址",
+        "time": "時間",
+        "order_id": "訂單ID",
+        "market_title": "市場標題",
+        "market_link": "市場鏈接",
+        "side": "方向",
+        "outcome": "市場方向",
+        "price": "價格",
+        "quantity": "數量",
+        "amount": "金額",
+        "available_balance": "可用餘額",
+        "leader_name": "Leader 名稱",
+        "config_name": "跟單配置名",
+        "error_message": "錯誤信息",
+        "filter_type": "過濾類型",
+        "filter_reason": "過濾原因",
+        "strategy_name": "策略名稱",
+        "transaction_hash": "交易哈希",
+        "total_value": "贖回總價值"
+      },
+      "variableDescriptions": {
+        "account_name": "執行訂單的賬戶名稱",
+        "wallet_address": "錢包地址（已脫敏）",
+        "time": "通知發送時間",
+        "order_id": "訂單唯一標識",
+        "market_title": "市場/事件名稱",
+        "market_link": "Polymarket 市場鏈接",
+        "side": "訂單方向（買入/賣出）",
+        "outcome": "市場方向（YES/NO 等）",
+        "price": "訂單價格",
+        "quantity": "訂單數量（shares）",
+        "amount": "訂單金額（USDC）",
+        "available_balance": "賬戶可用餘額（USDC）",
+        "leader_name": "跟單的 Leader 名稱/備註",
+        "config_name": "跟單配置名稱",
+        "error_message": "訂單失敗原因",
+        "filter_type": "訂單被過濾的類型",
+        "filter_reason": "訂單被過濾的詳細原因",
+        "strategy_name": "加密價差策略名稱",
+        "transaction_hash": "贖回交易的哈希值",
+        "total_value": "贖回的總價值（USDC）"
+      }
+    },
+    "templateTypes": {
+      "ORDER_SUCCESS": "訂單成功通知",
+      "ORDER_FAILED": "訂單失敗通知",
+      "ORDER_FILTERED": "訂單過濾通知",
+      "CRYPTO_TAIL_SUCCESS": "加密價差策略成功通知",
+      "REDEEM_SUCCESS": "倉位贖回成功通知",
+      "REDEEM_NO_RETURN": "倉位結算（無收益）通知"
+    },
+    "templateTypeDescriptions": {
+      "ORDER_SUCCESS": "訂單創建成功時發送的通知",
+      "ORDER_FAILED": "訂單創建失敗時發送的通知",
+      "ORDER_FILTERED": "訂單被風控過濾時發送的通知",
+      "CRYPTO_TAIL_SUCCESS": "加密價差策略下單成功時發送的通知",
+      "REDEEM_SUCCESS": "倉位贖回成功時發送的通知",
+      "REDEEM_NO_RETURN": "倉位結算但無收益時發送的通知"
+    }
  },
  "telegramConfig": {
    "title": "Telegram 配置說明",
@@ -1351,6 +1444,8 @@
    "title": "回測",
    "taskName": "任務名稱",
    "leader": "Leader",
+    "balance": "資金 (初始→最終)",
+    "profit": "收益 (金額/比例)",
    "initialBalance": "初始資金",
    "backtestDays": "回測天數",
    "status": "狀態",
@@ -1399,6 +1494,7 @@
    "createCopyTradingSuccess": "跟單配置創建成功",
    "noTasks": "暫無回測任務",
    "noTrades": "暫無交易記錄",
+    "noData": "暫無回測數據",
    "fetchTasksFailed": "獲取任務列表失敗",
    "fetchTaskDetailFailed": "獲取任務詳情失敗",
    "fetchTradesFailed": "獲取交易記錄失敗",
@@ -1496,7 +1592,9 @@
      "strategyName": "策略名稱",
      "account": "賬戶",
      "market": "關聯市場",
+      "marketAndTime": "市場/時間",
      "timeWindow": "時間區間",
+      "config": "配置",
      "priceRange": "價格區間",
      "amountMode": "投入方式",
      "ratio": "比例",
@@ -1509,6 +1607,7 @@
      "disable": "停用",
      "delete": "刪除",
      "viewTriggers": "訂單",
+      "viewPnlCurve": "收益曲線",
      "deleteConfirm": "確定刪除該策略？",
      "fetchFailed": "獲取列表失敗",
      "configGuide": "配置指南"
@@ -1576,6 +1675,20 @@
      "emptySuccess": "暫無成功記錄",
      "emptyFail": "暫無失敗記錄",
      "totalCount": "共 {count} 條"
+    },
+    "pnlCurve": {
+      "title": "收益曲線",
+      "totalPnl": "總收益",
+      "settledCount": "已結算筆數",
+      "winRate": "勝率",
+      "maxDrawdown": "最大回撤",
+      "timeRange": "時間範圍",
+      "today": "今日",
+      "last7Days": "近7天",
+      "last30Days": "近30天",
+      "all": "全部",
+      "customRange": "自定義",
+      "empty": "暫無已結算訂單，無法展示收益曲線"
    }
  },
  "cryptoTailMonitor": {
@@ -1644,6 +1757,58 @@
      "switchToLatest": "切換到最新週期",
      "periodEnded": "當前週期已結束",
      "newPeriodAvailable": "新週期已開始"
+    },
+    "manualOrder": {
+      "title": "手動下單",
+      "buttonUp": "買入 Up",
+      "buttonDown": "買入 Down",
+      "confirmTitle": "手動下單確認",
+      "marketTitle": "市場標題",
+      "direction": "方向",
+      "directionUp": "Up",
+      "directionDown": "Down",
+      "orderPrice": "下單價格",
+      "orderSize": "下單數量",
+      "totalAmount": "總金額",
+      "account": "賬戶",
+      "cancel": "取消",
+      "confirm": "確認下單",
+      "orderUnit": "USDC",
+      "sizeUnit": "張",
+      "statusNotOrdered": "未下單",
+      "statusOrdered": "本週期已下單",
+      "statusOrderedAuto": "本週期已自動下單",
+      "statusOrderedManual": "本週期已手動下單",
+      "errorInsufficientBalance": "賬戶餘額不足，可用餘額：{balance} USDC",
+      "errorPriceOutOfRange": "價格必須在 0~1 之間",
+      "errorMinSize": "數量不能少於 1 張",
+      "errorExceedsBalance": "總金額超過可用餘額",
+      "errorPriceRequired": "請輸入下單價格",
+      "errorSizeRequired": "請輸入下單數量",
+      "success": "手動下單成功",
+      "failed": "手動下單失敗：{{reason}}",
+      "errorSigning": "簽名失敗：{reason}",
+      "errorNetwork": "網絡錯誤，請稍後重試",
+      "priceNotLoaded": "價格數據未加載",
+      "insufficientBalance": "餘額不足，可用金額少於 1 USDC",
+      "fetchBalanceFailed": "獲取賬戶餘額失敗",
+      "availableBalance": "可用餘額",
+      "fetchLatestPrice": "獲取最新價",
+      "priceUpdated": "價格已更新",
+      "maxSize": "最大",
+      "invalidPriceOrBalance": "價格或餘額無效",
+      "insufficientBalanceForMax": "餘額不足以購買最大數量",
+      "maxSizeUpdated": "已更新為最大數量",
+      "periodChanged": "週期已切換，彈窗已關閉"
    }
+  },
+  "clobMigration": {
+    "title": "CLOB 2.0 遷移提醒",
+    "description": "Polymarket CLOB 已升級至 V2 版本，您需要前往帳戶頁完成 USDC 遷移操作，以確保交易功能正常使用。",
+    "goToAccounts": "前往帳戶頁",
+    "dontRemind": "不再提醒",
+    "accountGuide": "CLOB V2 需要 pUSD 進行交易，請點擊帳戶操作欄中的 USDC.e → pUSD 按鈕完成遷移。",
+    "accountGuideButton": "USDC.e → pUSD",
+    "dismissGuide": "知道了"
  }
 }
@@ -202,7 +202,7 @@ const AccountDetail: React.FC = () => {
              <Spin size="small" />
            ) : balance ? (
              <span style={{ fontWeight: 'bold', color: '#1890ff' }}>
-                {formatUSDC(balance)} USDC
+                ${formatUSDC(balance)}
              </span>
            ) : (
              <span style={{ color: '#999' }}>-</span>
@@ -274,7 +274,7 @@ const AccountDetail: React.FC = () => {
                    fontWeight: 'bold',
                    color: account.totalPnl.startsWith('-') ? '#ff4d4f' : '#52c41a'
                  }}>
-                    {formatUSDC(account.totalPnl)} USDC
+                    ${formatUSDC(account.totalPnl)}
                  </span>
                </Descriptions.Item>
              )}
@@ -1,6 +1,6 @@
 import { useEffect, useState } from 'react'
-import { Card, Table, Button, Space, Tag, Popconfirm, message, Typography, Spin, Modal, Descriptions, Divider, Form, Input, Alert } from 'antd'
-import { PlusOutlined, ReloadOutlined, EditOutlined, CopyOutlined } from '@ant-design/icons'
+import { Card, Table, Button, Space, Tag, Popconfirm, message, Typography, Spin, Modal, Descriptions, Divider, Form, Input, Alert, Tooltip, List, Empty } from 'antd'
+import { PlusOutlined, ReloadOutlined, EditOutlined, CopyOutlined, EyeOutlined, DeleteOutlined, WalletOutlined, SwapOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import { useAccountStore } from '../store/accountStore'
 import type { Account } from '../types'
@@ -8,6 +8,7 @@ import { useMediaQuery } from 'react-responsive'
 import { formatUSDC } from '../utils'
 import AccountImportForm from '../components/AccountImportForm'
 import AccountSetupStatusBlock from '../components/AccountSetupStatusBlock'
+import apiService from '../services/api'

 const { Title } = Typography

@@ -27,11 +28,57 @@ const AccountList: React.FC = () => {
  const [editLoading, setEditLoading] = useState(false)
  const [accountImportModalVisible, setAccountImportModalVisible] = useState(false)
  const [accountImportForm] = Form.useForm()
+  const [wrapLoading, setWrapLoading] = useState<Record<number, boolean>>({})
+  const [migrationGuideVisible, setMigrationGuideVisible] = useState(false)
+
+  const ACCOUNT_GUIDE_KEY = 'clob_v2_account_guide_dismissed'
+  const handleWrapToPusd = async (account: Account) => {
+    try {
+      setWrapLoading(prev => ({ ...prev, [account.id]: true }))
+      const res = await apiService.accounts.getUsdceBalance(account.id)
+      if (res.data.code !== 0 || !res.data.data) {
+        message.error(res.data.msg || '查询 USDC.e 余额失败')
+        return
+      }
+      const balance = parseFloat(res.data.data.balance)
+      if (balance <= 0) {
+        message.info('USDC.e 余额为 0，无需迁移')
+        return
+      }
+      Modal.confirm({
+        title: 'USDC.e → pUSD 迁移',
+        content: `检测到 ${balance.toFixed(2)} USDC.e，将全部 wrap 为 pUSD。确认继续？`,
+        okText: '确认迁移',
+        cancelText: '取消',
+        onOk: async () => {
+          const wrapRes = await apiService.accounts.wrapToPusd(account.id)
+          if (wrapRes.data.code === 0) {
+            const txHash = wrapRes.data.data?.transactionHash
+            message.success(txHash ? `迁移成功，交易: ${txHash.slice(0, 10)}...` : '迁移成功（无需操作）')
+            fetchAccountBalance(account.id)
+          } else {
+            message.error(wrapRes.data.msg || '迁移失败')
+          }
+        }
+      })
+    } catch (e: any) {
+      message.error(e.message || '迁移失败')
+    } finally {
+      setWrapLoading(prev => ({ ...prev, [account.id]: false }))
+    }
+  }

  useEffect(() => {
    fetchAccounts()
  }, [fetchAccounts])

+  // 首次进入且有账户时显示迁移引导
+  useEffect(() => {
+    if (!loading && accounts.length > 0 && !localStorage.getItem(ACCOUNT_GUIDE_KEY)) {
+      setMigrationGuideVisible(true)
+    }
+  }, [loading, accounts.length])
+
  const handleAccountImportSuccess = async () => {
    message.success(t('accountImport.importSuccess'))
    setAccountImportModalVisible(false)
@@ -325,177 +372,105 @@ const AccountList: React.FC = () => {
        }
        const balanceObj = balanceMap[record.id]
        const balance = balanceObj?.total || record.balance || '-'
-        return balance && balance !== '-' && typeof balance === 'string' ? `${formatUSDC(balance)} USDC` : '-'
+        return balance && balance !== '-' && typeof balance === 'string' ? `$${formatUSDC(balance)}` : '-'
      }
    },
    {
      title: t('accountList.action'),
      key: 'action',
+      width: 140,
      render: (_: any, record: Account) => (
-        <Space size="small">
-          <Button
-            type="link"
-            size="small"
-            onClick={() => handleShowDetail(record)}
-          >
-            {t('accountList.detail')}
-          </Button>
-          <Button
-            type="link"
-            size="small"
-            icon={<EditOutlined />}
-            onClick={() => handleShowEdit(record)}
-          >
-            {t('accountList.edit')}
-          </Button>
-          <Popconfirm
-            title={t('accountList.deleteConfirm')}
-            description={
-              record.apiKeyConfigured
-                ? t('accountList.deleteConfirmDesc')
-                : t('accountList.deleteConfirmDescSimple')
-            }
-            onConfirm={() => handleDelete(record)}
-            okText={t('accountList.deleteConfirmOk')}
-            cancelText={t('common.cancel')}
-            okButtonProps={{ danger: true }}
-          >
-            <Button type="link" size="small" danger>
-              {t('accountList.delete')}
-            </Button>
-          </Popconfirm>
-        </Space>
-      )
-    }
-  ]
-
-  const mobileColumns = [
-    {
-      title: t('accountList.accountName'),
-      key: 'info',
-      render: (_: any, record: Account) => {
-        return (
-          <div style={{ padding: '8px 0' }}>
-            <div style={{
-              fontWeight: 'bold',
-              marginBottom: '8px',
-              fontSize: '16px'
-            }}>
-              {record.accountName || `${t('accountList.accountName')} ${record.id}`}
-            </div>
-            <div style={{
-              fontSize: '11px',
-              color: '#666',
-              marginBottom: '8px',
-              wordBreak: 'break-all',
-              fontFamily: 'monospace',
-              lineHeight: '1.4'
-            }}>
-              <div style={{ marginBottom: '4px' }}>
-                <strong>{t('accountList.walletAddress')}:</strong> {record.walletAddress ? `${record.walletAddress.slice(0, 6)}...${record.walletAddress.slice(-4)}` : '-'}
-                <Button
-                  type="text"
-                  size="small"
-                  icon={<CopyOutlined />}
-                  onClick={(e) => {
-                    e.stopPropagation()
-                    handleCopy(record.walletAddress)
-                  }}
-                  style={{ marginLeft: '4px', padding: '0 4px' }}
-                />
-              </div>
-              <div style={{ marginBottom: '4px' }}>
-                <strong>{t('accountList.proxyAddress')}:</strong> {record.proxyAddress ? `${record.proxyAddress.slice(0, 6)}...${record.proxyAddress.slice(-4)}` : '-'}
-                <Button
-                  type="text"
-                  size="small"
-                  icon={<CopyOutlined />}
-                  onClick={(e) => {
-                    e.stopPropagation()
-                    handleCopy(record.proxyAddress)
-                  }}
-                  style={{ marginLeft: '4px', padding: '0 4px' }}
-                />
-              </div>
-              {record.walletType && (
-                <div style={{ marginBottom: '4px' }}>
-                  <strong>{t('accountList.walletType')}:</strong>{' '}
-                  <Tag color={record.walletType.toLowerCase() === 'magic' ? 'purple' : 'blue'} style={{ marginLeft: '4px' }}>
-                    {record.walletType.toLowerCase() === 'magic' ? 'Magic' : 'Safe'}
-                  </Tag>
-                </div>
-              )}
-            </div>
-            <div style={{
-              fontSize: '14px',
-              fontWeight: '500',
-              color: '#1890ff'
-            }}>
-              {t('accountList.totalBalance')}: {balanceLoading[record.id] ? (
-                <Spin size="small" style={{ marginLeft: '4px' }} />
-              ) : balanceMap[record.id]?.total && balanceMap[record.id].total !== '-' ? (
-                `${formatUSDC(balanceMap[record.id].total)} USDC`
-              ) : (
-                '-'
-              )}
-            </div>
-            {balanceMap[record.id] && balanceMap[record.id].available !== '-' && (
-              <div style={{
-                fontSize: '12px',
-                color: '#666',
-                marginTop: '4px'
-              }}>
-                {t('accountList.available')}: {formatUSDC(balanceMap[record.id].available)} USDC | {t('accountList.position')}: {formatUSDC(balanceMap[record.id].position)} USDC
-              </div>
-            )}
-          </div>
-        )
-      }
-    },
-    {
-      title: t('accountList.action'),
-      key: 'action',
-      width: 100,
-      render: (_: any, record: Account) => (
-        <Space direction="vertical" size="small" style={{ width: '100%' }}>
-          <Button
-            type="primary"
-            size="small"
-            block
-            onClick={() => handleShowDetail(record)}
-            style={{ minHeight: '32px' }}
-          >
-            {t('accountList.viewDetail')}
-          </Button>
-          <Button
-            size="small"
-            block
-            icon={<EditOutlined />}
-            onClick={() => handleShowEdit(record)}
-            style={{ minHeight: '32px' }}
-          >
-            {t('accountList.edit')}
-          </Button>
-          <Popconfirm
-            title={t('accountList.deleteConfirm')}
-            description={
-              record.apiKeyConfigured
-                ? t('accountList.deleteConfirmDesc')
-                : t('accountList.deleteConfirmDescSimple')
-            }
-            onConfirm={() => handleDelete(record)}
-            okText={t('accountList.deleteConfirmOk')}
-            cancelText={t('common.cancel')}
-            okButtonProps={{ danger: true }}
-          >
-            <Button
-              size="small"
-              block
-              danger
-              style={{ minHeight: '32px' }}
+        <Space size={4}>
+          <Tooltip title={t('accountList.detail')}>
+            <div
+              onClick={() => handleShowDetail(record)}
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                width: '32px',
+                height: '32px',
+                cursor: 'pointer',
+                borderRadius: '6px',
+                transition: 'background-color 0.2s'
+              }}
+              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
+              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
            >
-              {t('accountList.delete')}
-            </Button>
+              <EyeOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+            </div>
+          </Tooltip>
+
+          <Tooltip title={t('accountList.edit')}>
+            <div
+              onClick={() => handleShowEdit(record)}
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                width: '32px',
+                height: '32px',
+                cursor: 'pointer',
+                borderRadius: '6px',
+                transition: 'background-color 0.2s'
+              }}
+              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
+              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+            >
+              <EditOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+            </div>
+          </Tooltip>
+
+          <Tooltip title="USDC.e → pUSD">
+            <div
+              onClick={() => handleWrapToPusd(record)}
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                width: '32px',
+                height: '32px',
+                cursor: wrapLoading[record.id] ? 'wait' : 'pointer',
+                borderRadius: '6px',
+                transition: 'background-color 0.2s'
+              }}
+              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#fff7e6'}
+              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+            >
+              <SwapOutlined style={{ fontSize: '16px', color: '#fa8c16' }} spin={wrapLoading[record.id]} />
+            </div>
+          </Tooltip>
+
+          <Popconfirm
+            title={t('accountList.deleteConfirm')}
+            description={
+              record.apiKeyConfigured
+                ? t('accountList.deleteConfirmDesc')
+                : t('accountList.deleteConfirmDescSimple')
+            }
+            onConfirm={() => handleDelete(record)}
+            okText={t('accountList.deleteConfirmOk')}
+            cancelText={t('common.cancel')}
+            okButtonProps={{ danger: true }}
+          >
+            <Tooltip title={t('accountList.delete')}>
+              <div
+                style={{
+                  display: 'flex',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                  width: '32px',
+                  height: '32px',
+                  cursor: 'pointer',
+                  borderRadius: '6px',
+                  transition: 'background-color 0.2s'
+                }}
+                onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#fff1f0'}
+                onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+              >
+                <DeleteOutlined style={{ fontSize: '16px', color: '#ff4d4f' }} />
+              </div>
+            </Tooltip>
          </Popconfirm>
        </Space>
      )
@@ -519,38 +494,214 @@ const AccountList: React.FC = () => {
        <Title level={isMobile ? 3 : 2} style={{ margin: 0, fontSize: isMobile ? '18px' : undefined }}>
          {t('accountList.title')}
        </Title>
-        <Button
-          type="primary"
-          icon={<PlusOutlined />}
-          onClick={() => setAccountImportModalVisible(true)}
-          size={isMobile ? 'middle' : 'large'}
-          block={isMobile}
-          style={isMobile ? { minHeight: '44px' } : undefined}
-        >
-          {t('accountList.importAccount')}
-        </Button>
+        <Tooltip title={t('accountList.importAccount')}>
+          <Button
+            type="primary"
+            icon={<PlusOutlined />}
+            onClick={() => setAccountImportModalVisible(true)}
+            size={isMobile ? 'middle' : 'large'}
+            style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}
+          />
+        </Tooltip>
      </div>

+      {migrationGuideVisible && !loading && accounts.length > 0 && (
+        <Alert
+          message={t('clobMigration.accountGuide')}
+          type="warning"
+          showIcon
+          icon={<SwapOutlined />}
+          closable
+          onClose={() => {
+            localStorage.setItem(ACCOUNT_GUIDE_KEY, 'true')
+            setMigrationGuideVisible(false)
+          }}
+          afterClose={() => {
+            localStorage.setItem(ACCOUNT_GUIDE_KEY, 'true')
+            setMigrationGuideVisible(false)
+          }}
+          style={{ marginBottom: 16, ...(isMobile ? { margin: '0 8px 12px' } : {}) }}
+          action={
+            <Button
+              size="small"
+              type="primary"
+              danger
+              onClick={() => {
+                localStorage.setItem(ACCOUNT_GUIDE_KEY, 'true')
+                setMigrationGuideVisible(false)
+              }}
+            >
+              {t('clobMigration.dismissGuide')}
+            </Button>
+          }
+        />
+      )}
+
      <Card style={{
        margin: isMobile ? '0 -8px' : '0',
        borderRadius: isMobile ? '0' : undefined
      }}>
        {isMobile ? (
-          <Table
-            dataSource={accounts}
-            columns={mobileColumns}
-            rowKey="id"
-            loading={loading}
-            pagination={{
-              pageSize: 10,
-              showSizeChanger: false,
-              simple: true,
-              size: 'small'
-            }}
-            scroll={{ x: 'max-content' }}
-            size="small"
-            style={{ fontSize: '14px' }}
-          />
+          loading ? (
+            <div style={{ textAlign: 'center', padding: '40px' }}>
+              <Spin size="large" />
+            </div>
+          ) : accounts.length === 0 ? (
+            <Empty description={t('accountList.noData')} />
+          ) : (
+            <List
+              dataSource={accounts}
+              renderItem={(account) => {
+                const balance = balanceMap[account.id]
+
+                return (
+                  <Card
+                    key={account.id}
+                    style={{
+                      marginBottom: '10px',
+                      borderRadius: '10px',
+                      boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
+                      border: '1px solid #e8e8e8',
+                      overflow: 'hidden'
+                    }}
+                    bodyStyle={{ padding: '0' }}
+                  >
+                    {/* 头部区域 */}
+                    <div style={{
+                      padding: '10px 12px',
+                      background: 'var(--ant-color-primary, #1677ff)',
+                      color: '#fff'
+                    }}>
+                      <div style={{ fontSize: '15px', fontWeight: '600', marginBottom: '2px', display: 'flex', alignItems: 'center', gap: '6px' }}>
+                        <WalletOutlined style={{ fontSize: '14px' }} />
+                        <span>{account.accountName || `${t('accountList.accountName')} ${account.id}`}</span>
+                      </div>
+                      <div style={{ fontSize: '10px', opacity: '0.85', fontFamily: 'monospace', display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
+                        <span>{account.walletAddress ? `${account.walletAddress.slice(0, 6)}...${account.walletAddress.slice(-4)}` : '-'}</span>
+                        <Button
+                          type="text"
+                          size="small"
+                          icon={<CopyOutlined style={{ fontSize: '12px', color: 'rgba(255,255,255,0.85)' }} />}
+                          onClick={() => handleCopy(account.walletAddress)}
+                          style={{ padding: '0 4px', height: 'auto' }}
+                        />
+                      </div>
+                    </div>
+
+                    {/* 资产区域 */}
+                    <div style={{
+                      padding: '8px 12px',
+                      backgroundColor: '#fafafa',
+                      borderBottom: '1px solid #f0f0f0',
+                      minHeight: '42px',
+                      display: 'flex',
+                      alignItems: 'center'
+                    }}>
+                      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', width: '100%' }}>
+                        <div>
+                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
+                            {t('accountList.totalBalance')}
+                          </div>
+                          <div style={{ fontSize: '14px', fontWeight: '600', color: '#52c41a' }}>
+                            {balance?.total && balance.total !== '-' ? `$${formatUSDC(balance.total)}` : '-'}
+                          </div>
+                        </div>
+                        <div style={{ textAlign: 'right' }}>
+                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
+                            {t('accountList.walletType')}
+                          </div>
+                          <div style={{ fontSize: '12px' }}>
+                            {account.walletType ? (
+                              <Tag color={account.walletType.toLowerCase() === 'magic' ? 'purple' : 'blue'} style={{ margin: 0 }}>
+                                {account.walletType.toLowerCase() === 'magic' ? 'Magic' : 'Safe'}
+                              </Tag>
+                            ) : '-'}
+                          </div>
+                        </div>
+                      </div>
+                    </div>
+
+                    {/* 地址信息区域 */}
+                    <div style={{
+                      padding: '8px 12px',
+                      fontSize: '11px',
+                      color: '#8c8c8c',
+                      borderBottom: '1px solid #f0f0f0'
+                    }}>
+                      <div style={{ display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
+                        <span>{t('accountList.proxyAddress')}: {account.proxyAddress ? `${account.proxyAddress.slice(0, 6)}...${account.proxyAddress.slice(-4)}` : '-'}</span>
+                        <Button
+                          type="text"
+                          size="small"
+                          icon={<CopyOutlined style={{ fontSize: '12px' }} />}
+                          onClick={() => handleCopy(account.proxyAddress)}
+                          style={{ padding: '0 4px', height: 'auto' }}
+                        />
+                      </div>
+                    </div>
+
+                    {/* 图标操作栏 */}
+                    <div style={{
+                      padding: '8px 12px',
+                      display: 'flex',
+                      justifyContent: 'space-around',
+                      alignItems: 'center'
+                    }}>
+                      <Tooltip title={t('accountList.detail')}>
+                        <div
+                          onClick={() => handleShowDetail(account)}
+                          style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
+                        >
+                          <EyeOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                          <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('accountList.detail')}</span>
+                        </div>
+                      </Tooltip>
+
+                      <Tooltip title={t('accountList.edit')}>
+                        <div
+                          onClick={() => handleShowEdit(account)}
+                          style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
+                        >
+                          <EditOutlined style={{ fontSize: '18px', color: '#52c41a' }} />
+                          <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('accountList.edit')}</span>
+                        </div>
+                      </Tooltip>
+
+                      <Tooltip title={t('clobMigration.accountGuideButton')}>
+                        <div
+                          onClick={() => handleWrapToPusd(account)}
+                          style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: wrapLoading[account.id] ? 'wait' : 'pointer', padding: '4px 8px' }}
+                        >
+                          <SwapOutlined style={{ fontSize: '18px', color: '#fa8c16' }} spin={wrapLoading[account.id]} />
+                          <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('clobMigration.accountGuideButton')}</span>
+                        </div>
+                      </Tooltip>
+
+                      <Popconfirm
+                        title={t('accountList.deleteConfirm')}
+                        description={
+                          account.apiKeyConfigured
+                            ? t('accountList.deleteConfirmDesc')
+                            : t('accountList.deleteConfirmDescSimple')
+                        }
+                        onConfirm={() => handleDelete(account)}
+                        okText={t('accountList.deleteConfirmOk')}
+                        cancelText={t('common.cancel')}
+                        okButtonProps={{ danger: true }}
+                      >
+                        <Tooltip title={t('accountList.delete')}>
+                          <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                            <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
+                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('accountList.delete')}</span>
+                          </div>
+                        </Tooltip>
+                      </Popconfirm>
+                    </div>
+                  </Card>
+                )
+              }}
+            />
+          )
        ) : (
          <Table
            dataSource={accounts}
@@ -686,7 +837,7 @@ const AccountList: React.FC = () => {
                  <Spin size="small" />
                ) : detailBalance ? (
                  <span style={{ fontWeight: 'bold', color: '#1890ff', fontSize: '16px' }}>
-                    {formatUSDC(detailBalance.total)} USDC
+                    ${formatUSDC(detailBalance.total)}
                  </span>
                ) : (
                  <span style={{ color: '#999' }}>-</span>
@@ -697,7 +848,7 @@ const AccountList: React.FC = () => {
                  <Spin size="small" />
                ) : detailBalance ? (
                  <span style={{ color: '#52c41a' }}>
-                    {formatUSDC(detailBalance.available)} USDC
+                    ${formatUSDC(detailBalance.available)}
                  </span>
                ) : (
                  <span style={{ color: '#999' }}>-</span>
@@ -708,7 +859,7 @@ const AccountList: React.FC = () => {
                  <Spin size="small" />
                ) : detailBalance ? (
                  <span style={{ color: '#1890ff' }}>
-                    {formatUSDC(detailBalance.position)} USDC
+                    ${formatUSDC(detailBalance.position)}
                  </span>
                ) : (
                  <span style={{ color: '#999' }}>-</span>
@@ -764,7 +915,7 @@ const AccountList: React.FC = () => {
                          fontWeight: 'bold',
                          color: detailAccount.totalPnl && detailAccount.totalPnl.startsWith('-') ? '#ff4d4f' : '#52c41a'
                        }}>
-                          {formatUSDC(detailAccount.totalPnl)} USDC
+                          ${formatUSDC(detailAccount.totalPnl)}
                        </span>
                      </Descriptions.Item>
                    )}
@@ -10,6 +10,8 @@ interface BacktestChartProps {
  }[]
 }

+// Bug #39 Note: This chart currently displays cash balance (balanceAfter), not total equity.
+// A true equity curve (cash + position value) would require an equityAfter field in the trade records.
 const BacktestChart: React.FC<BacktestChartProps> = ({ trades }) => {
  const { t } = useTranslation()
  const chartRef = useRef<HTMLDivElement>(null)
@@ -73,9 +75,9 @@ const BacktestChart: React.FC<BacktestChartProps> = ({ trades }) => {
          return `
            <div>
              <div>${t('backtest.tradeTime')}: ${param.name}</div>
-              <div>${t('backtest.balanceAfter')}: ${value} USDC</div>
+              <div>${t('backtest.balanceAfter')}: $${value}</div>
              <div style="color: ${color}">
-                ${t('backtest.profitLoss')}: ${diff} USDC (${diffPercent}%)
+                ${t('backtest.profitLoss')}: $${diff} (${diffPercent}%)
              </div>
            </div>
          `
@@ -119,7 +121,7 @@ const BacktestChart: React.FC<BacktestChartProps> = ({ trades }) => {
      },
      yAxis: {
        type: 'value',
-        name: 'USDC',
+        name: '$',
        nameLocation: 'end',
        nameGap: 10,
        axisLabel: {
@@ -279,14 +279,14 @@ const BacktestDetail: React.FC = () => {
      render: (value: string) => parseFloat(value).toFixed(4)
    },
    {
-      title: t('backtest.amount') + ' (USDC)',
+      title: t('backtest.amount') + ' ($)',
      dataIndex: 'amount',
      key: 'amount',
      width: 120,
      render: (value: string) => formatUSDC(value)
    },
    {
-      title: t('backtest.balanceAfter') + ' (USDC)',
+      title: t('backtest.balanceAfter') + ' ($)',
      dataIndex: 'balanceAfter',
      key: 'balanceAfter',
      width: 120,
@@ -346,14 +346,14 @@ const BacktestDetail: React.FC = () => {
                {task.leaderName || task.leaderAddress}
              </Descriptions.Item>
              <Descriptions.Item label={t('backtest.initialBalance')}>
-                {formatUSDC(task.initialBalance)} USDC
+                ${formatUSDC(task.initialBalance)}
              </Descriptions.Item>
              <Descriptions.Item label={t('backtest.finalBalance')}>
-                {task.finalBalance ? formatUSDC(task.finalBalance) + ' USDC' : '-'}
+                {task.finalBalance ? '$' + formatUSDC(task.finalBalance) : '-'}
              </Descriptions.Item>
              <Descriptions.Item label={t('backtest.profitAmount')}>
                <span style={{ color: task.profitAmount && parseFloat(task.profitAmount) >= 0 ? '#52c41a' : '#ff4d4f' }}>
-                  {task.profitAmount ? formatUSDC(task.profitAmount) + ' USDC' : '-'}
+                  {task.profitAmount ? '$' + formatUSDC(task.profitAmount) : '-'}
                </span>
              </Descriptions.Item>
              <Descriptions.Item label={t('backtest.profitRate')}>
@@ -1,6 +1,6 @@
 import { useState, useEffect } from 'react'
 import { useSearchParams } from 'react-router-dom'
-import { Table, Card, Button, Select, Tag, Space, Modal, message, Row, Col, Form, Input, InputNumber, Switch, Statistic, Descriptions } from 'antd'
+import { Table, Card, Button, Select, Tag, Space, Modal, message, Row, Col, Form, Input, InputNumber, Switch, Statistic, Descriptions, List, Empty, Spin, Tooltip, Popconfirm } from 'antd'
 import { useTranslation } from 'react-i18next'
 import { PlusOutlined, ReloadOutlined, DeleteOutlined, StopOutlined, EyeOutlined, RedoOutlined, CopyOutlined, SyncOutlined } from '@ant-design/icons'
 import { formatUSDC } from '../utils'
@@ -118,49 +118,35 @@ const BacktestList: React.FC = () => {
  }

  // 删除任务
-  const handleDelete = (id: number) => {
-    Modal.confirm({
-      title: t('backtest.deleteConfirm'),
-      okText: t('common.confirm'),
-      cancelText: t('common.cancel'),
-      onOk: async () => {
-        try {
-          const response = await backtestService.delete({ id })
-          if (response.data.code === 0) {
-            message.success(t('backtest.deleteSuccess'))
-            fetchTasks()
-          } else {
-            message.error(response.data.msg || t('backtest.deleteFailed'))
-          }
-        } catch (error) {
-          console.error('Failed to delete backtest task:', error)
-          message.error(t('backtest.deleteFailed'))
-        }
+  const handleDelete = async (id: number) => {
+    try {
+      const response = await backtestService.delete({ id })
+      if (response.data.code === 0) {
+        message.success(t('backtest.deleteSuccess'))
+        fetchTasks()
+      } else {
+        message.error(response.data.msg || t('backtest.deleteFailed'))
      }
-    })
+    } catch (error) {
+      console.error('Failed to delete backtest task:', error)
+      message.error(t('backtest.deleteFailed'))
+    }
  }

  // 停止任务
-  const handleStop = (id: number) => {
-    Modal.confirm({
-      title: t('backtest.stopConfirm'),
-      okText: t('common.confirm'),
-      cancelText: t('common.cancel'),
-      onOk: async () => {
-        try {
-          const response = await backtestService.stop({ id })
-          if (response.data.code === 0) {
-            message.success(t('backtest.stopSuccess'))
-            fetchTasks()
-          } else {
-            message.error(response.data.msg || t('backtest.stopFailed'))
-          }
-        } catch (error) {
-          console.error('Failed to stop backtest task:', error)
-          message.error(t('backtest.stopFailed'))
-        }
+  const handleStop = async (id: number) => {
+    try {
+      const response = await backtestService.stop({ id })
+      if (response.data.code === 0) {
+        message.success(t('backtest.stopSuccess'))
+        fetchTasks()
+      } else {
+        message.error(response.data.msg || t('backtest.stopFailed'))
      }
-    })
+    } catch (error) {
+      console.error('Failed to stop backtest task:', error)
+      message.error(t('backtest.stopFailed'))
+    }
  }

  // 按配置重新测试（仅已完成任务）
@@ -475,14 +461,14 @@ const BacktestList: React.FC = () => {
      render: (value: string) => parseFloat(value).toFixed(4)
    },
    {
-      title: t('backtest.amount') + ' (USDC)',
+      title: t('backtest.amount') + ' ($)',
      dataIndex: 'amount',
      key: 'amount',
      width: 120,
      render: (value: string) => formatUSDC(value)
    },
    {
-      title: t('backtest.balanceAfter') + ' (USDC)',
+      title: t('backtest.balanceAfter') + ' ($)',
      dataIndex: 'balanceAfter',
      key: 'balanceAfter',
      width: 120,
@@ -502,168 +488,227 @@ const BacktestList: React.FC = () => {
      title: t('backtest.taskName'),
      dataIndex: 'taskName',
      key: 'taskName',
-      width: isMobile ? 120 : 150
+      width: isMobile ? 120 : 140,
+      ellipsis: true
    },
    {
      title: t('backtest.leader'),
      dataIndex: 'leaderName',
      key: 'leaderName',
-      width: isMobile ? 100 : 150,
+      width: isMobile ? 100 : 120,
+      ellipsis: true,
      render: (_: any, record: BacktestTaskDto) => record.leaderName || `Leader ${record.leaderId}`
    },
    {
-      title: t('backtest.initialBalance'),
-      dataIndex: 'initialBalance',
-      key: 'initialBalance',
-      width: 120,
-      render: (value: string) => formatUSDC(value)
+      title: t('backtest.balance'),
+      key: 'balance',
+      width: 160,
+      render: (_: any, record: BacktestTaskDto) => (
+        <div>
+          <div style={{ fontSize: 12, color: '#8c8c8c' }}>{formatUSDC(record.initialBalance)}</div>
+          <div style={{ fontWeight: 500 }}>{record.finalBalance ? formatUSDC(record.finalBalance) : '-'}</div>
+        </div>
+      )
    },
    {
-      title: t('backtest.finalBalance'),
-      dataIndex: 'finalBalance',
-      key: 'finalBalance',
-      width: 120,
-      render: (value: string | null) => value ? formatUSDC(value) : '-'
-    },
-    {
-      title: t('backtest.profitAmount'),
-      dataIndex: 'profitAmount',
-      key: 'profitAmount',
-      width: 120,
-      render: (value: string | null) => value ? (
-        <span style={{ color: parseFloat(value) >= 0 ? '#52c41a' : '#ff4d4f' }}>
-          {formatUSDC(value)}
-        </span>
-      ) : '-'
-    },
-    {
-      title: t('backtest.profitRate'),
-      dataIndex: 'profitRate',
-      key: 'profitRate',
-      width: 100,
-      render: (value: string | null) => value ? (
-        <span style={{ color: parseFloat(value) >= 0 ? '#52c41a' : '#ff4d4f' }}>
-          {value}%
-        </span>
-      ) : '-'
-    },
-    {
-      title: t('backtest.backtestDays'),
-      dataIndex: 'backtestDays',
-      key: 'backtestDays',
-      width: 100,
-      render: (value: number) => `${value} ${t('common.day')}`
+      title: t('backtest.profit'),
+      key: 'profit',
+      width: 140,
+      render: (_: any, record: BacktestTaskDto) => {
+        const profitAmount = record.profitAmount ? parseFloat(record.profitAmount) : null
+        const profitRate = record.profitRate ? parseFloat(record.profitRate) : null
+        const color = profitAmount !== null ? (profitAmount >= 0 ? '#52c41a' : '#ff4d4f') : undefined
+        return (
+          <div>
+            <div style={{ fontWeight: 500, color }}>
+              {profitAmount !== null ? formatUSDC(record.profitAmount) : '-'}
+            </div>
+            <div style={{ fontSize: 12, color }}>
+              {profitRate !== null ? `${record.profitRate}%` : '-'}
+            </div>
+          </div>
+        )
+      }
    },
    {
      title: t('backtest.status'),
      dataIndex: 'status',
      key: 'status',
-      width: 100,
-      render: (status: string) => (
-        <Tag color={getStatusColor(status)}>{getStatusText(status)}</Tag>
-      )
-    },
-    {
-      title: t('backtest.progress'),
-      dataIndex: 'progress',
-      key: 'progress',
-      width: 120,
-      render: (progress: number) => (
-        <div style={{ width: '100%' }}>
-          <div style={{ marginBottom: 4 }}>{progress}%</div>
-          <div style={{ width: '100%', height: 6, backgroundColor: '#f0f0f0', borderRadius: 3 }}>
-            <div
-              style={{
-                width: `${progress}%`,
-                height: '100%',
-                backgroundColor: progress === 100 ? '#52c41a' : '#1890ff',
-                borderRadius: 3,
-                transition: 'width 0.3s ease'
-              }}
-            />
+      width: 130,
+      render: (status: string, record: BacktestTaskDto) => {
+        const isRunning = status === 'RUNNING' || status === 'PENDING'
+        return (
+          <div>
+            <Tag color={getStatusColor(status)}>{getStatusText(status)}</Tag>
+            {isRunning && record.progress !== undefined && (
+              <div style={{ marginTop: 4, fontSize: 11, color: '#8c8c8c' }}>
+                {record.progress}%
+              </div>
+            )}
          </div>
-        </div>
-      )
+        )
+      }
    },
    {
      title: t('backtest.totalTrades'),
      dataIndex: 'totalTrades',
      key: 'totalTrades',
-      width: 100
+      width: 80,
+      align: 'center' as const
    },
    {
      title: t('backtest.createdAt'),
      dataIndex: 'createdAt',
      key: 'createdAt',
-      width: isMobile ? 150 : 180,
+      width: isMobile ? 150 : 150,
      render: (timestamp: number) => new Date(timestamp).toLocaleString()
    },
    {
      title: t('common.actions'),
      key: 'actions',
      fixed: isMobile ? false : ('right' as const),
-      width: isMobile ? 100 : 150,
+      width: isMobile ? 100 : 180,
      render: (_: any, record: BacktestTaskDto) => (
-        <Space size="small">
-          <Button
-            type="link"
-            size="small"
-            icon={<EyeOutlined />}
-            onClick={() => handleViewDetail(record.id)}
-          >
-            {t('common.viewDetail')}
-          </Button>
+        <Space size={4}>
+          <Tooltip title={t('common.viewDetail')}>
+            <div
+              onClick={() => handleViewDetail(record.id)}
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                width: '32px',
+                height: '32px',
+                cursor: 'pointer',
+                borderRadius: '6px',
+                transition: 'background-color 0.2s'
+              }}
+              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
+              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+            >
+              <EyeOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+            </div>
+          </Tooltip>
+
          {record.status === 'COMPLETED' && (
            <>
-              <Button
-                type="link"
-                size="small"
-                icon={<SyncOutlined />}
-                onClick={() => handleRerun(record)}
-              >
-                {t('backtest.rerun')}
-              </Button>
-              <Button
-                type="link"
-                size="small"
-                icon={<CopyOutlined />}
-                onClick={() => handleCreateCopyTrading(record)}
-              >
-                {t('backtest.createCopyTrading')}
-              </Button>
+              <Tooltip title={t('backtest.rerun')}>
+                <div
+                  onClick={() => handleRerun(record)}
+                  style={{
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    width: '32px',
+                    height: '32px',
+                    cursor: 'pointer',
+                    borderRadius: '6px',
+                    transition: 'background-color 0.2s'
+                  }}
+                  onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
+                  onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+                >
+                  <SyncOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+                </div>
+              </Tooltip>
+              <Tooltip title={t('backtest.createCopyTrading')}>
+                <div
+                  onClick={() => handleCreateCopyTrading(record)}
+                  style={{
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    width: '32px',
+                    height: '32px',
+                    cursor: 'pointer',
+                    borderRadius: '6px',
+                    transition: 'background-color 0.2s'
+                  }}
+                  onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
+                  onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+                >
+                  <CopyOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+                </div>
+              </Tooltip>
            </>
          )}
+
          {record.status === 'RUNNING' && (
-            <Button
-              type="link"
-              size="small"
-              danger
-              icon={<StopOutlined />}
-              onClick={() => handleStop(record.id)}
+            <Popconfirm
+              title={t('backtest.stopConfirm')}
+              onConfirm={() => handleStop(record.id)}
+              okText={t('common.confirm')}
+              cancelText={t('common.cancel')}
            >
-              {t('backtest.stop')}
-            </Button>
+              <Tooltip title={t('backtest.stop')}>
+                <div
+                  style={{
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    width: '32px',
+                    height: '32px',
+                    cursor: 'pointer',
+                    borderRadius: '6px',
+                    transition: 'background-color 0.2s'
+                  }}
+                  onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
+                  onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+                >
+                  <StopOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+                </div>
+              </Tooltip>
+            </Popconfirm>
          )}
+
          {(record.status === 'STOPPED' || record.status === 'FAILED') && (
-            <Button
-              type="link"
-              size="small"
-              icon={<RedoOutlined />}
-              onClick={() => handleRetry(record.id)}
-            >
-              {t('backtest.retry')}
-            </Button>
+            <Tooltip title={t('backtest.retry')}>
+              <div
+                onClick={() => handleRetry(record.id)}
+                style={{
+                  display: 'flex',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                  width: '32px',
+                  height: '32px',
+                  cursor: 'pointer',
+                  borderRadius: '6px',
+                  transition: 'background-color 0.2s'
+                }}
+                onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
+                onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+              >
+                <RedoOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+              </div>
+            </Tooltip>
          )}
+
          {(record.status === 'PENDING' || record.status === 'COMPLETED' || record.status === 'STOPPED' || record.status === 'FAILED') && (
-            <Button
-              type="link"
-              size="small"
-              danger
-              icon={<DeleteOutlined />}
-              onClick={() => handleDelete(record.id)}
+            <Popconfirm
+              title={t('backtest.deleteConfirm')}
+              onConfirm={() => handleDelete(record.id)}
+              okText={t('common.confirm')}
+              cancelText={t('common.cancel')}
            >
-              {t('common.delete')}
-            </Button>
+              <Tooltip title={t('common.delete')}>
+                <div
+                  style={{
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    width: '32px',
+                    height: '32px',
+                    cursor: 'pointer',
+                    borderRadius: '6px',
+                    transition: 'background-color 0.2s'
+                  }}
+                  onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#fff1f0'}
+                  onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+                >
+                  <DeleteOutlined style={{ fontSize: '16px', color: '#ff4d4f' }} />
+                </div>
+              </Tooltip>
+            </Popconfirm>
          )}
        </Space>
      )
@@ -671,94 +716,205 @@ const BacktestList: React.FC = () => {
  ]

  return (
-    <div style={{ padding: 24 }}>
-      <Card>
+    <div style={{ padding: isMobile ? 0 : 24 }}>
+      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px', flexWrap: 'wrap', gap: '12px', padding: isMobile ? '0 8px' : 0 }}>
+        <h2 style={{ margin: 0, fontSize: isMobile ? '20px' : '24px' }}>{t('backtest.title')}</h2>
+        <Space size={8}>
+          <Tooltip title={t('backtest.createTask')}>
+            <Button
+              type="primary"
+              icon={<PlusOutlined />}
+              onClick={handleCreate}
+              size={isMobile ? 'middle' : 'large'}
+              style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}
+            />
+          </Tooltip>
+          <Tooltip title={t('common.refresh')}>
+            <Button icon={<ReloadOutlined />} onClick={handleRefresh} loading={loading} size={isMobile ? 'middle' : 'large'} style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px' }} />
+          </Tooltip>
+        </Space>
+      </div>
+
+      <Card style={{ borderRadius: '12px', boxShadow: '0 2px 8px rgba(0,0,0,0.08)', border: '1px solid #e8e8e8' }} bodyStyle={{ padding: isMobile ? '12px' : '24px' }}>
        <Space direction="vertical" size="large" style={{ width: '100%' }}>
-          {/* 头部操作栏 */}
-          <Row justify="space-between" align="middle" gutter={[16, 16]}>
-            <Col xs={24} sm={24} md={12} lg={16}>
-              <Space size="middle" direction={isMobile ? 'vertical' : 'horizontal'} style={{ width: isMobile ? '100%' : 'auto' }}>
-                <LeaderSelect
-                  style={{ width: isMobile ? '100%' : 180 }}
-                  placeholder={t('backtest.leader')}
-                  allowClear
-                  value={leaderIdFilter}
-                  onChange={(value) => setLeaderIdFilter(value)}
-                  leaders={leaders}
-                />
-                <Select
-                  style={{ width: isMobile ? '100%' : 150 }}
-                  placeholder={t('backtest.status')}
-                  allowClear
-                  onChange={(value) => setStatusFilter(value)}
-                  value={statusFilter}
-                >
-                  <Select.Option value="PENDING">{t('backtest.statusPending')}</Select.Option>
-                  <Select.Option value="RUNNING">{t('backtest.statusRunning')}</Select.Option>
-                  <Select.Option value="COMPLETED">{t('backtest.statusCompleted')}</Select.Option>
-                  <Select.Option value="STOPPED">{t('backtest.statusStopped')}</Select.Option>
-                  <Select.Option value="FAILED">{t('backtest.statusFailed')}</Select.Option>
-                </Select>
-                <Select
-                  style={{ width: isMobile ? '100%' : 150 }}
-                  placeholder={t('backtest.sortBy')}
-                  onChange={(value) => setSortBy(value)}
-                  value={sortBy}
-                >
-                  <Select.Option value="profitAmount">{t('backtest.profitAmount')}</Select.Option>
-                  <Select.Option value="profitRate">{t('backtest.profitRate')}</Select.Option>
-                  <Select.Option value="createdAt">{t('backtest.createdAt')}</Select.Option>
-                </Select>
-                <Select
-                  style={{ width: isMobile ? '100%' : 120 }}
-                  placeholder={t('backtest.sortOrder')}
-                  onChange={(value) => setSortOrder(value)}
-                  value={sortOrder}
-                >
-                  <Select.Option value="asc">{t('common.ascending')}</Select.Option>
-                  <Select.Option value="desc">{t('common.descending')}</Select.Option>
-                </Select>
-              </Space>
+          {/* 筛选栏 */}
+          <Row gutter={[16, 16]} style={{ marginBottom: isMobile ? 12 : 0 }}>
+            <Col xs={24} sm={12} md={6}>
+              <LeaderSelect
+                style={{ width: '100%' }}
+                placeholder={t('backtest.leader')}
+                allowClear
+                value={leaderIdFilter}
+                onChange={(value) => setLeaderIdFilter(value)}
+                leaders={leaders}
+              />
            </Col>
-            <Col xs={24} sm={24} md={12} lg={8} style={{ textAlign: isMobile ? 'left' : 'right' }}>
-              <Space style={{ width: isMobile ? '100%' : 'auto' }}>
-                <Button
-                  type="primary"
-                  icon={<PlusOutlined />}
-                  onClick={handleCreate}
-                  style={{ flex: isMobile ? 1 : undefined }}
-                >
-                  {isMobile ? t('common.create') : t('backtest.createTask')}
-                </Button>
-                <Button
-                  icon={<ReloadOutlined />}
-                  onClick={handleRefresh}
-                  loading={loading}
-                  style={{ flex: isMobile ? 1 : undefined }}
-                >
-                  {t('common.refresh')}
-                </Button>
-              </Space>
+            <Col xs={24} sm={12} md={6}>
+              <Select
+                style={{ width: '100%' }}
+                placeholder={t('backtest.status')}
+                allowClear
+                onChange={(value) => setStatusFilter(value)}
+                value={statusFilter}
+              >
+                <Select.Option value="PENDING">{t('backtest.statusPending')}</Select.Option>
+                <Select.Option value="RUNNING">{t('backtest.statusRunning')}</Select.Option>
+                <Select.Option value="COMPLETED">{t('backtest.statusCompleted')}</Select.Option>
+                <Select.Option value="STOPPED">{t('backtest.statusStopped')}</Select.Option>
+                <Select.Option value="FAILED">{t('backtest.statusFailed')}</Select.Option>
+              </Select>
+            </Col>
+            <Col xs={24} sm={12} md={6}>
+              <Select style={{ width: '100%' }} placeholder={t('backtest.sortBy')} onChange={(value) => setSortBy(value)} value={sortBy}>
+                <Select.Option value="profitAmount">{t('backtest.profitAmount')}</Select.Option>
+                <Select.Option value="profitRate">{t('backtest.profitRate')}</Select.Option>
+                <Select.Option value="createdAt">{t('backtest.createdAt')}</Select.Option>
+              </Select>
+            </Col>
+            <Col xs={24} sm={12} md={6}>
+              <Select style={{ width: '100%' }} placeholder={t('backtest.sortOrder')} onChange={(value) => setSortOrder(value)} value={sortOrder}>
+                <Select.Option value="asc">{t('common.ascending')}</Select.Option>
+                <Select.Option value="desc">{t('common.descending')}</Select.Option>
+              </Select>
            </Col>
          </Row>

-          {/* 数据表格 */}
-          <Table
-            columns={columns}
-            dataSource={tasks}
-            rowKey="id"
-            loading={loading}
-            pagination={{
-              current: page,
-              pageSize: size,
-              total,
-              showSizeChanger: false,
-              showTotal: (total) => `${t('common.total')} ${total} ${t('common.items')}`,
-              onChange: (newPage) => setPage(newPage),
-              simple: isMobile
-            }}
-            scroll={isMobile ? { x: 1200 } : { x: 1400 }}
-          />
+          {/* 数据：移动端卡片 / 桌面端表格 */}
+          {isMobile ? (
+            <>
+              {loading ? (
+                <div style={{ textAlign: 'center', padding: '40px' }}>
+                  <Spin size="large" />
+                </div>
+              ) : tasks.length === 0 ? (
+                <Empty description={t('backtest.noData') || t('common.noData')} />
+              ) : (
+                <List
+                  dataSource={tasks}
+                  renderItem={(task) => (
+                    <Card
+                      key={task.id}
+                      style={{
+                        marginBottom: '10px',
+                        borderRadius: '10px',
+                        boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
+                        border: '1px solid #e8e8e8',
+                        overflow: 'hidden'
+                      }}
+                      bodyStyle={{ padding: 0 }}
+                    >
+                      <div style={{
+                        padding: '10px 12px',
+                        background: 'var(--ant-color-primary, #1677ff)',
+                        color: '#fff'
+                      }}>
+                        <div style={{ fontSize: '15px', fontWeight: '600', marginBottom: '2px' }}>{task.taskName}</div>
+                        <div style={{ fontSize: '12px', opacity: '0.9' }}>{task.leaderName || `Leader ${task.leaderId}`}</div>
+                      </div>
+                      <div style={{ padding: '8px 12px', backgroundColor: '#fafafa', borderBottom: '1px solid #f0f0f0', display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+                        <div>
+                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>{t('backtest.profitAmount')}</div>
+                          {task.profitAmount != null ? (
+                            <div style={{ fontSize: '14px', fontWeight: '600', color: parseFloat(task.profitAmount) >= 0 ? '#52c41a' : '#ff4d4f' }}>${formatUSDC(task.profitAmount)}</div>
+                          ) : (
+                            <div style={{ fontSize: '14px', color: '#8c8c8c' }}>-</div>
+                          )}
+                        </div>
+                        <div style={{ textAlign: 'right' }}>
+                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>{t('backtest.profitRate')}</div>
+                          {task.profitRate != null ? (
+                            <div style={{ fontSize: '14px', fontWeight: '600', color: parseFloat(task.profitRate) >= 0 ? '#52c41a' : '#ff4d4f' }}>{task.profitRate}%</div>
+                          ) : (
+                            <div style={{ fontSize: '14px', color: '#8c8c8c' }}>-</div>
+                          )}
+                        </div>
+                        <div style={{ textAlign: 'right' }}>
+                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>{t('backtest.status')}</div>
+                          <Tag color={getStatusColor(task.status)}>{getStatusText(task.status)}</Tag>
+                        </div>
+                      </div>
+                      <div style={{ padding: '6px 12px', fontSize: '11px', color: '#8c8c8c', borderBottom: '1px solid #f0f0f0' }}>
+                        {t('backtest.initialBalance')}: {formatUSDC(task.initialBalance)} · {t('backtest.backtestDays')}: {task.backtestDays} {t('common.day')} · {t('backtest.progress')}: {task.progress}%
+                      </div>
+                      <div style={{ padding: '8px 12px', display: 'flex', justifyContent: 'space-around', alignItems: 'center', flexWrap: 'wrap', gap: 4 }}>
+                        <Tooltip title={t('common.viewDetail')}>
+                          <div onClick={() => handleViewDetail(task.id)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                            <EyeOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.viewDetail')}</span>
+                          </div>
+                        </Tooltip>
+                        {task.status === 'COMPLETED' && (
+                          <>
+                            <Tooltip title={t('backtest.rerun')}>
+                              <div onClick={() => handleRerun(task)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                                <SyncOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                                <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('backtest.rerun')}</span>
+                              </div>
+                            </Tooltip>
+                            <Tooltip title={t('backtest.createCopyTrading')}>
+                              <div onClick={() => handleCreateCopyTrading(task)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                                <CopyOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                                <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('backtest.createCopyTrading')}</span>
+                              </div>
+                            </Tooltip>
+                          </>
+                        )}
+                        {task.status === 'RUNNING' && (
+                          <Tooltip title={t('backtest.stop')}>
+                            <div onClick={() => handleStop(task.id)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                              <StopOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('backtest.stop')}</span>
+                            </div>
+                          </Tooltip>
+                        )}
+                        {(task.status === 'STOPPED' || task.status === 'FAILED') && (
+                          <Tooltip title={t('backtest.retry')}>
+                            <div onClick={() => handleRetry(task.id)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                              <RedoOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('backtest.retry')}</span>
+                            </div>
+                          </Tooltip>
+                        )}
+                        {(task.status === 'PENDING' || task.status === 'COMPLETED' || task.status === 'STOPPED' || task.status === 'FAILED') && (
+                          <Tooltip title={t('common.delete')}>
+                            <div onClick={() => handleDelete(task.id)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                              <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
+                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.delete')}</span>
+                            </div>
+                          </Tooltip>
+                        )}
+                      </div>
+                    </Card>
+                  )}
+                />
+              )}
+              {/* 移动端分页 */}
+              {!loading && tasks.length > 0 && total > size && (
+                <div style={{ display: 'flex', justifyContent: 'center', marginTop: 16 }}>
+                  <Button size="small" disabled={page <= 1} onClick={() => setPage(p => Math.max(1, p - 1))}>{t('common.prev')}</Button>
+                  <span style={{ margin: '0 12px', lineHeight: '24px' }}>{page} / {Math.ceil(total / size)}</span>
+                  <Button size="small" disabled={page >= Math.ceil(total / size)} onClick={() => setPage(p => p + 1)}>{t('common.next')}</Button>
+                </div>
+              )}
+            </>
+          ) : (
+            <Table
+              columns={columns}
+              dataSource={tasks}
+              rowKey="id"
+              loading={loading}
+              pagination={{
+                current: page,
+                pageSize: size,
+                total,
+                showSizeChanger: false,
+                showTotal: (totalCount) => `${t('common.total')} ${totalCount} ${t('common.items')}`,
+                onChange: (newPage) => setPage(newPage),
+                simple: isMobile
+              }}
+              scroll={{ x: 1000 }}
+            />
+          )}
        </Space>
      </Card>

@@ -841,7 +997,7 @@ const BacktestList: React.FC = () => {
          <Row gutter={24}>
            <Col xs={24} sm={24} md={12}>
              <Form.Item
-                label={t('backtest.initialBalance') + ' (USDC)'}
+                label={t('backtest.initialBalance') + ' ($)'}
                name="initialBalance"
                rules={[
                  { required: true, message: t('backtest.initialBalanceRequired') || '请输入初始资金' },
@@ -926,7 +1082,7 @@ const BacktestList: React.FC = () => {

            {copyMode === 'FIXED' && (
              <Form.Item
-                label={t('backtest.fixedAmount') + ' (USDC)'}
+                label={t('backtest.fixedAmount') + ' ($)'}
                name="fixedAmount"
                rules={[
                  { required: true, message: t('backtest.fixedAmountRequired') || '请输入固定金额' },
@@ -945,7 +1101,7 @@ const BacktestList: React.FC = () => {
            <Row gutter={24}>
              <Col xs={24} sm={24} md={12}>
                <Form.Item
-                  label={t('backtest.maxOrderSize') + ' (USDC)'}
+                  label={t('backtest.maxOrderSize') + ' ($)'}
                  name="maxOrderSize"
                  rules={[{ required: true }]}
                >
@@ -954,7 +1110,7 @@ const BacktestList: React.FC = () => {
              </Col>
              <Col xs={24} sm={24} md={12}>
                <Form.Item
-                  label={t('backtest.minOrderSize') + ' (USDC)'}
+                  label={t('backtest.minOrderSize') + ' ($)'}
                  name="minOrderSize"
                  rules={[{ required: true }]}
                >
@@ -966,7 +1122,7 @@ const BacktestList: React.FC = () => {
            <Row gutter={24}>
              <Col xs={24} sm={24} md={12}>
                <Form.Item
-                  label={t('backtest.maxDailyLoss') + ' (USDC)'}
+                  label={t('backtest.maxDailyLoss') + ' ($)'}
                  name="maxDailyLoss"
                  rules={[{ required: true }]}
                >
@@ -985,7 +1141,7 @@ const BacktestList: React.FC = () => {
            </Row>

            <Form.Item
-              label={t('backtest.maxPositionValue') + ' (USDC)'}
+              label={t('backtest.maxPositionValue') + ' ($)'}
              name="maxPositionValue"
            >
              <InputNumber
@@ -1160,14 +1316,14 @@ const BacktestList: React.FC = () => {
                  {detailTask.leaderName || `Leader ${detailTask.leaderId}`}
                </Descriptions.Item>
                <Descriptions.Item label={t('backtest.initialBalance')}>
-                  {formatUSDC(detailTask.initialBalance)} USDC
+                  ${formatUSDC(detailTask.initialBalance)}
                </Descriptions.Item>
                <Descriptions.Item label={t('backtest.finalBalance')}>
-                  {detailTask.finalBalance ? formatUSDC(detailTask.finalBalance) + ' USDC' : '-'}
+                  {detailTask.finalBalance ? '$' + formatUSDC(detailTask.finalBalance) : '-'}
                </Descriptions.Item>
                <Descriptions.Item label={t('backtest.profitAmount')}>
                  <span style={{ color: detailTask.profitAmount && parseFloat(detailTask.profitAmount) >= 0 ? '#52c41a' : '#ff4d4f' }}>
-                    {detailTask.profitAmount ? formatUSDC(detailTask.profitAmount) + ' USDC' : '-'}
+                    {detailTask.profitAmount ? '$' + formatUSDC(detailTask.profitAmount) : '-'}
                  </span>
                </Descriptions.Item>
                <Descriptions.Item label={t('backtest.profitRate')}>
@@ -1283,17 +1439,17 @@ const BacktestList: React.FC = () => {
                  <Descriptions.Item label={t('backtest.copyMode')}>
                    {detailConfig.copyMode === 'RATIO' 
                      ? `${t('backtest.copyModeRatio')} ${parseFloat(detailConfig.copyRatio) * 100}%`
-                      : `${t('backtest.copyModeFixed')} ${formatUSDC(detailConfig.fixedAmount)} USDC`
+                      : `${t('backtest.copyModeFixed')} $${formatUSDC(detailConfig.fixedAmount)}`
                    }
                  </Descriptions.Item>
                  <Descriptions.Item label={t('backtest.maxOrderSize')}>
-                    {formatUSDC(detailConfig.maxOrderSize)} USDC
+                    {'$' + formatUSDC(detailConfig.maxOrderSize)}
                  </Descriptions.Item>
                  <Descriptions.Item label={t('backtest.minOrderSize')}>
-                    {formatUSDC(detailConfig.minOrderSize)} USDC
+                    {'$' + formatUSDC(detailConfig.minOrderSize)}
                  </Descriptions.Item>
                  <Descriptions.Item label={t('backtest.maxDailyLoss')}>
-                    {formatUSDC(detailConfig.maxDailyLoss)} USDC
+                    {'$' + formatUSDC(detailConfig.maxDailyLoss)}
                  </Descriptions.Item>
                  <Descriptions.Item label={t('backtest.maxDailyOrders')}>
                    {detailConfig.maxDailyOrders}
@@ -1315,7 +1471,7 @@ const BacktestList: React.FC = () => {
                  )}
                  {detailConfig.maxPositionValue && (
                    <Descriptions.Item label={t('backtest.maxPositionValue')}>
-                      {formatUSDC(detailConfig.maxPositionValue)} USDC
+                      {'$' + formatUSDC(detailConfig.maxPositionValue)}
                    </Descriptions.Item>
                  )}
                  {(detailConfig.minPrice || detailConfig.maxPrice) && (
@@ -150,7 +150,7 @@ const CopyTradingBuyOrdersPage: React.FC = () => {
        const amount = (parseFloat(record.quantity) * parseFloat(record.price)).toString()
        return (
          <span style={{ fontSize: isMobile ? 12 : 14 }}>
-            {isMobile ? formatUSDC(amount) : `${formatUSDC(amount)} USDC`}
+            {isMobile ? formatUSDC(amount) : `$${formatUSDC(amount)}`}
          </span>
        )
      }
@@ -305,7 +305,7 @@ const CopyTradingBuyOrdersPage: React.FC = () => {
                          数量: {formatUSDC(order.quantity)} | 价格: {formatUSDC(order.price)}
                        </div>
                        <div style={{ fontSize: '14px', fontWeight: '500', marginTop: '4px' }}>
-                          金额: {formatUSDC(amount)} USDC
+                          金额: ${formatUSDC(amount)}
                        </div>
                      </div>
                      
@@ -1,7 +1,7 @@
 import { useEffect, useState } from 'react'
 import { useSearchParams } from 'react-router-dom'
-import { Card, Table, Button, Space, Tag, Popconfirm, Switch, message, Select, Dropdown, Divider, Spin } from 'antd'
-import { PlusOutlined, DeleteOutlined, BarChartOutlined, UnorderedListOutlined, ArrowUpOutlined, ArrowDownOutlined, EditOutlined } from '@ant-design/icons'
+import { Card, Table, Button, Space, Tag, Popconfirm, Switch, message, Select, Dropdown, Spin, List, Empty, Tooltip } from 'antd'
+import { PlusOutlined, DeleteOutlined, BarChartOutlined, UnorderedListOutlined, ArrowUpOutlined, ArrowDownOutlined, EditOutlined, WalletOutlined, UserOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import type { MenuProps } from 'antd'
 import { apiService } from '../services/api'
@@ -279,7 +279,7 @@ const CopyTradingList: React.FC = () => {
              fontSize: isMobile ? 12 : 14
            }}>
              {getPnlIcon(stats.totalPnl)}
-              {isMobile ? formatUSDC(stats.totalPnl) : `${formatUSDC(stats.totalPnl)} USDC`}
+              {isMobile ? formatUSDC(stats.totalPnl) : `$${formatUSDC(stats.totalPnl)}`}
            </div>
            {!isMobile && (
              <div style={{ 
@@ -297,7 +297,7 @@ const CopyTradingList: React.FC = () => {
    {
      title: t('common.actions') || '操作',
      key: 'action',
-      width: isMobile ? 100 : 200,
+      width: isMobile ? 100 : 160,
      fixed: 'right' as const,
      render: (_: any, record: CopyTrading) => {
        const menuItems: MenuProps['items'] = [
@@ -321,61 +321,101 @@ const CopyTradingList: React.FC = () => {
            }
          }
        ]
-        
+
        return (
-          <Space size={isMobile ? 'small' : 'middle'} wrap>
-            {!isMobile && (
-              <>
-                <Button
-                  type="link"
-                  size="small"
-                  icon={<EditOutlined />}
-                  onClick={() => {
-                    setEditModalCopyTradingId(record.id.toString())
-                    setEditModalOpen(true)
-                  }}
-                >
-                  {t('common.edit') || '编辑'}
-                </Button>
-                <Button
-                  type="link"
-                  size="small"
-                  icon={<BarChartOutlined />}
-                  onClick={() => {
-                    setStatisticsModalCopyTradingId(record.id.toString())
-                    setStatisticsModalOpen(true)
-                  }}
-                >
-                  {t('copyTradingList.statistics') || '统计'}
-                </Button>
-              </>
-            )}
+          <Space size={4}>
+            <Tooltip title={t('common.edit') || '编辑'}>
+              <div
+                onClick={() => {
+                  setEditModalCopyTradingId(record.id.toString())
+                  setEditModalOpen(true)
+                }}
+                style={{
+                  display: 'flex',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                  width: '32px',
+                  height: '32px',
+                  cursor: 'pointer',
+                  borderRadius: '6px',
+                  transition: 'background-color 0.2s'
+                }}
+                onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#f0f0f0' }}
+                onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
+              >
+                <EditOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+              </div>
+            </Tooltip>
+
+            <Tooltip title={t('copyTradingList.statistics') || '统计'}>
+              <div
+                onClick={() => {
+                  setStatisticsModalCopyTradingId(record.id.toString())
+                  setStatisticsModalOpen(true)
+                }}
+                style={{
+                  display: 'flex',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                  width: '32px',
+                  height: '32px',
+                  cursor: 'pointer',
+                  borderRadius: '6px',
+                  transition: 'background-color 0.2s'
+                }}
+                onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#f0f0f0' }}
+                onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
+              >
+                <BarChartOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+              </div>
+            </Tooltip>
+
            <Dropdown menu={{ items: menuItems }} trigger={['click']}>
-              <Button
-                type="link"
-                size="small"
-                icon={<UnorderedListOutlined />}
-              >
-                {isMobile ? '' : (t('copyTradingList.orders') || '订单')}
-              </Button>
-            </Dropdown>
-            {!isMobile && (
-              <Popconfirm
-                title={t('copyTradingList.deleteConfirm') || '确定要删除这个跟单关系吗？'}
-                onConfirm={() => handleDelete(record.id)}
-                okText={t('common.confirm') || '确定'}
-                cancelText={t('common.cancel') || '取消'}
-              >
-                <Button
-                  type="link"
-                  size="small"
-                  danger
-                  icon={<DeleteOutlined />}
+              <Tooltip title={t('copyTradingList.orders') || '订单'}>
+                <div
+                  style={{
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    width: '32px',
+                    height: '32px',
+                    cursor: 'pointer',
+                    borderRadius: '6px',
+                    transition: 'background-color 0.2s'
+                  }}
+                  onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#f0f0f0' }}
+                  onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
                >
-                  {t('common.delete') || '删除'}
-                </Button>
-              </Popconfirm>
-            )}
+                  <UnorderedListOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+                </div>
+              </Tooltip>
+            </Dropdown>
+
+            <Popconfirm
+              title={t('copyTradingList.deleteConfirm') || '确定要删除这个跟单关系吗？'}
+              onConfirm={() => handleDelete(record.id)}
+              okText={t('common.confirm') || '确定'}
+              cancelText={t('common.cancel') || '取消'}
+            >
+              <Tooltip title={t('common.delete') || '删除'}>
+                <div
+                  style={{
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    width: '32px',
+                    height: '32px',
+                    cursor: 'pointer',
+                    borderRadius: '6px',
+                    transition: 'background-color 0.2s'
+                  }}
+                  onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#fff1f0' }}
+                  onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
+                >
+                  <DeleteOutlined style={{ fontSize: '16px', color: '#ff4d4f' }} />
+                </div>
+              </Tooltip>
+            </Popconfirm>
          </Space>
        )
      }
@@ -384,19 +424,21 @@ const CopyTradingList: React.FC = () => {
  
  return (
    <div>
-      <Card>
-        <div style={{ marginBottom: 16, display: 'flex', justifyContent: 'space-between', alignItems: 'center', flexWrap: 'wrap', gap: 16 }}>
-          <h2 style={{ margin: 0 }}>{t('copyTradingList.title') || '跟单配置管理'}</h2>
+      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px', flexWrap: 'wrap', gap: '12px' }}>
+        <h2 style={{ margin: 0, fontSize: isMobile ? '20px' : '24px' }}>{t('copyTradingList.title') || '跟单配置管理'}</h2>
+        <Tooltip title={t('copyTradingList.addCopyTrading') || '新增跟单'}>
          <Button
            type="primary"
            icon={<PlusOutlined />}
            onClick={() => setAddModalOpen(true)}
-          >
-            {t('copyTradingList.addCopyTrading') || '新增跟单'}
-          </Button>
-        </div>
-        
-        <div style={{ marginBottom: 16, display: 'flex', gap: 16, flexWrap: 'wrap' }}>
+            size={isMobile ? 'middle' : 'large'}
+            style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}
+          />
+        </Tooltip>
+      </div>
+
+      <Card style={{ borderRadius: '12px', boxShadow: '0 2px 8px rgba(0,0,0,0.08)', border: '1px solid #e8e8e8' }} bodyStyle={{ padding: isMobile ? '12px' : '24px' }}>
+        <div style={{ marginBottom: 16, display: 'flex', gap: 12, flexWrap: 'wrap' }}>
          <Select
            placeholder={t('copyTradingList.filterWallet') || '筛选钱包'}
            allowClear
@@ -421,14 +463,14 @@ const CopyTradingList: React.FC = () => {
          />
          
          <Select
-            placeholder="筛选状态"
+            placeholder={t('common.status') || '状态'}
            allowClear
            style={{ width: isMobile ? '100%' : 150 }}
            value={filters.enabled}
            onChange={(value) => setFilters({ ...filters, enabled: value !== undefined ? value : undefined })}
          >
-            <Option value={true}>开启</Option>
-            <Option value={false}>停止</Option>
+            <Option value={true}>{t('common.enabled') || '开启'}</Option>
+            <Option value={false}>{t('common.disabled') || '停止'}</Option>
          </Select>
        </div>
        
@@ -440,207 +482,180 @@ const CopyTradingList: React.FC = () => {
                <Spin size="large" />
              </div>
            ) : copyTradings.length === 0 ? (
-              <div style={{ textAlign: 'center', padding: '40px', color: '#999' }}>
-                暂无跟单配置
-              </div>
+              <Empty description={t('copyTradingList.noData') || '暂无跟单配置'} />
            ) : (
-              <div style={{ display: 'flex', flexDirection: 'column', gap: '12px' }}>
-                {copyTradings.map((record) => {
+              <List
+                dataSource={copyTradings}
+                renderItem={(record) => {
                  const stats = statisticsMap[record.id]
-                  const date = new Date(record.createdAt)
-                  const formattedDate = date.toLocaleString('zh-CN', {
-                    year: 'numeric',
-                    month: '2-digit',
-                    day: '2-digit',
-                    hour: '2-digit',
-                    minute: '2-digit'
-                  })
                  
                  return (
                    <Card
                      key={record.id}
                      style={{
-                        borderRadius: '12px',
-                        boxShadow: '0 2px 8px rgba(0,0,0,0.08)',
-                        border: '1px solid #e8e8e8'
+                        marginBottom: '10px',
+                        borderRadius: '10px',
+                        boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
+                        border: '1px solid #e8e8e8',
+                        overflow: 'hidden'
                      }}
-                      bodyStyle={{ padding: '16px' }}
+                      bodyStyle={{ padding: '0' }}
                    >
-                      {/* 基本信息 */}
-                      <div style={{ marginBottom: '12px' }}>
-                        <div style={{ 
-                          fontSize: '18px', 
-                          fontWeight: 'bold', 
-                          marginBottom: '8px',
-                          color: '#1890ff'
-                        }}>
-                          {record.configName || t('copyTradingList.configNameNotProvided') || '未提供'}
-                        </div>
-                        <div style={{ 
-                          fontSize: '14px', 
-                          marginBottom: '8px',
-                          color: '#666'
-                        }}>
-                          {record.copyMode === 'RATIO' 
-                            ? `${t('copyTradingList.ratioMode') || '比例'} ${(parseFloat(record.copyRatio || '0') * 100).toFixed(2).replace(/\.0+$/, '')}%`
-                            : `${t('copyTradingList.fixedAmountMode') || '固定'} ${formatUSDC(record.fixedAmount || '0')}`
-                          }
-                        </div>
-                        <div style={{ display: 'flex', flexWrap: 'wrap', gap: '6px', alignItems: 'center', justifyContent: 'space-between' }}>
-                          <Tag color={record.enabled ? 'green' : 'red'}>
-                            {record.enabled ? '启用' : '禁用'}
-                          </Tag>
+                      {/* 头部区域 - 配置名称 */}
+                      <div style={{
+                        padding: '10px 12px',
+                        background: 'var(--ant-color-primary, #1677ff)',
+                        color: '#fff'
+                      }}>
+                        <div style={{ fontSize: '15px', fontWeight: '600', marginBottom: '2px', display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
+                          <span>{record.configName || t('copyTradingList.configNameNotProvided') || '未提供'}</span>
                          <Switch
                            checked={record.enabled}
                            onChange={() => handleToggleStatus(record)}
-                            checkedChildren="开启"
-                            unCheckedChildren="停止"
+                            checkedChildren={t('copyTradingList.enabled') || '开启'}
+                            unCheckedChildren={t('copyTradingList.disabled') || '停止'}
                            size="small"
                          />
                        </div>
-                      </div>
-                      
-                      <Divider style={{ margin: '12px 0' }} />
-                      
-                      {/* 账户信息 */}
-                      <div style={{ marginBottom: '12px' }}>
-                        <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>账户</div>
-                        <div style={{ fontSize: '14px', fontWeight: '500' }}>
-                          {record.accountName || `账户 ${record.accountId}`}
-                        </div>
-                        <div style={{ fontSize: '12px', color: '#999', marginTop: '2px' }}>
-                          {record.walletAddress.slice(0, 6)}...{record.walletAddress.slice(-4)}
+                        <div style={{ fontSize: '12px', opacity: '0.9' }}>
+                          {record.copyMode === 'RATIO' 
+                            ? `${t('copyTradingList.ratioMode') || '比例'} ${(parseFloat(record.copyRatio || '0') * 100).toFixed(0).replace(/\.0+$/, '')}%`
+                            : `${t('copyTradingList.fixedAmountMode') || '固定'} $${formatUSDC(record.fixedAmount || '0')}`
+                          }
                        </div>
                      </div>
-                      
-                      {/* Leader 信息 */}
-                      <div style={{ marginBottom: '12px' }}>
-                        <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>Leader</div>
-                        <div style={{ fontSize: '14px', fontWeight: '500' }}>
-                          {record.leaderName || `Leader ${record.leaderId}`}
-                        </div>
-                        <div style={{ fontSize: '12px', color: '#999', marginTop: '2px' }}>
-                          {record.leaderAddress.slice(0, 6)}...{record.leaderAddress.slice(-4)}
-                        </div>
-                      </div>
-                      
-                      {/* 总盈亏 */}
-                      {stats && (
-                        <div style={{ marginBottom: '12px' }}>
-                          <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>总盈亏</div>
-                          <div style={{ 
-                            fontSize: '16px', 
-                            fontWeight: 'bold',
-                            color: getPnlColor(stats.totalPnl),
-                            display: 'flex',
-                            alignItems: 'center',
-                            gap: '4px'
-                          }}>
-                            {getPnlIcon(stats.totalPnl)}
-                            {formatUSDC(stats.totalPnl)} USDC
+
+                      {/* 盈亏区域 - 常驻显示 */}
+                      <div style={{
+                        padding: '8px 12px',
+                        backgroundColor: '#fafafa',
+                        borderBottom: '1px solid #f0f0f0',
+                        minHeight: '42px',
+                        display: 'flex',
+                        alignItems: 'center'
+                      }}>
+                        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', width: '100%' }}>
+                          <div>
+                            <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
+                              {t('copyTradingList.totalPnl') || '总盈亏'}
+                            </div>
+                            {stats ? (
+                              <div style={{ 
+                                fontSize: '14px', 
+                                fontWeight: '600',
+                                color: getPnlColor(stats.totalPnl),
+                                display: 'flex',
+                                alignItems: 'center',
+                                gap: '4px'
+                              }}>
+                                {getPnlIcon(stats.totalPnl)}
+                                ${formatUSDC(stats.totalPnl)}
+                              </div>
+                            ) : loadingStatistics.has(record.id) ? (
+                              <Spin size="small" />
+                            ) : (
+                              <div style={{ fontSize: '14px', color: '#8c8c8c' }}>-</div>
+                            )}
                          </div>
-                          <div style={{ 
-                            fontSize: '12px', 
-                            color: getPnlColor(stats.totalPnlPercent),
-                            marginTop: '4px'
-                          }}>
-                            {formatPercent(stats.totalPnlPercent)}
-                          </div>
-                        </div>
-                      )}
-                      
-                      {loadingStatistics.has(record.id) && (
-                        <div style={{ marginBottom: '12px', fontSize: '12px', color: '#999' }}>
-                          加载统计中...
-                        </div>
-                      )}
-                      
-                      {/* 创建时间 */}
-                      <div style={{ marginBottom: '16px' }}>
-                        <div style={{ fontSize: '12px', color: '#999' }}>
-                          创建时间: {formattedDate}
+                          {stats && (
+                            <div style={{ textAlign: 'right' }}>
+                              <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
+                                {t('copyTradingList.profitRate') || '收益率'}
+                              </div>
+                              <div style={{ 
+                                fontSize: '12px', 
+                                fontWeight: '500',
+                                color: getPnlColor(stats.totalPnlPercent)
+                              }}>
+                                {formatPercent(stats.totalPnlPercent)}
+                              </div>
+                            </div>
+                          )}
                        </div>
                      </div>
-                      
-                      {/* 操作按钮 */}
-                      <div style={{ display: 'flex', gap: '8px', flexWrap: 'wrap' }}>
-                        <Button
-                          type="primary"
-                          size="small"
-                          icon={<EditOutlined />}
-                          onClick={() => {
-                            setEditModalCopyTradingId(record.id.toString())
-                            setEditModalOpen(true)
-                          }}
-                          style={{ flex: 1, minWidth: '80px' }}
-                        >
-                          {t('common.edit') || '编辑'}
-                        </Button>
-                        <Button
-                          size="small"
-                          icon={<BarChartOutlined />}
-                          onClick={() => {
-                            setStatisticsModalCopyTradingId(record.id.toString())
-                            setStatisticsModalOpen(true)
-                          }}
-                          style={{ flex: 1, minWidth: '80px' }}
-                        >
-                          {t('copyTradingList.statistics') || '统计'}
-                        </Button>
-                        <Dropdown 
-                          menu={{ 
-                            items: [
-                              {
-                                key: 'matchedOrders',
-                                label: t('copyTradingList.matchedOrders') || '已成交订单',
-                                icon: <UnorderedListOutlined />,
-                                onClick: () => {
-                                  setOrdersModalCopyTradingId(record.id.toString())
-                                  setOrdersModalTab('buy')
-                                  setOrdersModalOpen(true)
-                                }
-                              },
-                              {
-                                key: 'filteredOrders',
-                                label: t('copyTradingList.filteredOrders') || '已过滤订单',
-                                icon: <UnorderedListOutlined />,
-                                onClick: () => {
-                                  setFilteredOrdersModalCopyTradingId(record.id.toString())
-                                  setFilteredOrdersModalOpen(true)
-                                }
-                              }
-                            ]
-                          }} 
-                          trigger={['click']}
-                        >
-                          <Button
-                            size="small"
-                            icon={<UnorderedListOutlined />}
-                            style={{ flex: 1, minWidth: '80px' }}
+
+                      {/* 账户和Leader信息区域 */}
+                      <div style={{
+                        padding: '8px 12px',
+                        fontSize: '11px',
+                        color: '#8c8c8c',
+                        borderBottom: '1px solid #f0f0f0'
+                      }}>
+                        <div style={{ display: 'flex', alignItems: 'center', marginBottom: '4px' }}>
+                          <WalletOutlined style={{ fontSize: '12px', marginRight: '4px', color: '#1890ff' }} />
+                          <span>{t('copyTradingList.wallet') || '账户'}: {record.accountName || `#${record.accountId}`}</span>
+                        </div>
+                        <div style={{ display: 'flex', alignItems: 'center' }}>
+                          <UserOutlined style={{ fontSize: '12px', marginRight: '4px', color: '#722ed1' }} />
+                          <span>Leader: {record.leaderName || `#${record.leaderId}`}</span>
+                        </div>
+                      </div>
+
+                      {/* 图标操作栏 */}
+                      <div style={{
+                        padding: '8px 12px',
+                        display: 'flex',
+                        justifyContent: 'space-around',
+                        alignItems: 'center'
+                      }}>
+                        <Tooltip title={t('common.edit') || '编辑'}>
+                          <div
+                            onClick={() => {
+                              setEditModalCopyTradingId(record.id.toString())
+                              setEditModalOpen(true)
+                            }}
+                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
                          >
-                            {t('copyTradingList.orders') || '订单'}
-                          </Button>
-                        </Dropdown>
+                            <EditOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.edit') || '编辑'}</span>
+                          </div>
+                        </Tooltip>
+
+                        <Tooltip title={t('copyTradingList.statistics') || '统计'}>
+                          <div
+                            onClick={() => {
+                              setStatisticsModalCopyTradingId(record.id.toString())
+                              setStatisticsModalOpen(true)
+                            }}
+                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
+                          >
+                            <BarChartOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('copyTradingList.statistics') || '统计'}</span>
+                          </div>
+                        </Tooltip>
+
+                        <Tooltip title={t('copyTradingList.orders') || '订单'}>
+                          <div
+                            onClick={() => {
+                              setOrdersModalCopyTradingId(record.id.toString())
+                              setOrdersModalTab('buy')
+                              setOrdersModalOpen(true)
+                            }}
+                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
+                          >
+                            <UnorderedListOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('copyTradingList.orders') || '订单'}</span>
+                          </div>
+                        </Tooltip>
+
                        <Popconfirm
                          title={t('copyTradingList.deleteConfirm') || '确定要删除这个跟单关系吗？'}
                          onConfirm={() => handleDelete(record.id)}
                          okText={t('common.confirm') || '确定'}
                          cancelText={t('common.cancel') || '取消'}
                        >
-                          <Button
-                            danger
-                            size="small"
-                            icon={<DeleteOutlined />}
-                            style={{ flex: 1, minWidth: '80px' }}
-                          >
-                            {t('common.delete') || '删除'}
-                          </Button>
+                          <Tooltip title={t('common.delete') || '删除'}>
+                            <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                              <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
+                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.delete') || '删除'}</span>
+                            </div>
+                          </Tooltip>
                        </Popconfirm>
                      </div>
                    </Card>
                  )
-                })}
-              </div>
+                }}
+              />
            )}
          </div>
        ) : (
@@ -130,7 +130,7 @@ const CopyTradingMatchedOrdersPage: React.FC = () => {
          fontWeight: 500,
          fontSize: isMobile ? 12 : 14
        }}>
-          {isMobile ? formatUSDC(value) : `${formatUSDC(value)} USDC`}
+          {isMobile ? formatUSDC(value) : `$${formatUSDC(value)}`}
        </span>
      )
    },
@@ -262,7 +262,7 @@ const CopyTradingMatchedOrdersPage: React.FC = () => {
                          fontWeight: 'bold',
                          color: getPnlColor(order.realizedPnl)
                        }}>
-                          {formatUSDC(order.realizedPnl)} USDC
+                          ${formatUSDC(order.realizedPnl)}
                        </div>
                      </div>
                      
@@ -518,7 +518,7 @@ const AddModal: React.FC<AddModalProps> = ({
                      value={parseFloat(leaderAssetInfo.total)}
                      precision={4}
                      valueStyle={{ color: '#52c41a', fontWeight: 'bold', fontSize: '16px' }}
-                      suffix="USDC"
+                      prefix="$"
                      formatter={(value) => formatUSDC(value?.toString() || '0')}
                    />
                  </Col>
@@ -528,7 +528,7 @@ const AddModal: React.FC<AddModalProps> = ({
                      value={parseFloat(leaderAssetInfo.available)}
                      precision={4}
                      valueStyle={{ color: '#1890ff', fontSize: '14px' }}
-                      suffix="USDC"
+                      prefix="$"
                      formatter={(value) => formatUSDC(value?.toString() || '0')}
                    />
                  </Col>
@@ -538,7 +538,7 @@ const AddModal: React.FC<AddModalProps> = ({
                      value={parseFloat(leaderAssetInfo.position)}
                      precision={4}
                      valueStyle={{ color: '#722ed1', fontSize: '14px' }}
-                      suffix="USDC"
+                      prefix="$"
                      formatter={(value) => formatUSDC(value?.toString() || '0')}
                    />
                  </Col>
@@ -606,7 +606,7 @@ const AddModal: React.FC<AddModalProps> = ({
          
          {copyMode === 'FIXED' && (
            <Form.Item
-              label={t('copyTradingAdd.fixedAmount') || '固定跟单金额 (USDC)'}
+              label={t('copyTradingAdd.fixedAmount') || '固定跟单金额 ($)'}
              name="fixedAmount"
              rules={[
                { required: true, message: t('copyTradingAdd.fixedAmountRequired') || '请输入固定跟单金额' },
@@ -645,7 +645,7 @@ const AddModal: React.FC<AddModalProps> = ({
          {copyMode === 'RATIO' && (
            <>
              <Form.Item
-                label={t('copyTradingAdd.maxOrderSize') || '单笔订单最大金额 (USDC)'}
+                label={t('copyTradingAdd.maxOrderSize') || '单笔订单最大金额 ($)'}
                name="maxOrderSize"
                tooltip={t('copyTradingAdd.maxOrderSizeTooltip') || '比例模式下，限制单笔跟单订单的最大金额上限'}
              >
@@ -665,7 +665,7 @@ const AddModal: React.FC<AddModalProps> = ({
              </Form.Item>
              
              <Form.Item
-                label={t('copyTradingAdd.minOrderSize') || '单笔订单最小金额 (USDC)'}
+                label={t('copyTradingAdd.minOrderSize') || '单笔订单最小金额 ($)'}
                name="minOrderSize"
                tooltip={t('copyTradingAdd.minOrderSizeTooltip') || '比例模式下，限制单笔跟单订单的最小金额下限，必须 >= 1'}
                rules={[
@@ -700,7 +700,7 @@ const AddModal: React.FC<AddModalProps> = ({
          )}
          
          <Form.Item
-            label={t('copyTradingAdd.maxDailyLoss') || '每日最大亏损限制 (USDC)'}
+            label={t('copyTradingAdd.maxDailyLoss') || '每日最大亏损限制 ($)'}
            name="maxDailyLoss"
            tooltip={t('copyTradingAdd.maxDailyLossTooltip') || '限制每日最大亏损金额，用于风险控制'}
          >
@@ -709,7 +709,7 @@ const AddModal: React.FC<AddModalProps> = ({
              step={0.0001}
              precision={4}
              style={{ width: '100%' }}
-              placeholder={t('copyTradingAdd.maxDailyLossPlaceholder') || '默认 10000 USDC（可选）'}
+              placeholder={t('copyTradingAdd.maxDailyLossPlaceholder') || '默认 10000 $（可选）'}
              formatter={(value) => {
                if (!value && value !== 0) return ''
                const num = parseFloat(value.toString())
@@ -767,7 +767,7 @@ const AddModal: React.FC<AddModalProps> = ({
          </Form.Item>
          
          <Form.Item
-            label={t('copyTradingAdd.minOrderDepth') || '最小订单深度 (USDC)'}
+            label={t('copyTradingAdd.minOrderDepth') || '最小订单深度 ($)'}
            name="minOrderDepth"
            tooltip={t('copyTradingAdd.minOrderDepthTooltip') || '检查订单簿的总订单金额（买盘+卖盘），确保市场有足够的流动性。不填写则不启用此过滤'}
          >
@@ -853,7 +853,7 @@ const AddModal: React.FC<AddModalProps> = ({
          <Divider>{t('copyTradingAdd.positionLimitFilter') || '最大仓位限制'}</Divider>
          
          <Form.Item
-            label={t('copyTradingAdd.maxPositionValue') || '最大仓位金额 (USDC)'}
+            label={t('copyTradingAdd.maxPositionValue') || '最大仓位金额 ($)'}
            name="maxPositionValue"
            tooltip={t('copyTradingAdd.maxPositionValueTooltip') || '限制单个市场的最大仓位金额。如果该市场的当前仓位金额 + 跟单金额超过此限制，则不会下单。不填写则不启用此限制'}
          >
@@ -1082,7 +1082,7 @@ const AddModal: React.FC<AddModalProps> = ({
                <span>
                  {record.copyMode === 'RATIO' 
                    ? `${t('copyTradingAdd.ratioMode') || '比例'} ${record.copyRatio}x`
-                    : `${t('copyTradingAdd.fixedAmountMode') || '固定'} ${formatUSDC(record.fixedAmount || '0')} USDC`
+                    : `${t('copyTradingAdd.fixedAmountMode') || '固定'} $${formatUSDC(record.fixedAmount || '0')}`
                  }
                </span>
              )
@@ -261,7 +261,7 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId, active = fal
        const amount = (parseFloat(record.quantity) * parseFloat(record.price)).toString()
        return (
          <span style={{ fontSize: isMobile ? 12 : 14 }}>
-            {isMobile ? formatUSDC(amount) : `${formatUSDC(amount)} USDC`}
+            {isMobile ? formatUSDC(amount) : `$${formatUSDC(amount)}`}
          </span>
        )
      }
@@ -384,7 +384,7 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId, active = fal
                  </div>
                  <div style={{ display: 'flex', gap: '16px', flexWrap: 'wrap', fontSize: isMobile ? '12px' : '13px', color: '#666' }}>
                    <span>{t('copyTradingOrders.orderCount') || '订单数'}: {group.stats.count}</span>
-                    <span>{t('copyTradingOrders.totalAmount') || '总金额'}: {formatUSDC(group.stats.totalAmount)} USDC</span>
+                    <span>{t('copyTradingOrders.totalAmount') || '总金额'}: ${formatUSDC(group.stats.totalAmount)}</span>
                    <span>
                      {t('copyTradingOrders.statusBreakdown') || '状态'}:
                      {group.stats.fullyMatchedCount > 0 && ` ${t('copyTradingOrders.allFullySold') || '全部卖出'} ${group.stats.fullyMatchedCount}`}
@@ -460,7 +460,7 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId, active = fal

                            <div style={{ fontSize: '12px', color: '#666' }}>
                              <div>{t('copyTradingOrders.quantity') || '数量'}: {formatUSDC(order.quantity)} | {t('copyTradingOrders.price') || '价格'}: {formatUSDC(order.price)}</div>
-                              <div>{t('copyTradingOrders.amount') || '金额'}: {formatUSDC(amount)} USDC</div>
+                              <div>{t('copyTradingOrders.amount') || '金额'}: ${formatUSDC(amount)}</div>
                              <div>{t('copyTradingOrders.matched') || '已匹配'}: {formatUSDC(order.matchedQuantity)} | {t('copyTradingOrders.remaining') || '剩余'}: {formatUSDC(order.remainingQuantity)}</div>
                              <div style={{ color: '#999', marginTop: '4px' }}>{formattedDate}</div>
                            </div>
@@ -557,7 +557,7 @@ const BuyOrdersTab: React.FC<BuyOrdersTabProps> = ({ copyTradingId, active = fal
                        {t('copyTradingOrders.quantity') || '数量'}: {formatUSDC(order.quantity)} | {t('copyTradingOrders.price') || '价格'}: {formatUSDC(order.price)}
                      </div>
                      <div style={{ fontSize: '14px', fontWeight: '500', marginTop: '4px' }}>
-                        {t('copyTradingOrders.amount') || '金额'}: {formatUSDC(amount)} USDC
+                        {t('copyTradingOrders.amount') || '金额'}: ${formatUSDC(amount)}
                      </div>
                    </div>

@@ -356,7 +356,7 @@ const EditModal: React.FC<EditModalProps> = ({
                    value={parseFloat(leaderAssetInfo.total)}
                    precision={4}
                    valueStyle={{ color: '#52c41a', fontWeight: 'bold', fontSize: '16px' }}
-                    suffix="USDC"
+                    prefix="$"
                    formatter={(value) => formatUSDC(value?.toString() || '0')}
                  />
                </Col>
@@ -366,7 +366,7 @@ const EditModal: React.FC<EditModalProps> = ({
                    value={parseFloat(leaderAssetInfo.available)}
                    precision={4}
                    valueStyle={{ color: '#1890ff', fontSize: '14px' }}
-                    suffix="USDC"
+                    prefix="$"
                    formatter={(value) => formatUSDC(value?.toString() || '0')}
                  />
                </Col>
@@ -376,7 +376,7 @@ const EditModal: React.FC<EditModalProps> = ({
                    value={parseFloat(leaderAssetInfo.position)}
                    precision={4}
                    valueStyle={{ color: '#722ed1', fontSize: '14px' }}
-                    suffix="USDC"
+                    prefix="$"
                    formatter={(value) => formatUSDC(value?.toString() || '0')}
                  />
                </Col>
@@ -456,7 +456,7 @@ const EditModal: React.FC<EditModalProps> = ({
          
          {copyMode === 'FIXED' && (
            <Form.Item
-              label={t('copyTradingEdit.fixedAmount') || '固定跟单金额 (USDC)'}
+              label={t('copyTradingEdit.fixedAmount') || '固定跟单金额 ($)'}
              name="fixedAmount"
              rules={[
                { required: true, message: t('copyTradingEdit.fixedAmountRequired') || '请输入固定跟单金额' },
@@ -495,7 +495,7 @@ const EditModal: React.FC<EditModalProps> = ({
          {copyMode === 'RATIO' && (
            <>
              <Form.Item
-                label={t('copyTradingEdit.maxOrderSize') || '单笔订单最大金额 (USDC)'}
+                label={t('copyTradingEdit.maxOrderSize') || '单笔订单最大金额 ($)'}
                name="maxOrderSize"
                tooltip={t('copyTradingEdit.maxOrderSizeTooltip') || '比例模式下，限制单笔跟单订单的最大金额上限'}
              >
@@ -515,7 +515,7 @@ const EditModal: React.FC<EditModalProps> = ({
              </Form.Item>
              
              <Form.Item
-                label={t('copyTradingEdit.minOrderSize') || '单笔订单最小金额 (USDC)'}
+                label={t('copyTradingEdit.minOrderSize') || '单笔订单最小金额 ($)'}
                name="minOrderSize"
                tooltip={t('copyTradingEdit.minOrderSizeTooltip') || '比例模式下，限制单笔跟单订单的最小金额下限，必须 >= 1'}
                rules={[
@@ -550,7 +550,7 @@ const EditModal: React.FC<EditModalProps> = ({
          )}
          
          <Form.Item
-            label={t('copyTradingEdit.maxDailyLoss') || '每日最大亏损限制 (USDC)'}
+            label={t('copyTradingEdit.maxDailyLoss') || '每日最大亏损限制 ($)'}
            name="maxDailyLoss"
            tooltip={t('copyTradingEdit.maxDailyLossTooltip') || '限制每日最大亏损金额，用于风险控制'}
          >
@@ -559,7 +559,7 @@ const EditModal: React.FC<EditModalProps> = ({
              step={0.0001}
              precision={4}
              style={{ width: '100%' }}
-              placeholder={t('copyTradingEdit.maxDailyLossPlaceholder') || '默认 10000 USDC（可选）'}
+              placeholder={t('copyTradingEdit.maxDailyLossPlaceholder') || '默认 10000 $（可选）'}
              formatter={(value) => {
                if (!value && value !== 0) return ''
                const num = parseFloat(value.toString())
@@ -617,7 +617,7 @@ const EditModal: React.FC<EditModalProps> = ({
          </Form.Item>
   
          <Form.Item
-            label={t('copyTradingEdit.minOrderDepth') || '最小订单深度 (USDC)'}
+            label={t('copyTradingEdit.minOrderDepth') || '最小订单深度 ($)'}
            name="minOrderDepth"
            tooltip={t('copyTradingEdit.minOrderDepthTooltip') || '检查订单簿的总订单金额（买盘+卖盘），确保市场有足够的流动性。不填写则不启用此过滤'}
          >
@@ -703,7 +703,7 @@ const EditModal: React.FC<EditModalProps> = ({
          <Divider>{t('copyTradingEdit.positionLimitFilter') || '最大仓位限制'}</Divider>
          
          <Form.Item
-            label={t('copyTradingEdit.maxPositionValue') || '最大仓位金额 (USDC)'}
+            label={t('copyTradingEdit.maxPositionValue') || '最大仓位金额 ($)'}
            name="maxPositionValue"
            tooltip={t('copyTradingEdit.maxPositionValueTooltip') || '限制单个市场的最大仓位金额。如果该市场的当前仓位金额 + 跟单金额超过此限制，则不会下单。不填写则不启用此限制'}
          >
@@ -228,7 +228,7 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId, acti
          fontWeight: 500,
          fontSize: isMobile ? 12 : 14
        }}>
-          {isMobile ? formatUSDC(value) : `${formatUSDC(value)} USDC`}
+          {isMobile ? formatUSDC(value) : `$${formatUSDC(value)}`}
        </span>
      )
    },
@@ -408,7 +408,7 @@ const MatchedOrdersTab: React.FC<MatchedOrdersTabProps> = ({ copyTradingId, acti
                        fontWeight: 'bold',
                        color: getPnlColor(order.realizedPnl)
                      }}>
-                        {formatUSDC(order.realizedPnl)} USDC
+                        ${formatUSDC(order.realizedPnl)}
                      </div>
                    </div>

@@ -258,7 +258,7 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId, active = f
        const amount = (parseFloat(record.quantity) * parseFloat(record.price)).toString()
        return (
          <span style={{ fontSize: isMobile ? 12 : 14 }}>
-            {isMobile ? formatUSDC(amount) : `${formatUSDC(amount)} USDC`}
+            {isMobile ? formatUSDC(amount) : `$${formatUSDC(amount)}`}
          </span>
        )
      }
@@ -274,7 +274,7 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId, active = f
          fontWeight: 500,
          fontSize: isMobile ? 12 : 14
        }}>
-          {isMobile ? formatUSDC(value) : `${formatUSDC(value)} USDC`}
+          {isMobile ? formatUSDC(value) : `$${formatUSDC(value)}`}
        </span>
      )
    },
@@ -362,10 +362,10 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId, active = f
                  </div>
                  <div style={{ display: 'flex', gap: '16px', flexWrap: 'wrap', fontSize: isMobile ? '12px' : '13px', color: '#666' }}>
                    <span>{t('copyTradingOrders.orderCount') || '订单数'}: {group.stats.count}</span>
-                    <span>{t('copyTradingOrders.totalAmount') || '总金额'}: {formatUSDC(group.stats.totalAmount)} USDC</span>
+                    <span>{t('copyTradingOrders.totalAmount') || '总金额'}: ${formatUSDC(group.stats.totalAmount)}</span>
                    {group.stats.totalPnl && (
                      <span style={{ color: pnlColor, fontWeight: 500 }}>
-                        {t('copyTradingOrders.totalPnl') || '总盈亏'}: {formatUSDC(group.stats.totalPnl)} USDC
+                        {t('copyTradingOrders.totalPnl') || '总盈亏'}: ${formatUSDC(group.stats.totalPnl)}
                      </span>
                    )}
                  </div>
@@ -434,9 +434,9 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId, active = f

                            <div style={{ fontSize: '12px', color: '#666' }}>
                              <div>{t('copyTradingOrders.quantity') || '数量'}: {formatUSDC(order.quantity)} | {t('copyTradingOrders.price') || '价格'}: {formatUSDC(order.price)}</div>
-                              <div>{t('copyTradingOrders.amount') || '金额'}: {formatUSDC(amount)} USDC</div>
+                              <div>{t('copyTradingOrders.amount') || '金额'}: ${formatUSDC(amount)}</div>
                              <div style={{ color: getPnlColor(order.realizedPnl), fontWeight: 500 }}>
-                                {t('copyTradingOrders.realizedPnl') || '已实现盈亏'}: {formatUSDC(order.realizedPnl)} USDC
+                                {t('copyTradingOrders.realizedPnl') || '已实现盈亏'}: ${formatUSDC(order.realizedPnl)}
                              </div>
                              <div style={{ color: '#999', marginTop: '4px' }}>{formattedDate}</div>
                            </div>
@@ -530,7 +530,7 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId, active = f
                        {t('copyTradingOrders.quantity') || '数量'}: {formatUSDC(order.quantity)} | {t('copyTradingOrders.price') || '价格'}: {formatUSDC(order.price)}
                      </div>
                      <div style={{ fontSize: '14px', fontWeight: '500', marginTop: '4px' }}>
-                        {t('copyTradingOrders.amount') || '金额'}: {formatUSDC(amount)} USDC
+                        {t('copyTradingOrders.amount') || '金额'}: ${formatUSDC(amount)}
                      </div>
                    </div>

@@ -541,7 +541,7 @@ const SellOrdersTab: React.FC<SellOrdersTabProps> = ({ copyTradingId, active = f
                        fontWeight: 'bold',
                        color: getPnlColor(order.realizedPnl)
                      }}>
-                        {formatUSDC(order.realizedPnl)} USDC
+                        ${formatUSDC(order.realizedPnl)}
                      </div>
                    </div>

@@ -104,7 +104,7 @@ const StatisticsModal: React.FC<StatisticsModalProps> = ({
            </div>
            <div style={{ fontSize: '16px', fontWeight: '500', color: '#333', flex: '1', textAlign: 'right', display: 'flex', alignItems: 'center', justifyContent: 'flex-end', gap: '4px' }}>
              <ArrowUpOutlined style={{ color: '#1890ff', fontSize: '14px' }} />
-              <span style={{ fontSize: 'clamp(12px, 4vw, 16px)' }}>{formatUSDC(statistics.totalBuyAmount)} USDC</span>
+              <span style={{ fontSize: 'clamp(12px, 4vw, 16px)' }}>${formatUSDC(statistics.totalBuyAmount)}</span>
            </div>
          </div>
          <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', padding: '12px', borderBottom: '1px solid #f0f0f0' }}>
@@ -113,7 +113,7 @@ const StatisticsModal: React.FC<StatisticsModalProps> = ({
            </div>
            <div style={{ fontSize: '16px', fontWeight: '500', color: '#333', flex: '1', textAlign: 'right', display: 'flex', alignItems: 'center', justifyContent: 'flex-end', gap: '4px' }}>
              <ArrowDownOutlined style={{ color: '#ff4d4f', fontSize: '14px' }} />
-              <span style={{ fontSize: 'clamp(12px, 4vw, 16px)' }}>{formatUSDC(statistics.totalSellAmount)} USDC</span>
+              <span style={{ fontSize: 'clamp(12px, 4vw, 16px)' }}>${formatUSDC(statistics.totalSellAmount)}</span>
            </div>
          </div>
          <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', padding: '12px', borderBottom: '1px solid #f0f0f0' }}>
@@ -122,7 +122,7 @@ const StatisticsModal: React.FC<StatisticsModalProps> = ({
            </div>
            <div style={{ fontSize: '16px', fontWeight: 'bold', color: getPnlColor(statistics.totalPnl), flex: '1', textAlign: 'right', display: 'flex', alignItems: 'center', justifyContent: 'flex-end', gap: '4px' }}>
              {getPnlIcon(statistics.totalPnl)}
-              <span style={{ fontSize: 'clamp(12px, 4vw, 16px)' }}>{formatUSDC(statistics.totalPnl)} USDC</span>
+              <span style={{ fontSize: 'clamp(12px, 4vw, 16px)' }}>${formatUSDC(statistics.totalPnl)}</span>
            </div>
          </div>
          <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', padding: '12px', borderBottom: '1px solid #f0f0f0' }}>
@@ -131,7 +131,7 @@ const StatisticsModal: React.FC<StatisticsModalProps> = ({
            </div>
            <div style={{ fontSize: '16px', fontWeight: '500', color: getPnlColor(statistics.totalRealizedPnl), flex: '1', textAlign: 'right', display: 'flex', alignItems: 'center', justifyContent: 'flex-end', gap: '4px' }}>
              {getPnlIcon(statistics.totalRealizedPnl)}
-              <span style={{ fontSize: 'clamp(12px, 4vw, 16px)' }}>{formatUSDC(statistics.totalRealizedPnl)} USDC</span>
+              <span style={{ fontSize: 'clamp(12px, 4vw, 16px)' }}>${formatUSDC(statistics.totalRealizedPnl)}</span>
            </div>
          </div>
          <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', padding: '12px', borderBottom: '1px solid #f0f0f0' }}>
@@ -140,7 +140,7 @@ const StatisticsModal: React.FC<StatisticsModalProps> = ({
            </div>
            <div style={{ fontSize: '16px', fontWeight: '500', color: getPnlColor(statistics.totalUnrealizedPnl), flex: '1', textAlign: 'right', display: 'flex', alignItems: 'center', justifyContent: 'flex-end', gap: '4px' }}>
              {getPnlIcon(statistics.totalUnrealizedPnl)}
-              <span style={{ fontSize: 'clamp(12px, 4vw, 16px)' }}>{formatUSDC(statistics.totalUnrealizedPnl)} USDC</span>
+              <span style={{ fontSize: 'clamp(12px, 4vw, 16px)' }}>${formatUSDC(statistics.totalUnrealizedPnl)}</span>
            </div>
          </div>
        </div>
@@ -165,43 +165,38 @@ const StatisticsModal: React.FC<StatisticsModalProps> = ({
              <Statistic
                title={t('copyTradingOrders.totalBuyAmount') || '总买入金额'}
                value={formatUSDC(statistics.totalBuyAmount)}
-                suffix="USDC"
-                prefix={<ArrowUpOutlined style={{ color: '#1890ff' }} />}
+                prefix={<><ArrowUpOutlined style={{ color: '#1890ff' }} /> $</>}
              />
            </Col>
            <Col xs={24} sm={12} md={8}>
              <Statistic
                title={t('copyTradingOrders.totalSellAmount') || '总卖出金额'}
                value={formatUSDC(statistics.totalSellAmount)}
-                suffix="USDC"
-                prefix={<ArrowDownOutlined style={{ color: '#ff4d4f' }} />}
+                prefix={<><ArrowDownOutlined style={{ color: '#ff4d4f' }} /> $</>}
              />
            </Col>
            <Col xs={24} sm={12} md={8}>
              <Statistic
                title={t('copyTradingOrders.totalPnl') || '总盈亏'}
                value={formatUSDC(statistics.totalPnl)}
-                suffix="USDC"
                valueStyle={{ color: getPnlColor(statistics.totalPnl) }}
-                prefix={getPnlIcon(statistics.totalPnl)}
+                prefix={<>{getPnlIcon(statistics.totalPnl)} $</>}
              />
            </Col>
            <Col xs={24} sm={12} md={8}>
              <Statistic
                title={t('copyTradingOrders.totalRealizedPnl') || '总已实现盈亏'}
                value={formatUSDC(statistics.totalRealizedPnl)}
-                suffix="USDC"
                valueStyle={{ color: getPnlColor(statistics.totalRealizedPnl) }}
-                prefix={getPnlIcon(statistics.totalRealizedPnl)}
+                prefix={<>{getPnlIcon(statistics.totalRealizedPnl)} $</>}
              />
            </Col>
            <Col xs={24} sm={12} md={8}>
              <Statistic
                title={t('copyTradingOrders.totalUnrealizedPnl') || '总未实现盈亏'}
                value={formatUSDC(statistics.totalUnrealizedPnl)}
-                suffix="USDC"
                valueStyle={{ color: getPnlColor(statistics.totalUnrealizedPnl) }}
-                prefix={getPnlIcon(statistics.totalUnrealizedPnl)}
+                prefix={<>{getPnlIcon(statistics.totalUnrealizedPnl)} $</>}
              />
            </Col>
          </Row>
@@ -145,7 +145,7 @@ const CopyTradingSellOrdersPage: React.FC = () => {
        const amount = (parseFloat(record.quantity) * parseFloat(record.price)).toString()
        return (
          <span style={{ fontSize: isMobile ? 12 : 14 }}>
-            {isMobile ? formatUSDC(amount) : `${formatUSDC(amount)} USDC`}
+            {isMobile ? formatUSDC(amount) : `$${formatUSDC(amount)}`}
          </span>
        )
      }
@@ -161,7 +161,7 @@ const CopyTradingSellOrdersPage: React.FC = () => {
          fontWeight: 500,
          fontSize: isMobile ? 12 : 14
        }}>
-          {isMobile ? formatUSDC(value) : `${formatUSDC(value)} USDC`}
+          {isMobile ? formatUSDC(value) : `$${formatUSDC(value)}`}
        </span>
      )
    },
@@ -277,7 +277,7 @@ const CopyTradingSellOrdersPage: React.FC = () => {
                          数量: {formatUSDC(order.quantity)} | 价格: {formatUSDC(order.price)}
                        </div>
                        <div style={{ fontSize: '14px', fontWeight: '500', marginTop: '4px' }}>
-                          金额: {formatUSDC(amount)} USDC
+                          金额: ${formatUSDC(amount)}
                        </div>
                      </div>
                      
@@ -289,7 +289,7 @@ const CopyTradingSellOrdersPage: React.FC = () => {
                          fontWeight: 'bold',
                          color: getPnlColor(order.realizedPnl)
                        }}>
-                          {formatUSDC(order.realizedPnl)} USDC
+                          ${formatUSDC(order.realizedPnl)}
                        </div>
                      </div>
                      
@@ -145,7 +145,7 @@ const CopyTradingStatisticsPage: React.FC = () => {
            <Statistic
              title="总买入金额"
              value={formatUSDC(statistics.totalBuyAmount)}
-              suffix="USDC"
+              prefix="$"
            />
          </Col>
          <Col xs={24} sm={12} md={6}>
@@ -179,7 +179,7 @@ const CopyTradingStatisticsPage: React.FC = () => {
            <Statistic
              title="总卖出金额"
              value={formatUSDC(statistics.totalSellAmount)}
-              suffix="USDC"
+              prefix="$"
            />
          </Col>
          <Col xs={24} sm={12} md={8}>
@@ -220,8 +220,7 @@ const CopyTradingStatisticsPage: React.FC = () => {
              title="总已实现盈亏"
              value={formatUSDC(statistics.totalRealizedPnl)}
              valueStyle={{ color: getPnlColor(statistics.totalRealizedPnl) }}
-              prefix={getPnlIcon(statistics.totalRealizedPnl)}
-              suffix="USDC"
+              prefix={<>{getPnlIcon(statistics.totalRealizedPnl)} $</>}
            />
          </Col>
          <Col xs={24} sm={12} md={6}>
@@ -229,8 +228,7 @@ const CopyTradingStatisticsPage: React.FC = () => {
              title="总未实现盈亏"
              value={formatUSDC(statistics.totalUnrealizedPnl)}
              valueStyle={{ color: getPnlColor(statistics.totalUnrealizedPnl) }}
-              prefix={getPnlIcon(statistics.totalUnrealizedPnl)}
-              suffix="USDC"
+              prefix={<>{getPnlIcon(statistics.totalUnrealizedPnl)} $</>}
            />
          </Col>
          <Col xs={24} sm={12} md={6}>
@@ -238,8 +236,7 @@ const CopyTradingStatisticsPage: React.FC = () => {
              title="总盈亏"
              value={formatUSDC(statistics.totalPnl)}
              valueStyle={{ color: getPnlColor(statistics.totalPnl) }}
-              prefix={getPnlIcon(statistics.totalPnl)}
-              suffix="USDC"
+              prefix={<>{getPnlIcon(statistics.totalPnl)} $</>}
            />
          </Col>
          <Col xs={24} sm={12} md={6}>
@@ -12,9 +12,13 @@ import {
  Alert,
  Radio,
  Button,
-  Tooltip
+  Tooltip,
+  Modal,
+  InputNumber,
+  message
 } from 'antd'
-import { ClockCircleOutlined, SyncOutlined, InfoCircleOutlined } from '@ant-design/icons'
+import { Popup as AntdMobilePopup } from 'antd-mobile'
+import { ClockCircleOutlined, SyncOutlined, InfoCircleOutlined, ShoppingCartOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import { useMediaQuery } from 'react-responsive'
 import * as echarts from 'echarts'
@@ -30,6 +34,10 @@ import type {

 const { Title, Text } = Typography

+// localStorage keys
+const PERIOD_SWITCH_MODE_KEY = 'cryptoTailMonitor_periodSwitchMode'
+const SELECTED_STRATEGY_ID_KEY = 'cryptoTailMonitor_selectedStrategyId'
+
 /** 分时图数据点：时间戳、BTC 价格 USDC、市场 Up/Down 价格 0-1 */
 interface PriceDataPoint {
  time: number
@@ -46,8 +54,11 @@ const CryptoTailMonitor: React.FC = () => {
  const [strategies, setStrategies] = useState<CryptoTailStrategyDto[]>([])
  const [strategiesLoading, setStrategiesLoading] = useState(false)

-  // 选中的策略
-  const [selectedStrategyId, setSelectedStrategyId] = useState<number | null>(null)
+  // 选中的策略（从 localStorage 恢复）
+  const [selectedStrategyId, setSelectedStrategyId] = useState<number | null>(() => {
+    const cached = localStorage.getItem(SELECTED_STRATEGY_ID_KEY)
+    return cached != null ? parseInt(cached, 10) : null
+  })

  // 监控数据
  const [initData, setInitData] = useState<CryptoTailMonitorInitResponse | null>(null)
@@ -61,9 +72,10 @@ const CryptoTailMonitor: React.FC = () => {
  const marketChartRef = useRef<HTMLDivElement>(null)
  const marketChartInstance = useRef<echarts.ECharts | null>(null)
  const lastPeriodStartRef = useRef<number | null>(null)
-
-  // localStorage key for period switch mode
-  const PERIOD_SWITCH_MODE_KEY = 'cryptoTailMonitor_periodSwitchMode'
+  const selectedStrategyIdRef = useRef<number | null>(null)
+  useEffect(() => {
+    selectedStrategyIdRef.current = selectedStrategyId
+  }, [selectedStrategyId])

  // 记录首次数据进入时间（用于中途进入时的横轴起点）
  const [firstDataTime, setFirstDataTime] = useState<number | null>(null)
@@ -84,6 +96,38 @@ const CryptoTailMonitor: React.FC = () => {
  // 标记当前是否在查看旧周期（手动模式下）
  const [isViewingOldPeriod, setIsViewingOldPeriod] = useState<boolean>(false)

+  // 手动下单状态
+  const [manualOrderModal, setManualOrderModal] = useState<{
+    visible: boolean
+    direction: 'UP' | 'DOWN'
+    price: string
+    size: string
+    totalAmount: string
+    bestBid: string
+    availableBalance: string
+    periodStartUnix: number | null
+  }>({
+    visible: false,
+    direction: 'UP',
+    price: '',
+    size: '',
+    totalAmount: '',
+    bestBid: '',
+    availableBalance: '',
+    periodStartUnix: null
+  })
+  const [ordering, setOrdering] = useState(false)
+
+  // 检测周期切换，关闭弹窗并提示用户
+  useEffect(() => {
+    if (manualOrderModal.visible && manualOrderModal.periodStartUnix != null && pushData) {
+      if (pushData.periodStartUnix !== manualOrderModal.periodStartUnix) {
+        message.warning(t('cryptoTailMonitor.manualOrder.periodChanged'))
+        handleCloseManualOrderModal()
+      }
+    }
+  }, [pushData?.periodStartUnix, manualOrderModal.visible, manualOrderModal.periodStartUnix])
+
  // 获取策略列表
  useEffect(() => {
    const fetchStrategies = async () => {
@@ -91,10 +135,18 @@ const CryptoTailMonitor: React.FC = () => {
      try {
        const res = await apiService.cryptoTailStrategy.list({ enabled: true })
        if (res.data.code === 0 && res.data.data) {
-          setStrategies(res.data.data.list ?? [])
-          // 自动选择第一个策略
-          if (res.data.data.list?.length > 0 && !selectedStrategyId) {
-            setSelectedStrategyId(res.data.data.list[0].id)
+          const strategyList = res.data.data.list ?? []
+          setStrategies(strategyList)
+          // 从 localStorage 恢复选中的策略
+          const cachedId = localStorage.getItem(SELECTED_STRATEGY_ID_KEY)
+          const cachedStrategyId = cachedId != null ? parseInt(cachedId, 10) : null
+          // 检查缓存的策略是否在列表中
+          const isValidCached = cachedStrategyId != null && strategyList.some(s => s.id === cachedStrategyId)
+          if (isValidCached) {
+            setSelectedStrategyId(cachedStrategyId)
+          } else if (strategyList.length > 0) {
+            // 自动选择第一个策略
+            setSelectedStrategyId(strategyList[0].id)
          }
        }
      } catch (e) {
@@ -106,6 +158,13 @@ const CryptoTailMonitor: React.FC = () => {
    fetchStrategies()
  }, [])

+  // 保存选中的策略到 localStorage
+  useEffect(() => {
+    if (selectedStrategyId != null) {
+      localStorage.setItem(SELECTED_STRATEGY_ID_KEY, String(selectedStrategyId))
+    }
+  }, [selectedStrategyId])
+
  // 初始化监控数据
  useEffect(() => {
    if (!selectedStrategyId) {
@@ -127,7 +186,7 @@ const CryptoTailMonitor: React.FC = () => {
      setPendingPeriodData(null)
      setIsViewingOldPeriod(false)
      try {
-        const res = await apiService.cryptoTailStrategy.monitorInit(selectedStrategyId)
+        const res = await apiService.cryptoTailStrategy.monitorInit({ strategyId: selectedStrategyId })
        if (res.data.code === 0 && res.data.data) {
          setInitData(res.data.data)
        } else {
@@ -172,11 +231,23 @@ const CryptoTailMonitor: React.FC = () => {
    const lastPeriod = lastPeriodStartRef.current

    if (pushPeriod != null && pushPeriod !== lastPeriod) {
-      // 新周期到来
+      // 新周期到来：重新拉取 init（含 tokenIds），再更新状态
      lastPeriodStartRef.current = pushPeriod
-
+      const marketTitle = (data as { marketTitle?: string }).marketTitle
+      const applyFreshInit = (fresh: CryptoTailMonitorInitResponse) => {
+        if (selectedStrategyIdRef.current !== fresh.strategyId) return
+        const merged: CryptoTailMonitorInitResponse = {
+          ...fresh,
+          periodStartUnix: pushPeriod,
+          marketTitle: marketTitle ?? fresh.marketTitle ?? ''
+        }
+        if (periodSwitchMode === 'manual' && lastPeriod != null) {
+          setPendingPeriodData(p => p ? { ...p, initData: merged } : null)
+        } else {
+          setInitData(merged)
+        }
+      }
      if (periodSwitchMode === 'manual' && lastPeriod != null) {
-        // 手动模式：保存新周期数据到 pending，保留当前显示
        setPendingPeriodData({
          periodStartUnix: pushPeriod,
          priceHistory: [newPoint],
@@ -184,26 +255,35 @@ const CryptoTailMonitor: React.FC = () => {
          pushData: data
        })
        setIsViewingOldPeriod(true)
-        // 更新 pending 数据的 initData
-        setInitData(prev => {
-          if (prev) {
-            setPendingPeriodData(p => p ? { ...p, initData: { ...prev, periodStartUnix: pushPeriod, marketTitle: (data as { marketTitle?: string }).marketTitle ?? prev.marketTitle } } : null)
+        apiService.cryptoTailStrategy.monitorInit({ strategyId: selectedStrategyId!, periodStartUnix: pushPeriod }).then(res => {
+          if (res.data?.code === 0 && res.data?.data) applyFreshInit(res.data.data)
+          else {
+            setInitData(prev => {
+              if (prev) setPendingPeriodData(p => p ? { ...p, initData: { ...prev, periodStartUnix: pushPeriod, marketTitle: marketTitle ?? prev.marketTitle ?? '' } } : null)
+              return prev ?? null
+            })
          }
-          return prev
+        }).catch(() => {
+          setInitData(prev => {
+            if (prev) setPendingPeriodData(p => p ? { ...p, initData: { ...prev, periodStartUnix: pushPeriod, marketTitle: marketTitle ?? prev.marketTitle ?? '' } } : null)
+            return prev ?? null
+          })
        })
      } else {
-        // 自动模式或首次推送：直接切换
-        if (lastPeriod != null) {
-          setHasSwitchedPeriod(true)
-        }
+        if (lastPeriod != null) setHasSwitchedPeriod(true)
        setFirstDataTime(newPoint.time)
-        setInitData(prev => prev ? { ...prev, periodStartUnix: pushPeriod, marketTitle: (data as { marketTitle?: string }).marketTitle ?? prev.marketTitle } : null)
        setPriceHistory([newPoint])
        setPushData(data)
        setIsViewingOldPeriod(false)
        setPendingPeriodData(null)
-        return
+        apiService.cryptoTailStrategy.monitorInit({ strategyId: selectedStrategyId!, periodStartUnix: pushPeriod }).then(res => {
+          if (res.data?.code === 0 && res.data?.data) applyFreshInit(res.data.data)
+          else setInitData(prev => prev ? { ...prev, periodStartUnix: pushPeriod, marketTitle: marketTitle ?? prev.marketTitle ?? '' } : null)
+        }).catch(() => {
+          setInitData(prev => prev ? { ...prev, periodStartUnix: pushPeriod, marketTitle: marketTitle ?? prev.marketTitle ?? '' } : null)
+        })
      }
+      return
    } else {
      // 同周期：追加数据
      if (periodSwitchMode === 'manual' && isViewingOldPeriod && pendingPeriodData) {
@@ -413,7 +493,7 @@ const CryptoTailMonitor: React.FC = () => {
          } else {
            timeStr = '--'
          }
-          return `<span style="font-size:12px">${timeStr} &nbsp; ${Number(val).toFixed(2)} USDC</span>`
+          return `<span style="font-size:12px">${timeStr} &nbsp; $${Number(val).toFixed(2)}</span>`
        }
      },
      legend: {
@@ -709,6 +789,188 @@ const CryptoTailMonitor: React.FC = () => {
  const spreadBelowThreshold = currentSpread != null && currentSpread !== '' && minSpreadLineNum.length > 0 &&
    parseFloat(currentSpread) < Math.min(...minSpreadLineNum)

+  // 手动下单：打开弹窗
+  const handleOpenManualOrderModal = async (direction: 'UP' | 'DOWN') => {
+    if (!pushData) {
+      message.warning(t('cryptoTailMonitor.manualOrder.priceNotLoaded'))
+      return
+    }
+    const bestBid = direction === 'UP' ? pushData.currentPriceUp : pushData.currentPriceDown
+    if (!bestBid) {
+      message.warning(t('cryptoTailMonitor.manualOrder.priceNotLoaded'))
+      return
+    }
+    // 计算默认价格：最优 bid × 1.1，限制在 0~0.99 之间
+    const rawPrice = parseFloat(bestBid) * 1.1
+    const defaultPrice = Math.min(0.99, Math.max(0, rawPrice))
+    
+    // 获取账户余额
+    let availableBalance = '0'
+    if (initData?.accountId) {
+      try {
+        const balanceRes = await apiService.accounts.balance({ accountId: initData.accountId })
+        if (balanceRes.data.code === 0 && balanceRes.data.data?.availableBalance) {
+          availableBalance = balanceRes.data.data.availableBalance
+        }
+      } catch (e) {
+        console.error('获取账户余额失败:', e)
+      }
+    }
+    
+    // 使用策略配置的金额
+    let defaultAmountUsdc = 10
+    if (initData?.amountMode === 'FIXED' && initData?.amountValue) {
+      defaultAmountUsdc = parseFloat(initData.amountValue)
+    } else if (initData?.amountMode === 'RATIO' && initData?.amountValue) {
+      // RATIO 模式：按比例计算
+      const balanceNum = parseFloat(availableBalance)
+      const ratio = parseFloat(initData.amountValue || '10')
+      defaultAmountUsdc = balanceNum * ratio / 100
+      // 至少保留 1 USDC
+      if (defaultAmountUsdc < 1) {
+        message.warning(t('cryptoTailMonitor.manualOrder.insufficientBalance'))
+        return
+      }
+    }
+    
+    // 计算默认数量（保留2位小数，用于手动下单）
+    let defaultSize = (defaultAmountUsdc / defaultPrice).toFixed(2)
+    // 确保至少 1 张
+    if (parseFloat(defaultSize) < 1) {
+      defaultSize = '1.00'
+    }
+    
+    // 重新计算总金额（基于实际数量）
+    const defaultTotalAmount = (defaultPrice * parseFloat(defaultSize)).toFixed(2)
+    
+    setManualOrderModal({
+      visible: true,
+      direction,
+      price: defaultPrice.toFixed(4),
+      size: defaultSize,
+      totalAmount: defaultTotalAmount,
+      bestBid,
+      availableBalance,
+      periodStartUnix: pushData.periodStartUnix
+    })
+  }
+
+  // 获取最新价
+  const handleFetchLatestPrice = async () => {
+    if (!pushData) {
+      message.warning(t('cryptoTailMonitor.manualOrder.priceNotLoaded'))
+      return
+    }
+    const latestPrice = manualOrderModal.direction === 'UP' 
+      ? pushData.currentPriceUp 
+      : pushData.currentPriceDown
+    if (!latestPrice) {
+      message.warning(t('cryptoTailMonitor.manualOrder.priceNotLoaded'))
+      return
+    }
+    const price = Math.min(0.99, parseFloat(latestPrice))
+    const size = parseFloat(manualOrderModal.size)
+    const totalAmount = (price * size).toFixed(2)
+    setManualOrderModal({ 
+      ...manualOrderModal, 
+      price: price.toFixed(4),
+      totalAmount 
+    })
+    message.success(t('cryptoTailMonitor.manualOrder.priceUpdated'))
+  }
+
+  const handleCloseManualOrderModal = () => {
+    setManualOrderModal({
+      visible: false,
+      direction: 'UP',
+      price: '',
+      size: '',
+      totalAmount: '',
+      bestBid: '',
+      availableBalance: '',
+      periodStartUnix: null
+    })
+  }
+
+  const handlePriceChange = (value: number | null) => {
+    if (value === null) return
+    const clamped = Math.min(0.99, Math.max(0, value))
+    const price = clamped.toFixed(4)
+    const size = parseFloat(manualOrderModal.size)
+    const totalAmount = (clamped * size).toFixed(2)
+    setManualOrderModal({ ...manualOrderModal, price, totalAmount })
+  }
+
+  const handleSizeChange = (value: number | null) => {
+    if (value === null) return
+    const size = value.toFixed(2)
+    const priceRaw = parseFloat(manualOrderModal.price)
+    const price = Math.min(0.99, Math.max(0, priceRaw))
+    const totalAmount = (price * value).toFixed(2)
+    setManualOrderModal({ ...manualOrderModal, size, totalAmount, price: price.toFixed(4) })
+  }
+
+  // 计算最大数量（截位处理）
+  const handleMaxSize = () => {
+    const price = parseFloat(manualOrderModal.price)
+    const balance = parseFloat(manualOrderModal.availableBalance)
+    
+    if (price <= 0 || balance <= 0) {
+      message.warning(t('cryptoTailMonitor.manualOrder.invalidPriceOrBalance'))
+      return
+    }
+    
+    // 最大数量 = 余额 / 价格，保留2位小数
+    let maxSize = Math.floor((balance / price) * 100) / 100
+    
+    // 确保至少 1 张
+    if (maxSize < 1) {
+      message.warning(t('cryptoTailMonitor.manualOrder.insufficientBalanceForMax'))
+      return
+    }
+    
+    const totalAmount = (price * maxSize).toFixed(2)
+    setManualOrderModal({ 
+      ...manualOrderModal, 
+      size: maxSize.toFixed(2),
+      totalAmount 
+    })
+    message.success(t('cryptoTailMonitor.manualOrder.maxSizeUpdated'))
+  }
+
+  const handleManualOrder = async () => {
+    if (!initData || !pushData) return
+    try {
+      setOrdering(true)
+      const tokenIds: string[] = []
+      if (initData.tokenIdUp) tokenIds.push(initData.tokenIdUp)
+      if (initData.tokenIdDown) tokenIds.push(initData.tokenIdDown)
+      const request = {
+        strategyId: initData.strategyId,
+        periodStartUnix: pushData.periodStartUnix,
+        direction: manualOrderModal.direction,
+        price: Math.min(0.99, Math.max(0, parseFloat(manualOrderModal.price) || 0)).toFixed(4),
+        size: manualOrderModal.size,
+        marketTitle: pushData.marketTitle || initData.marketTitle,
+        tokenIds
+      }
+      const res = await apiService.cryptoTailStrategy.manualOrder(request)
+      if (res.data.code === 0 && res.data.data?.success) {
+        message.success(t('cryptoTailMonitor.manualOrder.success'))
+        handleCloseManualOrderModal()
+      } else {
+        const reason = res.data.msg?.trim() || 'unknown'
+        message.error(t('cryptoTailMonitor.manualOrder.failed', { reason }))
+      }
+    } catch (error: unknown) {
+      const err = error as { response?: { data?: { msg?: string } }; message?: string }
+      const reason = err?.response?.data?.msg?.trim() ?? err?.message?.trim() ?? 'unknown'
+      message.error(t('cryptoTailMonitor.manualOrder.failed', { reason }))
+    } finally {
+      setOrdering(false)
+    }
+  }
+
  return (
    <div style={{ padding: isMobile ? 12 : 24 }}>
      <Title level={2} style={{ marginBottom: 16, fontSize: isMobile ? 20 : 24 }}>
@@ -717,18 +979,22 @@ const CryptoTailMonitor: React.FC = () => {

      {/* 顶部控制区 */}
      <Card style={{ marginBottom: 16 }}>
-        <Space wrap size="middle">
-          <Space>
+        <Space direction={isMobile ? 'vertical' : 'horizontal'} size="middle" style={{ width: '100%' }}>
+          <Space direction={isMobile ? 'vertical' : 'horizontal'} size="small" style={{ width: isMobile ? '100%' : 'auto' }}>
            <Text strong>{t('cryptoTailMonitor.selectStrategy')}</Text>
            <Select
-              style={{ minWidth: isMobile ? 200 : 300 }}
+              style={{ minWidth: isMobile ? '100%' : 300, width: isMobile ? '100%' : 'auto' }}
              loading={strategiesLoading}
              value={selectedStrategyId}
              onChange={(id) => setSelectedStrategyId(id)}
              placeholder={t('cryptoTailMonitor.selectStrategyPlaceholder')}
+              popupMatchSelectWidth={false}
+              dropdownStyle={{ minWidth: isMobile ? 280 : 'auto', wordWrap: 'break-word', whiteSpace: 'normal' }}
+              optionLabelProp="label"
              options={strategies.map(s => ({
                label: `${s.name || s.marketSlugPrefix} (${s.intervalSeconds === 300 ? '5m' : '15m'})`,
-                value: s.id
+                value: s.id,
+                style: { whiteSpace: 'normal', wordWrap: 'break-word' }
              }))}
            />
          </Space>
@@ -914,29 +1180,63 @@ const CryptoTailMonitor: React.FC = () => {
            />
          </Card>

+          {/* 手动下单 */}
+          {!isMobile ? (
+            <Card title={t('cryptoTailMonitor.manualOrder.title')} style={{ marginTop: 16 }}>
+              <Row gutter={16}>
+                <Col span={12}>
+                  <Button
+                    type="primary"
+                    icon={<ShoppingCartOutlined />}
+                    disabled={!pushData || pushData.triggered || pushData.periodEnded}
+                    onClick={() => handleOpenManualOrderModal('UP')}
+                    loading={ordering}
+                    block
+                    style={{ backgroundColor: '#1890ff', borderColor: '#1890ff' }}
+                  >
+                    {t('cryptoTailMonitor.manualOrder.buttonUp')} {pushData?.currentPriceUp ? `(${formatNumber(pushData.currentPriceUp, 2)})` : ''}
+                  </Button>
+                </Col>
+                <Col span={12}>
+                  <Button
+                    type="primary"
+                    icon={<ShoppingCartOutlined />}
+                    disabled={!pushData || pushData.triggered || pushData.periodEnded}
+                    onClick={() => handleOpenManualOrderModal('DOWN')}
+                    loading={ordering}
+                    block
+                    style={{ backgroundColor: '#fa8c16', borderColor: '#fa8c16' }}
+                  >
+                    {t('cryptoTailMonitor.manualOrder.buttonDown')} {pushData?.currentPriceDown ? `(${formatNumber(pushData.currentPriceDown, 2)})` : ''}
+                  </Button>
+                </Col>
+              </Row>
+            </Card>
+          ) : null}
+
          {/* 策略信息 */}
          <Card title={t('cryptoTailMonitor.strategyInfo.title')} style={{ marginTop: 16 }}>
-            <Row gutter={[16, 8]}>
-              <Col span={12}>
+            <Row gutter={[16, isMobile ? 12 : 8]}>
+              <Col xs={24} sm={24} md={12}>
                <Text type="secondary">{t('cryptoTailMonitor.strategyInfo.market')}: </Text>
                <Text>{pushData?.marketTitle ?? initData.marketTitle}</Text>
              </Col>
-              <Col span={12}>
+              <Col xs={24} sm={24} md={12}>
                <Text type="secondary">{t('cryptoTailMonitor.strategyInfo.interval')}: </Text>
                <Text>{initData.intervalSeconds === 300 ? '5m' : '15m'}</Text>
              </Col>
-              <Col span={12}>
+              <Col xs={24} sm={24} md={12}>
                <Text type="secondary">{t('cryptoTailMonitor.strategyInfo.account')}: </Text>
                <Text>{initData.accountName || `#${initData.accountId}`}</Text>
              </Col>
-              <Col span={12}>
+              <Col xs={24} sm={24} md={12}>
                <Text type="secondary">{t('cryptoTailMonitor.strategyInfo.spreadMode')}: </Text>
                <Text>{initData.minSpreadMode}</Text>
                {initData.minSpreadMode === 'FIXED' && initData.minSpreadValue && (
                  <Text> ({formatNumber(initData.minSpreadValue, 4)})</Text>
                )}
              </Col>
-              <Col span={12}>
+              <Col xs={24} sm={24} md={12}>
                <Text type="secondary">{t('cryptoTailMonitor.strategyInfo.spreadDirection')}: </Text>
                <Text>{(initData.spreadDirection ?? 'MIN') === 'MAX' ? t('cryptoTailMonitor.stat.configuredSpreadMax') : t('cryptoTailMonitor.stat.configuredSpreadMin')}</Text>
              </Col>
@@ -944,6 +1244,298 @@ const CryptoTailMonitor: React.FC = () => {
          </Card>
        </>
      )}
+
+      {/* 手动下单确认弹窗 - 桌面端使用 Modal */}
+      {!isMobile && (
+        <Modal
+          title={t('cryptoTailMonitor.manualOrder.confirmTitle')}
+          open={manualOrderModal.visible}
+          onCancel={handleCloseManualOrderModal}
+          footer={[
+            <Button key="cancel" onClick={handleCloseManualOrderModal}>
+              {t('cryptoTailMonitor.manualOrder.cancel')}
+            </Button>,
+            <Button
+              key="confirm"
+              type="primary"
+              onClick={handleManualOrder}
+              loading={ordering}
+              style={
+                manualOrderModal.direction === 'UP'
+                  ? { backgroundColor: '#1890ff', borderColor: '#1890ff' }
+                  : { backgroundColor: '#fa8c16', borderColor: '#fa8c16' }
+              }
+            >
+              {t('cryptoTailMonitor.manualOrder.confirm')}
+            </Button>
+          ]}
+          width={480}
+        >
+          {initData && (
+            <Space direction="vertical" style={{ width: '100%' }} size={16}>
+              <Row gutter={[12, 8]}>
+                <Col span={24}>
+                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
+                    {t('cryptoTailMonitor.manualOrder.marketTitle')}
+                  </Text>
+                  <Text>{pushData?.marketTitle ?? initData.marketTitle}</Text>
+                </Col>
+                <Col span={24}>
+                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
+                    {t('cryptoTailMonitor.manualOrder.direction')}
+                  </Text>
+                  <Text
+                    strong
+                    style={{
+                      color: manualOrderModal.direction === 'UP' ? '#1890ff' : '#fa8c16'
+                    }}
+                  >
+                    {manualOrderModal.direction === 'UP'
+                      ? t('cryptoTailMonitor.manualOrder.directionUp')
+                      : t('cryptoTailMonitor.manualOrder.directionDown')}
+                  </Text>
+                </Col>
+                <Col span={24}>
+                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
+                    {t('cryptoTailMonitor.manualOrder.availableBalance')}
+                  </Text>
+                  <Text strong style={{ fontSize: 16, color: '#52c41a' }}>
+                    {manualOrderModal.availableBalance ? formatNumber(manualOrderModal.availableBalance, 2) : '-'} {t('cryptoTailMonitor.manualOrder.orderUnit')}
+                  </Text>
+                </Col>
+                <Col span={24}>
+                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
+                    {t('cryptoTailMonitor.manualOrder.orderPrice')} ({t('cryptoTailMonitor.manualOrder.orderUnit')})
+                  </Text>
+                  <Space.Compact style={{ width: '100%' }}>
+                    <InputNumber
+                      style={{ width: '100%' }}
+                      value={manualOrderModal.price ? parseFloat(manualOrderModal.price) : undefined}
+                      onChange={handlePriceChange}
+                      min={0}
+                      max={1}
+                      step={0.0001}
+                      precision={4}
+                      placeholder="0.0000"
+                    />
+                    <Button onClick={handleFetchLatestPrice} icon={<SyncOutlined />}>
+                      {t('cryptoTailMonitor.manualOrder.fetchLatestPrice')}
+                    </Button>
+                  </Space.Compact>
+                </Col>
+                <Col span={24}>
+                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
+                    {t('cryptoTailMonitor.manualOrder.orderSize')} ({t('cryptoTailMonitor.manualOrder.sizeUnit')})
+                  </Text>
+                  <Space.Compact style={{ width: '100%' }}>
+                    <InputNumber
+                      style={{ width: '100%' }}
+                      value={manualOrderModal.size ? parseFloat(manualOrderModal.size) : undefined}
+                      onChange={handleSizeChange}
+                      min={1}
+                      precision={2}
+                      placeholder="1"
+                    />
+                    <Button onClick={handleMaxSize} type="primary" ghost>
+                      {t('cryptoTailMonitor.manualOrder.maxSize')}
+                    </Button>
+                  </Space.Compact>
+                </Col>
+                <Col span={24}>
+                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
+                    {t('cryptoTailMonitor.manualOrder.totalAmount')}
+                  </Text>
+                  <Text strong style={{ fontSize: 16 }}>
+                    {manualOrderModal.totalAmount} {t('cryptoTailMonitor.manualOrder.orderUnit')}
+                  </Text>
+                </Col>
+                <Col span={24}>
+                  <Text type="secondary" style={{ display: 'block', marginBottom: 4 }}>
+                    {t('cryptoTailMonitor.manualOrder.account')}
+                  </Text>
+                  <Text>{initData.accountName || `#${initData.accountId}`}</Text>
+                </Col>
+              </Row>
+            </Space>
+          )}
+        </Modal>
+      )}
+
+      {/* 移动端 BottomSheet 弹窗 */}
+      {isMobile && (
+        <AntdMobilePopup
+          visible={manualOrderModal.visible}
+          onMaskClick={handleCloseManualOrderModal}
+          onClose={handleCloseManualOrderModal}
+          bodyStyle={{
+            borderRadius: '16px 16px 0 0',
+            padding: '12px 16px',
+            maxHeight: '70vh',
+            overflow: 'auto'
+          }}
+        >
+          {initData && (
+            <div>
+              {/* 标题栏 */}
+              <div style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'space-between',
+                marginBottom: 12
+              }}>
+                <Text strong style={{ fontSize: 16 }}>
+                  {t('cryptoTailMonitor.manualOrder.confirmTitle')}
+                </Text>
+                <Button type="text" onClick={handleCloseManualOrderModal} style={{ padding: 0, fontSize: 18 }}>
+                  ✕
+                </Button>
+              </div>
+
+              {/* 市场信息 + 方向 + 余额（一行） */}
+              <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 10, flexWrap: 'wrap', gap: 8 }}>
+                <div style={{ flex: '1 1 auto', minWidth: 0 }}>
+                  <Text type="secondary" style={{ fontSize: 12 }}>{t('cryptoTailMonitor.manualOrder.marketTitle')}: </Text>
+                  <Text style={{ fontSize: 13 }} ellipsis>{pushData?.marketTitle ?? initData.marketTitle}</Text>
+                </div>
+                <Text
+                  strong
+                  style={{
+                    fontSize: 14,
+                    color: manualOrderModal.direction === 'UP' ? '#1890ff' : '#fa8c16'
+                  }}
+                >
+                  {manualOrderModal.direction === 'UP'
+                    ? t('cryptoTailMonitor.manualOrder.directionUp')
+                    : t('cryptoTailMonitor.manualOrder.directionDown')}
+                </Text>
+              </div>
+
+              {/* 可用余额 */}
+              <div style={{ marginBottom: 10 }}>
+                <Text type="secondary" style={{ fontSize: 12 }}>
+                  {t('cryptoTailMonitor.manualOrder.availableBalance')}: 
+                </Text>
+                <Text strong style={{ fontSize: 14, color: '#52c41a', marginLeft: 4 }}>
+                  {manualOrderModal.availableBalance ? formatNumber(manualOrderModal.availableBalance, 2) : '-'} {t('cryptoTailMonitor.manualOrder.orderUnit')}
+                </Text>
+              </div>
+
+              {/* 价格输入 */}
+              <div style={{ marginBottom: 10 }}>
+                <Text type="secondary" style={{ display: 'block', marginBottom: 2, fontSize: 12 }}>
+                  {t('cryptoTailMonitor.manualOrder.orderPrice')}
+                </Text>
+                <Space.Compact style={{ width: '100%' }}>
+                  <InputNumber
+                    style={{ width: '100%', height: 36 }}
+                    value={manualOrderModal.price ? parseFloat(manualOrderModal.price) : undefined}
+                    onChange={handlePriceChange}
+                    min={0}
+                    max={1}
+                    step={0.0001}
+                    precision={4}
+                    placeholder="0.0000"
+                  />
+                  <Button onClick={handleFetchLatestPrice} icon={<SyncOutlined />} style={{ height: 36, fontSize: 12 }}>
+                    {t('cryptoTailMonitor.manualOrder.fetchLatestPrice')}
+                  </Button>
+                </Space.Compact>
+              </div>
+
+              {/* 数量输入 */}
+              <div style={{ marginBottom: 10 }}>
+                <Text type="secondary" style={{ display: 'block', marginBottom: 2, fontSize: 12 }}>
+                  {t('cryptoTailMonitor.manualOrder.orderSize')}
+                </Text>
+                <Space.Compact style={{ width: '100%' }}>
+                  <InputNumber
+                    style={{ width: '100%', height: 36 }}
+                    value={manualOrderModal.size ? parseFloat(manualOrderModal.size) : undefined}
+                    onChange={handleSizeChange}
+                    min={1}
+                    precision={2}
+                    placeholder="1"
+                  />
+                  <Button onClick={handleMaxSize} type="primary" ghost style={{ height: 36, fontSize: 12 }}>
+                    {t('cryptoTailMonitor.manualOrder.maxSize')}
+                  </Button>
+                </Space.Compact>
+              </div>
+
+              {/* 总金额 + 账户（一行） */}
+              <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: 12 }}>
+                <div>
+                  <Text type="secondary" style={{ fontSize: 12 }}>{t('cryptoTailMonitor.manualOrder.totalAmount')}: </Text>
+                  <Text strong style={{ fontSize: 16, marginLeft: 4 }}>
+                    {manualOrderModal.totalAmount} {t('cryptoTailMonitor.manualOrder.orderUnit')}
+                  </Text>
+                </div>
+                <div>
+                  <Text type="secondary" style={{ fontSize: 12 }}>{t('cryptoTailMonitor.manualOrder.account')}: </Text>
+                  <Text style={{ fontSize: 12 }}>{initData.accountName || `#${initData.accountId}`}</Text>
+                </div>
+              </div>
+
+              {/* 确认按钮 */}
+              <Button
+                type="primary"
+                block
+                onClick={handleManualOrder}
+                loading={ordering}
+                style={{
+                  height: 44,
+                  borderRadius: 8,
+                  backgroundColor: manualOrderModal.direction === 'UP' ? '#1890ff' : '#fa8c16',
+                  borderColor: manualOrderModal.direction === 'UP' ? '#1890ff' : '#fa8c16'
+                }}
+              >
+                {t('cryptoTailMonitor.manualOrder.confirm')}
+              </Button>
+            </div>
+          )}
+        </AntdMobilePopup>
+      )}
+
+      {/* 移动端底部悬浮按钮 */}
+      {isMobile && (
+        <div
+          style={{
+            position: 'fixed',
+            bottom: 0,
+            left: 0,
+            right: 0,
+            zIndex: 1000,
+            padding: '12px 16px',
+            background: 'rgba(255, 255, 255, 0.95)',
+            backdropFilter: 'blur(10px)',
+            borderTop: '1px solid #f0f0f0',
+            boxShadow: '0 -2px 8px rgba(0, 0, 0, 0.06)'
+          }}
+        >
+          <div style={{ display: 'flex', width: '100%', gap: 0 }}>
+            <Button
+              type="primary"
+              icon={<ShoppingCartOutlined />}
+              disabled={!pushData || pushData.triggered || pushData.periodEnded}
+              onClick={() => handleOpenManualOrderModal('UP')}
+              loading={ordering}
+              style={{ flex: 1, backgroundColor: '#1890ff', borderColor: '#1890ff', height: 44, borderRadius: '6px 0 0 6px' }}
+            >
+              {t('cryptoTailMonitor.manualOrder.buttonUp')} {pushData?.currentPriceUp ? `(${formatNumber(pushData.currentPriceUp, 2)})` : ''}
+            </Button>
+            <Button
+              type="primary"
+              icon={<ShoppingCartOutlined />}
+              disabled={!pushData || pushData.triggered || pushData.periodEnded}
+              onClick={() => handleOpenManualOrderModal('DOWN')}
+              loading={ordering}
+              style={{ flex: 1, backgroundColor: '#fa8c16', borderColor: '#fa8c16', height: 44, borderRadius: '0 6px 6px 0' }}
+            >
+              {t('cryptoTailMonitor.manualOrder.buttonDown')} {pushData?.currentPriceDown ? `(${formatNumber(pushData.currentPriceDown, 2)})` : ''}
+            </Button>
+          </div>
+        </div>
+      )}
    </div>
  )
 }
@@ -0,0 +1,149 @@
+import { useEffect, useRef } from 'react'
+import { Modal, Row, Col, Statistic, Button, Space, Empty } from 'antd'
+import { useTranslation } from 'react-i18next'
+import { useMediaQuery } from 'react-responsive'
+import dayjs from 'dayjs'
+import * as echarts from 'echarts'
+import type { EChartsOption } from 'echarts'
+import { formatUSDC } from '../utils'
+import type { CryptoTailPnlCurveResponse } from '../types'
+
+export interface CryptoTailPnlCurveModalProps {
+  open: boolean
+  onClose: () => void
+  data: CryptoTailPnlCurveResponse | null
+  loading: boolean
+  strategyName: string
+  preset: 'today' | '7d' | '30d' | 'all'
+  onPresetChange: (preset: 'today' | '7d' | '30d' | 'all') => void
+  onRefresh: () => void
+}
+
+const CryptoTailPnlCurveModal: React.FC<CryptoTailPnlCurveModalProps> = (props) => {
+  const { open, onClose, data, loading, strategyName, preset, onPresetChange, onRefresh } = props
+  const { t } = useTranslation()
+  const isMobile = useMediaQuery({ maxWidth: 768 })
+  const chartRef = useRef<HTMLDivElement>(null)
+  const chartInstance = useRef<echarts.ECharts | null>(null)
+
+  useEffect(() => {
+    if (!open || !data?.curveData?.length || !chartRef.current) return
+    if (chartInstance.current) {
+      const dom = chartInstance.current.getDom()
+      if (!dom || !document.contains(dom)) {
+        chartInstance.current.dispose()
+        chartInstance.current = null
+      }
+    }
+    if (!chartInstance.current) chartInstance.current = echarts.init(chartRef.current)
+    const option: EChartsOption = {
+      tooltip: {
+        trigger: 'axis',
+        formatter: (params: unknown) => {
+          const arr = params as Array<{ value: [number, number] }>
+          const v = arr[0]?.value
+          if (!v) return ''
+          const d = data.curveData.find((p) => p.timestamp === v[0])
+          if (!d) return ''
+          return dayjs(v[0]).format('YYYY-MM-DD HH:mm') + '<br/>' + t('cryptoTailStrategy.pnlCurve.totalPnl') + ': $' + formatUSDC(d.cumulativePnl)
+        }
+      },
+      grid: { left: '3%', right: '4%', bottom: '3%', top: '10%', containLabel: true },
+      xAxis: { type: 'time' },
+      yAxis: { type: 'value', axisLabel: { formatter: (val: number) => '$' + String(val) } },
+      series: [{
+        name: t('cryptoTailStrategy.pnlCurve.totalPnl'),
+        type: 'line',
+        data: data.curveData.map((p) => [p.timestamp, parseFloat(p.cumulativePnl)]),
+        smooth: preset === 'all',
+        symbol: 'circle',
+        symbolSize: 4,
+        lineStyle: { width: 2, color: '#1890ff' },
+        areaStyle: {
+          color: new echarts.graphic.LinearGradient(0, 0, 0, 1, [
+            { offset: 0, color: 'rgba(24, 144, 255, 0.3)' },
+            { offset: 1, color: 'rgba(24, 144, 255, 0.05)' }
+          ])
+        }
+      }]
+    }
+    chartInstance.current.setOption(option, true)
+    chartInstance.current.resize()
+  }, [open, data, preset, t])
+
+  useEffect(() => {
+    if (!open) {
+      chartInstance.current?.dispose()
+      chartInstance.current = null
+    }
+  }, [open])
+
+  useEffect(() => {
+    if (!open || !chartInstance.current) return
+    const handleResize = () => chartInstance.current?.resize()
+    window.addEventListener('resize', handleResize)
+    return () => window.removeEventListener('resize', handleResize)
+  }, [open])
+
+  const pnlColor = (value: string | null | undefined): string | undefined => {
+    if (value == null || value === '') return undefined
+    const num = parseFloat(value)
+    if (Number.isNaN(num)) return undefined
+    if (num > 0) return '#52c41a'
+    if (num < 0) return '#ff4d4f'
+    return undefined
+  }
+
+  return (
+    <Modal
+      title={t('cryptoTailStrategy.pnlCurve.title') + ' - ' + strategyName}
+      open={open}
+      onCancel={onClose}
+      footer={null}
+      width={Math.min(800, window.innerWidth - 48)}
+      destroyOnClose
+    >
+      <Row gutter={[16, 16]} style={{ marginBottom: 16 }}>
+        <Col xs={12} sm={6}>
+          <Statistic
+            title={t('cryptoTailStrategy.pnlCurve.totalPnl')}
+            value={data?.totalRealizedPnl != null ? formatUSDC(data.totalRealizedPnl) : '-'}
+            prefix="$"
+            valueStyle={{ color: pnlColor(data?.totalRealizedPnl ?? null) }}
+          />
+        </Col>
+        <Col xs={12} sm={6}>
+          <Statistic title={t('cryptoTailStrategy.pnlCurve.settledCount')} value={data?.settledCount ?? 0} />
+        </Col>
+        <Col xs={12} sm={6}>
+          <Statistic
+            title={t('cryptoTailStrategy.pnlCurve.winRate')}
+            value={data?.winRate != null ? (Number(data.winRate) * 100).toFixed(1) + '%' : '-'}
+          />
+        </Col>
+        <Col xs={12} sm={6}>
+          <Statistic
+            title={t('cryptoTailStrategy.pnlCurve.maxDrawdown')}
+            value={data?.maxDrawdown != null ? '-' + formatUSDC(data.maxDrawdown) : '-'}
+            prefix="$"
+            valueStyle={{ color: data?.maxDrawdown ? '#ff4d4f' : undefined }}
+          />
+        </Col>
+      </Row>
+      <Space wrap style={{ marginBottom: 16 }}>
+        <Button size="small" type={preset === 'today' ? 'primary' : 'default'} onClick={() => onPresetChange('today')}>{t('cryptoTailStrategy.pnlCurve.today')}</Button>
+        <Button size="small" type={preset === '7d' ? 'primary' : 'default'} onClick={() => onPresetChange('7d')}>{t('cryptoTailStrategy.pnlCurve.last7Days')}</Button>
+        <Button size="small" type={preset === '30d' ? 'primary' : 'default'} onClick={() => onPresetChange('30d')}>{t('cryptoTailStrategy.pnlCurve.last30Days')}</Button>
+        <Button size="small" type={preset === 'all' ? 'primary' : 'default'} onClick={() => onPresetChange('all')}>{t('cryptoTailStrategy.pnlCurve.all')}</Button>
+        <Button size="small" onClick={onRefresh} loading={loading}>{t('common.refresh')}</Button>
+      </Space>
+      {!data && loading
+        ? <div style={{ height: 320, display: 'flex', alignItems: 'center', justifyContent: 'center' }}>{t('common.loading')}</div>
+        : !data?.curveData?.length
+          ? <Empty description={t('cryptoTailStrategy.pnlCurve.empty')} style={{ marginTop: 24 }} />
+          : <div ref={chartRef} style={{ width: '100%', height: isMobile ? 260 : 320 }} />}
+    </Modal>
+  )
+}
+
+export default CryptoTailPnlCurveModal
@@ -21,19 +21,19 @@ import {
  Tabs,
  DatePicker,
  Empty,
-  Typography,
-  Divider
+  Typography
 } from 'antd'
 import type { Dayjs } from 'dayjs'
 import dayjs from 'dayjs'
-import { PlusOutlined, EditOutlined, UnorderedListOutlined, InfoCircleOutlined, WarningOutlined, CalendarOutlined, FileTextOutlined } from '@ant-design/icons'
+import { PlusOutlined, EditOutlined, UnorderedListOutlined, LineChartOutlined, InfoCircleOutlined, WarningOutlined, CalendarOutlined, FileTextOutlined, DeleteOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import { useMediaQuery } from 'react-responsive'
 import { apiService } from '../services/api'
 import { useAccountStore } from '../store/accountStore'
-import type { CryptoTailStrategyDto, CryptoTailStrategyTriggerDto, CryptoTailMarketOptionDto } from '../types'
+import type { CryptoTailStrategyDto, CryptoTailStrategyTriggerDto, CryptoTailMarketOptionDto, CryptoTailPnlCurveResponse } from '../types'
 import { formatUSDC, formatNumber } from '../utils'
 import { getVersionInfo } from '../utils/version'
+import CryptoTailPnlCurveModal from './CryptoTailPnlCurveModal'

 const CryptoTailStrategyList: React.FC = () => {
  const { t, i18n } = useTranslation()
@@ -59,6 +59,14 @@ const CryptoTailStrategyList: React.FC = () => {
  const [triggersLoading, setTriggersLoading] = useState(false)
  const [form] = Form.useForm()

+  const [pnlCurveModalOpen, setPnlCurveModalOpen] = useState(false)
+  const [pnlCurveStrategyId, setPnlCurveStrategyId] = useState<number | null>(null)
+  const [pnlCurveStrategyName, setPnlCurveStrategyName] = useState('')
+  const [pnlCurvePreset, setPnlCurvePreset] = useState<'today' | '7d' | '30d' | 'all'>('all')
+  const [pnlCurveCustomRange, setPnlCurveCustomRange] = useState<[Dayjs | null, Dayjs | null]>([null, null])
+  const [pnlCurveData, setPnlCurveData] = useState<CryptoTailPnlCurveResponse | null>(null)
+  const [pnlCurveLoading, setPnlCurveLoading] = useState(false)
+
  /** 币安 API 健康状态：仅保留「不可用」的项，用于强提醒 */
  const [binanceUnhealthy, setBinanceUnhealthy] = useState<Array<{ name: string; message: string }>>([])
  const [binanceCheckLoading, setBinanceCheckLoading] = useState(false)
@@ -328,6 +336,61 @@ const CryptoTailStrategyList: React.FC = () => {
    await loadTriggerRecords(strategyId, 'success', { page: 1, pageSize: 20, dateRange: [null, null] })
  }

+  const getPnlCurveTimeRange = (): { startDate?: number; endDate?: number } => {
+    if (pnlCurvePreset === 'all') return {}
+    const now = dayjs()
+    if (pnlCurvePreset === 'today') {
+      return { startDate: now.startOf('day').valueOf(), endDate: now.valueOf() }
+    }
+    if (pnlCurvePreset === '7d') {
+      return { startDate: now.subtract(7, 'day').startOf('day').valueOf(), endDate: now.valueOf() }
+    }
+    if (pnlCurvePreset === '30d') {
+      return { startDate: now.subtract(30, 'day').startOf('day').valueOf(), endDate: now.valueOf() }
+    }
+    if (pnlCurveCustomRange[0] != null && pnlCurveCustomRange[1] != null) {
+      return {
+        startDate: pnlCurveCustomRange[0].startOf('day').valueOf(),
+        endDate: pnlCurveCustomRange[1].endOf('day').valueOf()
+      }
+    }
+    return {}
+  }
+
+  const loadPnlCurve = async () => {
+    if (pnlCurveStrategyId == null) return
+    setPnlCurveLoading(true)
+    try {
+      const { startDate, endDate } = getPnlCurveTimeRange()
+      const res = await apiService.cryptoTailStrategy.pnlCurve({
+        strategyId: pnlCurveStrategyId,
+        startDate,
+        endDate
+      })
+      if (res.data.code === 0 && res.data.data) {
+        setPnlCurveData(res.data.data)
+      }
+    } catch (e) {
+      console.error('Failed to load PnL curve:', e)
+    } finally {
+      setPnlCurveLoading(false)
+    }
+  }
+
+  const openPnlCurve = (record: CryptoTailStrategyDto) => {
+    setPnlCurveStrategyId(record.id)
+    setPnlCurveStrategyName(record.name ?? record.marketTitle ?? record.marketSlugPrefix ?? '')
+    setPnlCurvePreset('all')
+    setPnlCurveCustomRange([null, null])
+    setPnlCurveModalOpen(true)
+  }
+
+  useEffect(() => {
+    if (pnlCurveModalOpen && pnlCurveStrategyId != null) {
+      loadPnlCurve()
+    }
+  }, [pnlCurveModalOpen, pnlCurveStrategyId, pnlCurvePreset, pnlCurveCustomRange])
+
  const onTriggerTabChange = (key: string) => {
    const next = key === 'success' ? 'success' : 'fail'
    setTriggerTab(next)
@@ -389,7 +452,7 @@ const CryptoTailStrategyList: React.FC = () => {
      title: t('common.status'),
      dataIndex: 'enabled',
      key: 'enabled',
-      width: 80,
+      width: 72,
      render: (enabled: boolean, record: CryptoTailStrategyDto) => (
        <Switch
          checked={enabled}
@@ -402,7 +465,8 @@ const CryptoTailStrategyList: React.FC = () => {
      title: t('cryptoTailStrategy.list.strategyName'),
      dataIndex: 'name',
      key: 'name',
-      width: isMobile ? 100 : 160,
+      width: isMobile ? 100 : 140,
+      ellipsis: true,
      render: (name: string | undefined, r: CryptoTailStrategyDto) => (
        <Typography.Text strong style={{ wordBreak: 'break-word', whiteSpace: 'normal' }}>
          {name || (r.marketTitle ?? r.marketSlugPrefix) || '-'}
@@ -413,7 +477,8 @@ const CryptoTailStrategyList: React.FC = () => {
      title: t('cryptoTailStrategy.list.account'),
      dataIndex: 'accountId',
      key: 'accountId',
-      width: isMobile ? 90 : 120,
+      width: isMobile ? 90 : 100,
+      ellipsis: true,
      render: (_: unknown, r: CryptoTailStrategyDto) => (
        <Typography.Text type="secondary" style={{ wordBreak: 'break-word', whiteSpace: 'normal' }}>
          {getAccountLabel(r.accountId)}
@@ -421,99 +486,149 @@ const CryptoTailStrategyList: React.FC = () => {
      )
    },
    {
-      title: t('cryptoTailStrategy.list.market'),
-      key: 'market',
-      width: isMobile ? 120 : 200,
+      title: t('cryptoTailStrategy.list.marketAndTime'),
+      key: 'marketAndTime',
+      width: isMobile ? 120 : 180,
      render: (_: unknown, r: CryptoTailStrategyDto) => (
-        <Typography.Text style={{ wordBreak: 'break-word', whiteSpace: 'normal' }}>
-          {marketOptions.find((m) => m.slug === r.marketSlugPrefix)?.title ?? r.marketTitle ?? r.marketSlugPrefix ?? '-'}
-        </Typography.Text>
+        <div>
+          <Typography.Text style={{ wordBreak: 'break-word', whiteSpace: 'normal', display: 'block' }}>
+            {marketOptions.find((m) => m.slug === r.marketSlugPrefix)?.title ?? r.marketTitle ?? r.marketSlugPrefix ?? '-'}
+          </Typography.Text>
+          <Typography.Text type="secondary" style={{ fontSize: 12, wordBreak: 'break-word', whiteSpace: 'pre-line' }}>
+            {formatTimeWindow(r.windowStartSeconds, r.windowEndSeconds, false)}
+          </Typography.Text>
+        </div>
      )
    },
    {
-      title: t('cryptoTailStrategy.list.timeWindow'),
-      key: 'timeWindow',
-      width: isMobile ? 100 : 120,
+      title: t('cryptoTailStrategy.list.config'),
+      key: 'config',
+      width: isMobile ? 100 : 140,
      render: (_: unknown, r: CryptoTailStrategyDto) => (
-        <Typography.Text type="secondary" style={{ wordBreak: 'break-word', whiteSpace: 'pre-line' }}>
-          {formatTimeWindow(r.windowStartSeconds, r.windowEndSeconds)}
-        </Typography.Text>
-      )
-    },
-    {
-      title: t('cryptoTailStrategy.list.priceRange'),
-      key: 'priceRange',
-      width: isMobile ? 90 : 120,
-      render: (_: unknown, r: CryptoTailStrategyDto) => (
-        <Typography.Text type="secondary" style={{ wordBreak: 'break-word', whiteSpace: 'normal' }}>
-          {formatPriceRange(r.minPrice, r.maxPrice)}
-        </Typography.Text>
-      )
-    },
-    {
-      title: t('cryptoTailStrategy.list.amountMode'),
-      key: 'amountMode',
-      width: isMobile ? 90 : 120,
-      render: (_: unknown, r: CryptoTailStrategyDto) => (
-        <Typography.Text type="secondary" style={{ wordBreak: 'break-word', whiteSpace: 'normal' }}>
-          {(r.amountMode?.toUpperCase() ?? '') === 'RATIO'
-            ? `${t('cryptoTailStrategy.list.ratio')} ${formatNumber(r.amountValue, 2) || '0'}%`
-            : `${t('cryptoTailStrategy.list.fixed')} ${formatUSDC(r.amountValue)} USDC`}
-        </Typography.Text>
+        <div>
+          <Typography.Text type="secondary" style={{ fontSize: 12, display: 'block' }}>
+            {formatPriceRange(r.minPrice, r.maxPrice)}
+          </Typography.Text>
+          <Typography.Text type="secondary" style={{ fontSize: 12 }}>
+            {(r.amountMode?.toUpperCase() ?? '') === 'RATIO'
+              ? `${t('cryptoTailStrategy.list.ratio')} ${formatNumber(r.amountValue, 2) || '0'}%`
+              : `${t('cryptoTailStrategy.list.fixed')} ${formatUSDC(r.amountValue)}`}
+          </Typography.Text>
+        </div>
      )
    },
    {
      title: t('cryptoTailStrategy.list.totalRealizedPnl'),
-      key: 'totalRealizedPnl',
+      key: 'pnl',
      width: isMobile ? 90 : 120,
      render: (_: unknown, r: CryptoTailStrategyDto) => {
-        const text = r.totalRealizedPnl != null ? `${formatUSDC(r.totalRealizedPnl)} USDC` : '-'
+        const text = r.totalRealizedPnl != null ? formatUSDC(r.totalRealizedPnl) : '-'
        const color = pnlColor(r.totalRealizedPnl)
-        return color ? (
-          <Typography.Text style={{ color, fontWeight: 500 }}>{text}</Typography.Text>
-        ) : (
-          <Typography.Text type="secondary">{text}</Typography.Text>
+        return (
+          <div>
+            {color ? (
+              <Typography.Text style={{ color, fontWeight: 500 }}>{text}</Typography.Text>
+            ) : (
+              <Typography.Text type="secondary">{text}</Typography.Text>
+            )}
+            <Typography.Text type="secondary" style={{ fontSize: 12, display: 'block' }}>
+              {r.winRate != null ? `${(Number(r.winRate) * 100).toFixed(1)}%` : '-'}
+            </Typography.Text>
+          </div>
        )
      }
    },
-    {
-      title: t('cryptoTailStrategy.list.winRate'),
-      key: 'winRate',
-      width: isMobile ? 70 : 90,
-      render: (_: unknown, r: CryptoTailStrategyDto) =>
-        r.winRate != null ? (
-          <Tag color="blue">{(Number(r.winRate) * 100).toFixed(1)}%</Tag>
-        ) : (
-          <Typography.Text type="secondary">-</Typography.Text>
-        )
-    },
    {
      title: t('cryptoTailStrategy.list.actions'),
      key: 'actions',
-      width: isMobile ? 120 : 200,
+      width: isMobile ? 120 : 140,
      fixed: 'right' as const,
      render: (_: unknown, record: CryptoTailStrategyDto) => (
-        <Space size="small" wrap>
-          <Button type="link" size="small" icon={<EditOutlined />} onClick={() => openEditModal(record)}>
-            {t('cryptoTailStrategy.list.edit')}
-          </Button>
-          <Button
-            type="link"
-            size="small"
-            icon={<UnorderedListOutlined />}
-            onClick={() => openTriggers(record.id)}
-          >
-            {t('cryptoTailStrategy.list.viewTriggers')}
-          </Button>
+        <Space size={4}>
+          <Tooltip title={t('cryptoTailStrategy.list.edit')}>
+            <div
+              onClick={() => openEditModal(record)}
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                width: '32px',
+                height: '32px',
+                cursor: 'pointer',
+                borderRadius: '6px',
+                transition: 'background-color 0.2s'
+              }}
+              onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#f0f0f0' }}
+              onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
+            >
+              <EditOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+            </div>
+          </Tooltip>
+
+          <Tooltip title={t('cryptoTailStrategy.list.viewTriggers')}>
+            <div
+              onClick={() => openTriggers(record.id)}
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                width: '32px',
+                height: '32px',
+                cursor: 'pointer',
+                borderRadius: '6px',
+                transition: 'background-color 0.2s'
+              }}
+              onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#f0f0f0' }}
+              onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
+            >
+              <UnorderedListOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+            </div>
+          </Tooltip>
+
+          <Tooltip title={t('cryptoTailStrategy.list.viewPnlCurve')}>
+            <div
+              onClick={() => openPnlCurve(record)}
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                width: '32px',
+                height: '32px',
+                cursor: 'pointer',
+                borderRadius: '6px',
+                transition: 'background-color 0.2s'
+              }}
+              onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#f0f0f0' }}
+              onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
+            >
+              <LineChartOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+            </div>
+          </Tooltip>
+
          <Popconfirm
            title={t('cryptoTailStrategy.list.deleteConfirm')}
            onConfirm={() => handleDelete(record.id)}
            okText={t('common.confirm')}
            cancelText={t('common.cancel')}
          >
-            <Button type="link" size="small" danger>
-              {t('cryptoTailStrategy.list.delete')}
-            </Button>
+            <Tooltip title={t('cryptoTailStrategy.list.delete')}>
+              <div
+                style={{
+                  display: 'flex',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                  width: '32px',
+                  height: '32px',
+                  cursor: 'pointer',
+                  borderRadius: '6px',
+                  transition: 'background-color 0.2s'
+                }}
+                onMouseEnter={(e) => { e.currentTarget.style.backgroundColor = '#fff1f0' }}
+                onMouseLeave={(e) => { e.currentTarget.style.backgroundColor = 'transparent' }}
+              >
+                <DeleteOutlined style={{ fontSize: '16px', color: '#ff4d4f' }} />
+              </div>
+            </Tooltip>
          </Popconfirm>
        </Space>
      )
@@ -543,17 +658,28 @@ const CryptoTailStrategyList: React.FC = () => {
  }

  return (
-    <div style={{ padding: isMobile ? 12 : 24 }}>
-      <div style={{ display: 'flex', alignItems: 'center', gap: 12, marginBottom: 16, flexWrap: 'wrap' }}>
-        <h1 style={{ margin: 0, fontSize: isMobile ? 20 : 24 }}>{t('cryptoTailStrategy.list.title')}</h1>
-        <Button
-          type="link"
-          icon={<FileTextOutlined />}
-          onClick={() => window.open(getGuideUrl(), '_blank')}
-          style={{ padding: 0, height: 'auto', fontSize: isMobile ? 14 : 16 }}
-        >
-          {t('cryptoTailStrategy.list.configGuide')}
-        </Button>
+    <div style={{ padding: isMobile ? 0 : 24 }}>
+      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px', flexWrap: 'wrap', gap: '12px', padding: isMobile ? '0 8px' : 0 }}>
+        <div style={{ display: 'flex', alignItems: 'center', gap: 12, flexWrap: 'wrap' }}>
+          <h2 style={{ margin: 0, fontSize: isMobile ? '20px' : '24px' }}>{t('cryptoTailStrategy.list.title')}</h2>
+          <Button
+            type="link"
+            icon={<FileTextOutlined />}
+            onClick={() => window.open(getGuideUrl(), '_blank')}
+            style={{ padding: 0, height: 'auto', fontSize: isMobile ? 14 : 16 }}
+          >
+            {t('cryptoTailStrategy.list.configGuide')}
+          </Button>
+        </div>
+        <Tooltip title={t('cryptoTailStrategy.list.addStrategy')}>
+          <Button
+            type="primary"
+            icon={<PlusOutlined />}
+            onClick={openAddModal}
+            size={isMobile ? 'middle' : 'large'}
+            style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}
+          />
+        </Tooltip>
      </div>
      {binanceUnhealthy.length > 0 && list.some((s) => s.enabled) && (
        <Alert
@@ -583,20 +709,17 @@ const CryptoTailStrategyList: React.FC = () => {
              </Button>
            </div>
          }
-          style={{ marginBottom: 16 }}
+          style={{ marginBottom: 16, margin: isMobile ? '0 8px 16px' : undefined }}
        />
      )}
      <Alert
        type="warning"
        showIcon
        message={t('cryptoTailStrategy.list.walletTip')}
-        style={{ marginBottom: 16 }}
+        style={{ marginBottom: 16, margin: isMobile ? '0 8px 16px' : undefined }}
      />
-      <Card>
+      <Card style={{ borderRadius: isMobile ? 0 : '12px', boxShadow: '0 2px 8px rgba(0,0,0,0.08)', border: isMobile ? 'none' : '1px solid #e8e8e8' }} styles={{ body: { padding: isMobile ? 12 : 24 } }}>
        <div style={{ marginBottom: 16, display: 'flex', flexWrap: 'wrap', gap: 8, alignItems: 'center' }}>
-          <Button type="primary" icon={<PlusOutlined />} onClick={openAddModal}>
-            {t('cryptoTailStrategy.list.addStrategy')}
-          </Button>
          <Select
            placeholder={t('cryptoTailStrategy.form.selectAccount')}
            allowClear
@@ -619,86 +742,86 @@ const CryptoTailStrategyList: React.FC = () => {
        </div>
        <Spin spinning={loading}>
          {isMobile ? (
-            <div style={{ display: 'flex', flexDirection: 'column', gap: 16 }}>
-              {list.map((item) => (
-                <Card
-                  key={item.id}
-                  size="small"
-                  styles={{ body: { padding: 16 } }}
-                  style={{ borderLeft: `3px solid ${item.enabled ? 'var(--ant-colorSuccess)' : 'var(--ant-colorBorder)'}` }}
-                >
-                  <Typography.Text strong style={{ fontSize: 15, wordBreak: 'break-word', whiteSpace: 'normal', display: 'block', marginBottom: 8 }}>
-                    {item.name || (item.marketTitle ?? item.marketSlugPrefix) || '-'}
-                  </Typography.Text>
-                  <Typography.Text type="secondary" style={{ display: 'block', marginBottom: 4, fontSize: 13, wordBreak: 'break-word', whiteSpace: 'normal' }}>
-                    {t('cryptoTailStrategy.list.account')}: {getAccountLabel(item.accountId)}
-                  </Typography.Text>
-                  <Typography.Text type="secondary" style={{ display: 'block', marginBottom: 8, fontSize: 13, wordBreak: 'break-word', whiteSpace: 'normal' }}>
-                    {marketOptions.find((m) => m.slug === item.marketSlugPrefix)?.title ?? item.marketSlugPrefix ?? '-'}
-                  </Typography.Text>
-                  <div style={{ display: 'grid', gridTemplateColumns: '1fr 1fr', gap: '6px 16px', marginBottom: 12 }}>
-                    <Typography.Text type="secondary" style={{ fontSize: 12, wordBreak: 'break-word', whiteSpace: 'normal' }}>
-                      {t('cryptoTailStrategy.list.timeWindow')}
-                    </Typography.Text>
-                    <Typography.Text style={{ fontSize: 12 }}>{formatTimeWindow(item.windowStartSeconds, item.windowEndSeconds, false)}</Typography.Text>
-                    <Typography.Text type="secondary" style={{ fontSize: 12, wordBreak: 'break-word', whiteSpace: 'normal' }}>
-                      {t('cryptoTailStrategy.list.priceRange')}
-                    </Typography.Text>
-                    <Typography.Text style={{ fontSize: 12, wordBreak: 'break-word', whiteSpace: 'normal' }}>{formatPriceRange(item.minPrice, item.maxPrice)}</Typography.Text>
-                    <Typography.Text type="secondary" style={{ fontSize: 12, wordBreak: 'break-word', whiteSpace: 'normal' }}>
-                      {t('cryptoTailStrategy.list.amountMode')}
-                    </Typography.Text>
-                    <Typography.Text style={{ fontSize: 12, wordBreak: 'break-word', whiteSpace: 'normal' }}>
-                      {(item.amountMode?.toUpperCase() ?? '') === 'RATIO'
-                        ? `${t('cryptoTailStrategy.list.ratio')} ${formatNumber(item.amountValue, 2) || '0'}%`
-                        : `${t('cryptoTailStrategy.list.fixed')} ${formatUSDC(item.amountValue)} USDC`}
-                    </Typography.Text>
-                  </div>
-                  <Divider style={{ margin: '10px 0' }} />
-                  <Space wrap style={{ marginBottom: 12 }}>
-                    <Typography.Text type="secondary" style={{ fontSize: 12 }}>
-                      {t('cryptoTailStrategy.list.totalRealizedPnl')}:{' '}
-                    </Typography.Text>
-                    {item.totalRealizedPnl != null ? (
-                      <Typography.Text style={{ color: pnlColor(item.totalRealizedPnl) ?? undefined, fontWeight: 500, fontSize: 12 }}>
-                        {formatUSDC(item.totalRealizedPnl)} USDC
-                      </Typography.Text>
-                    ) : (
-                      <Typography.Text type="secondary" style={{ fontSize: 12 }}>-</Typography.Text>
-                    )}
-                    {item.winRate != null && (
-                      <>
-                        <Typography.Text type="secondary" style={{ fontSize: 12 }}>·</Typography.Text>
-                        <Tag color="blue" style={{ margin: 0 }}>{t('cryptoTailStrategy.list.winRate')} {(Number(item.winRate) * 100).toFixed(1)}%</Tag>
-                      </>
-                    )}
-                  </Space>
-                  <Divider style={{ margin: '10px 0' }} />
-                  <Space wrap size="small">
-                    <Switch
-                      checked={item.enabled}
-                      onChange={() => handleToggle(item)}
-                      size="small"
-                    />
-                    <Button type="link" size="small" icon={<EditOutlined />} onClick={() => openEditModal(item)}>
-                      {t('cryptoTailStrategy.list.edit')}
-                    </Button>
-                    <Button type="link" size="small" icon={<UnorderedListOutlined />} onClick={() => openTriggers(item.id)}>
-                      {t('cryptoTailStrategy.list.viewTriggers')}
-                    </Button>
-                    <Popconfirm
-                      title={t('cryptoTailStrategy.list.deleteConfirm')}
-                      onConfirm={() => handleDelete(item.id)}
-                      okText={t('common.confirm')}
-                      cancelText={t('common.cancel')}
-                    >
-                      <Button type="link" size="small" danger>
-                        {t('cryptoTailStrategy.list.delete')}
-                      </Button>
-                    </Popconfirm>
-                  </Space>
-                </Card>
-              ))}
+            <div style={{ display: 'flex', flexDirection: 'column', gap: 12 }}>
+              {list.map((item) => {
+                const accountLabel = getAccountLabel(item.accountId)
+                const marketTitle = marketOptions.find((m) => m.slug === item.marketSlugPrefix)?.title ?? item.marketTitle ?? item.marketSlugPrefix ?? '-'
+                return (
+                  <Card
+                    key={item.id}
+                    style={{
+                      marginBottom: 0,
+                      borderRadius: '10px',
+                      boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
+                      border: '1px solid #e8e8e8',
+                      overflow: 'hidden'
+                    }}
+                    bodyStyle={{ padding: 0 }}
+                  >
+                    <div style={{
+                      padding: '10px 12px',
+                      background: item.enabled ? 'var(--ant-color-primary, #1677ff)' : 'var(--ant-color-fill-secondary, #f0f0f0)',
+                      color: item.enabled ? '#fff' : 'var(--ant-color-text-secondary, #666)'
+                    }}>
+                      <div style={{ fontSize: '15px', fontWeight: '600', display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
+                        <span style={{ wordBreak: 'break-word', whiteSpace: 'normal' }}>{item.name || marketTitle || '-'}</span>
+                        <Switch checked={item.enabled} onChange={() => handleToggle(item)} size="small" />
+                      </div>
+                    </div>
+                    <div style={{ padding: '8px 12px', backgroundColor: '#fafafa', borderBottom: '1px solid #f0f0f0' }}>
+                      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center' }}>
+                        <div>
+                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>{t('cryptoTailStrategy.list.totalRealizedPnl')}</div>
+                          {item.totalRealizedPnl != null ? (
+                            <div style={{ fontSize: '14px', fontWeight: '600', color: pnlColor(item.totalRealizedPnl) }}>${formatUSDC(item.totalRealizedPnl)}</div>
+                          ) : (
+                            <div style={{ fontSize: '14px', color: '#8c8c8c' }}>-</div>
+                          )}
+                        </div>
+                        <div style={{ textAlign: 'right' }}>
+                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>{t('cryptoTailStrategy.list.winRate')}</div>
+                          {item.winRate != null ? <Tag color="blue" style={{ margin: 0 }}>{(Number(item.winRate) * 100).toFixed(1)}%</Tag> : <span style={{ fontSize: '12px', color: '#8c8c8c' }}>-</span>}
+                        </div>
+                      </div>
+                    </div>
+                    <div style={{ padding: '6px 12px', fontSize: '11px', color: '#8c8c8c', borderBottom: '1px solid #f0f0f0' }}>
+                      <div>{t('cryptoTailStrategy.list.account')}: {accountLabel}</div>
+                      <div>{t('cryptoTailStrategy.list.market')}: {marketTitle}</div>
+                    </div>
+                    <div style={{ padding: '6px 12px', fontSize: '11px', color: '#8c8c8c', borderBottom: '1px solid #f0f0f0' }}>
+                      {t('cryptoTailStrategy.list.timeWindow')}: {formatTimeWindow(item.windowStartSeconds, item.windowEndSeconds, false)} · {t('cryptoTailStrategy.list.priceRange')}: {formatPriceRange(item.minPrice, item.maxPrice)}
+                    </div>
+                    <div style={{ padding: '8px 12px', display: 'flex', justifyContent: 'space-around', alignItems: 'center' }}>
+                      <Tooltip title={t('cryptoTailStrategy.list.edit')}>
+                        <div onClick={() => openEditModal(item)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                          <EditOutlined style={{ fontSize: '18px', color: '#52c41a' }} />
+                          <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('cryptoTailStrategy.list.edit')}</span>
+                        </div>
+                      </Tooltip>
+                      <Tooltip title={t('cryptoTailStrategy.list.viewTriggers')}>
+                        <div onClick={() => openTriggers(item.id)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                          <UnorderedListOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                          <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('cryptoTailStrategy.list.viewTriggers')}</span>
+                        </div>
+                      </Tooltip>
+                      <Tooltip title={t('cryptoTailStrategy.list.viewPnlCurve')}>
+                        <div onClick={() => openPnlCurve(item)} style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                          <LineChartOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                          <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('cryptoTailStrategy.list.viewPnlCurve')}</span>
+                        </div>
+                      </Tooltip>
+                      <Popconfirm title={t('cryptoTailStrategy.list.deleteConfirm')} onConfirm={() => handleDelete(item.id)} okText={t('common.confirm')} cancelText={t('common.cancel')}>
+                        <Tooltip title={t('cryptoTailStrategy.list.delete')}>
+                          <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                            <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
+                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('cryptoTailStrategy.list.delete')}</span>
+                          </div>
+                        </Tooltip>
+                      </Popconfirm>
+                    </div>
+                  </Card>
+                )
+              })}
            </div>
          ) : (
            <Table
@@ -706,7 +829,7 @@ const CryptoTailStrategyList: React.FC = () => {
              columns={columns}
              dataSource={list}
              pagination={{ pageSize: 20 }}
-              scroll={{ x: 900 }}
+              scroll={{ x: 720 }}
            />
          )}
        </Spin>
@@ -735,6 +858,17 @@ const CryptoTailStrategyList: React.FC = () => {
        <p>{t('cryptoTailStrategy.redeemRequiredModal.description')}</p>
      </Modal>

+      <CryptoTailPnlCurveModal
+        open={pnlCurveModalOpen}
+        onClose={() => setPnlCurveModalOpen(false)}
+        data={pnlCurveData}
+        loading={pnlCurveLoading}
+        strategyName={pnlCurveStrategyName}
+        preset={pnlCurvePreset}
+        onPresetChange={setPnlCurvePreset}
+        onRefresh={loadPnlCurve}
+      />
+
      <Modal
        title={editingId ? t('cryptoTailStrategy.form.update') : t('cryptoTailStrategy.form.create')}
        open={formModalOpen}
@@ -832,7 +966,7 @@ const CryptoTailStrategyList: React.FC = () => {
                </Form.Item>
              ) : (
                <Form.Item name="amountValue" label={t('cryptoTailStrategy.form.fixedUsdc')} rules={[{ required: true }]}>
-                  <InputNumber min={1} style={{ width: '100%' }} addonAfter="USDC" stringMode />
+                  <InputNumber min={1} style={{ width: '100%' }} addonBefore="$" stringMode />
                </Form.Item>
              )
            }
@@ -977,7 +1111,7 @@ const CryptoTailStrategyList: React.FC = () => {
                        dataIndex: 'amountUsdc',
                        key: 'amountUsdc',
                        width: 110,
-                        render: (v: string) => `${formatUSDC(v)} USDC`
+                        render: (v: string) => `$${formatUSDC(v)}`
                      },
                      {
                        title: t('cryptoTailStrategy.triggerRecords.realizedPnl'),
@@ -1052,7 +1186,7 @@ const CryptoTailStrategyList: React.FC = () => {
                        dataIndex: 'amountUsdc',
                        key: 'amountUsdc',
                        width: 110,
-                        render: (v: string) => `${formatUSDC(v)} USDC`
+                        render: (v: string) => `$${formatUSDC(v)}`
                      },
                      {
                        title: t('cryptoTailStrategy.triggerRecords.failReason'),
@@ -1,7 +1,7 @@
 import { useEffect, useState } from 'react'
 import { useNavigate } from 'react-router-dom'
-import { Card, Table, Button, Space, Tag, Popconfirm, message, List, Empty, Spin, Divider, Typography, Modal, Descriptions, Statistic, Row, Col } from 'antd'
-import { PlusOutlined, EditOutlined, DeleteOutlined, GlobalOutlined, EyeOutlined, ReloadOutlined, WalletOutlined } from '@ant-design/icons'
+import { Card, Table, Button, Space, Tag, Popconfirm, message, List, Empty, Spin, Divider, Typography, Modal, Descriptions, Statistic, Row, Col, Tooltip, Badge } from 'antd'
+import { PlusOutlined, EditOutlined, DeleteOutlined, GlobalOutlined, EyeOutlined, ReloadOutlined, WalletOutlined, CopyOutlined, LineChartOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import { apiService } from '../services/api'
 import type { Leader, LeaderBalanceResponse } from '../types'
@@ -225,11 +225,11 @@ const LeaderList: React.FC = () => {
      title: t('leaderList.leaderName'),
      dataIndex: 'leaderName',
      key: 'leaderName',
-      width: 150,
+      width: 200,
      render: (text: string, record: Leader) => (
        <Space direction="vertical" size={0}>
          <Text strong style={{ fontSize: '14px' }}>{text || `Leader ${record.id}`}</Text>
-          <Text type="secondary" style={{ fontSize: '12px' }}>{record.leaderAddress}</Text>
+          <Text type="secondary" style={{ fontSize: '12px', fontFamily: 'monospace' }}>{record.leaderAddress}</Text>
        </Space>
      )
    },
@@ -237,76 +237,155 @@ const LeaderList: React.FC = () => {
      title: t('leaderList.remark'),
      dataIndex: 'remark',
      key: 'remark',
-      width: 200,
+      width: 180,
      ellipsis: true,
      render: (remark: string | undefined) => {
        if (!remark) return <Text type="secondary">-</Text>
-        return <Text ellipsis={{ tooltip: remark }} style={{ maxWidth: 180 }}>{remark}</Text>
+        return <Text ellipsis={{ tooltip: remark }} style={{ maxWidth: 160 }}>{remark}</Text>
      }
    },
    {
      title: t('leaderDetail.availableBalance'),
      key: 'balance',
-      width: 150,
+      width: 180,
      render: (_: any, record: Leader) => {
        const balance = balanceMap[record.id]
        if (!balance) return <Spin size="small" />
-        const displayText = balance.available === '-' ? '-' : `${formatUSDC(balance.available)} USDC`
-        return <Text style={{ color: '#1890ff', fontSize: '14px' }}>{displayText}</Text>
+        return (
+          <Space direction="vertical" size={0}>
+            <Text style={{ color: '#52c41a', fontSize: '14px', fontWeight: '500' }}>
+              {balance.available === '-' ? '-' : `$${formatUSDC(balance.available)}`}
+            </Text>
+            <Text type="secondary" style={{ fontSize: '12px' }}>
+              {t('leaderDetail.positionBalance')}: {formatUSDC(balance.position)}
+            </Text>
+          </Space>
+        )
      }
    },
-    {
-      title: t('leaderList.copyTradingCount'),
-      dataIndex: 'copyTradingCount',
-      key: 'copyTradingCount',
-      width: 100,
-      render: (count: number, record: Leader) => (
-        <Button
-          type="link"
-          size="small"
-          onClick={() => navigate(`/copy-trading?leaderId=${record.id}`)}
-          disabled={count === 0}
-          style={{ padding: 0 }}
-        >
-          <Tag color="cyan">{count}</Tag>
-        </Button>
-      )
-    },
-    {
-      title: t('leaderList.backtestCount'),
-      dataIndex: 'backtestCount',
-      key: 'backtestCount',
-      width: 100,
-      render: (count: number, record: Leader) => (
-        <Button
-          type="link"
-          size="small"
-          onClick={() => navigate(`/backtest?leaderId=${record.id}`)}
-          disabled={count === 0}
-          style={{ padding: 0 }}
-        >
-          <Tag color="purple">{count}</Tag>
-        </Button>
-      )
-    },
    {
      title: t('common.actions'),
      key: 'action',
-      width: isMobile ? 180 : 250,
+      width: 200,
      fixed: 'right' as const,
      render: (_: any, record: Leader) => (
-        <Space size="small" wrap>
-          <Button type="link" size="small" icon={<EyeOutlined />} onClick={() => handleShowDetail(record)}>
-            {t('common.viewDetail')}
-          </Button>
+        <Space size={4}>
+          <Tooltip title={t('common.viewDetail')}>
+            <div
+              onClick={() => handleShowDetail(record)}
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                width: '32px',
+                height: '32px',
+                cursor: 'pointer',
+                borderRadius: '6px',
+                transition: 'background-color 0.2s'
+              }}
+              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
+              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+            >
+              <EyeOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+            </div>
+          </Tooltip>
+
          {record.website && (
-            <Button type="link" size="small" icon={<GlobalOutlined />} onClick={() => window.open(record.website, '_blank', 'noopener,noreferrer')}>
-              {t('leaderList.openWebsite')}
-            </Button>
+            <Tooltip title={t('leaderList.openWebsite')}>
+              <div
+                onClick={() => window.open(record.website, '_blank', 'noopener,noreferrer')}
+                style={{
+                  display: 'flex',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                  width: '32px',
+                  height: '32px',
+                  cursor: 'pointer',
+                  borderRadius: '6px',
+                  transition: 'background-color 0.2s'
+                }}
+                onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
+                onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+              >
+                <GlobalOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+              </div>
+            </Tooltip>
          )}
-          <Button type="link" size="small" icon={<EditOutlined />} onClick={() => navigate(`/leaders/edit?id=${record.id}`)}>
-            {t('common.edit')}
-          </Button>
+
+          <Tooltip title={t('common.edit')}>
+            <div
+              onClick={() => navigate(`/leaders/edit?id=${record.id}`)}
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                width: '32px',
+                height: '32px',
+                cursor: 'pointer',
+                borderRadius: '6px',
+                transition: 'background-color 0.2s'
+              }}
+              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
+              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+            >
+              <EditOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+            </div>
+          </Tooltip>
+
+          <Tooltip title={`${t('leaderList.viewCopyTradings')} (${record.copyTradingCount})`}>
+            <div
+              onClick={() => {
+                if (record.copyTradingCount > 0) {
+                  navigate(`/copy-trading?leaderId=${record.id}`)
+                }
+              }}
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                width: '32px',
+                height: '32px',
+                cursor: record.copyTradingCount === 0 ? 'not-allowed' : 'pointer',
+                borderRadius: '6px',
+                opacity: record.copyTradingCount === 0 ? 0.4 : 1,
+                transition: 'background-color 0.2s'
+              }}
+              onMouseEnter={(e) => record.copyTradingCount > 0 && (e.currentTarget.style.backgroundColor = '#f0f0f0')}
+              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+            >
+              <Badge count={record.copyTradingCount} size="small" offset={[-4, -4]}>
+                <CopyOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+              </Badge>
+            </div>
+          </Tooltip>
+
+          <Tooltip title={`${t('leaderList.viewBacktests')} (${record.backtestCount})`}>
+            <div
+              onClick={() => {
+                if (record.backtestCount > 0) {
+                  navigate(`/backtest?leaderId=${record.id}`)
+                }
+              }}
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                width: '32px',
+                height: '32px',
+                cursor: record.backtestCount === 0 ? 'not-allowed' : 'pointer',
+                borderRadius: '6px',
+                opacity: record.backtestCount === 0 ? 0.4 : 1,
+                transition: 'background-color 0.2s'
+              }}
+              onMouseEnter={(e) => record.backtestCount > 0 && (e.currentTarget.style.backgroundColor = '#f0f0f0')}
+              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+            >
+              <Badge count={record.backtestCount} size="small" offset={[-4, -4]}>
+                <LineChartOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+              </Badge>
+            </div>
+          </Tooltip>
+
          <Popconfirm
            title={t('leaderList.deleteConfirm')}
            description={record.copyTradingCount > 0 ? t('leaderList.deleteConfirmDesc', { count: record.copyTradingCount }) : undefined}
@@ -314,9 +393,24 @@ const LeaderList: React.FC = () => {
            okText={t('common.confirm')}
            cancelText={t('common.cancel')}
          >
-            <Button type="link" size="small" danger icon={<DeleteOutlined />}>
-              {t('common.delete')}
-            </Button>
+            <Tooltip title={t('common.delete')}>
+              <div
+                style={{
+                  display: 'flex',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                  width: '32px',
+                  height: '32px',
+                  cursor: 'pointer',
+                  borderRadius: '6px',
+                  transition: 'background-color 0.2s'
+                }}
+                onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#fff1f0'}
+                onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+              >
+                <DeleteOutlined style={{ fontSize: '16px', color: '#ff4d4f' }} />
+              </div>
+            </Tooltip>
          </Popconfirm>
        </Space>
      )
@@ -327,9 +421,9 @@ const LeaderList: React.FC = () => {
    <div>
      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px', flexWrap: 'wrap', gap: '12px' }}>
        <h2 style={{ margin: 0, fontSize: isMobile ? '20px' : '24px' }}>{t('leaderList.title')}</h2>
-        <Button type="primary" icon={<PlusOutlined />} onClick={() => navigate('/leaders/add')} size={isMobile ? 'middle' : 'large'} style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}>
-          {t('leaderList.addLeader')}
-        </Button>
+        <Tooltip title={t('leaderList.addLeader')}>
+          <Button type="primary" icon={<PlusOutlined />} onClick={() => navigate('/leaders/add')} size={isMobile ? 'middle' : 'large'} style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }} />
+        </Tooltip>
      </div>

      <Card style={{ borderRadius: '12px', boxShadow: '0 2px 8px rgba(0,0,0,0.08)', border: '1px solid #e8e8e8' }} bodyStyle={{ padding: isMobile ? '12px' : '24px' }}>
@@ -348,69 +442,145 @@ const LeaderList: React.FC = () => {
                  const balance = balanceMap[leader.id]

                  return (
-                    <Card key={leader.id} style={{ marginBottom: '16px', borderRadius: '12px', boxShadow: '0 2px 6px rgba(0,0,0,0.06)', border: '1px solid #f0f0f0' }} bodyStyle={{ padding: '16px' }}>
-                      <div style={{ marginBottom: '12px' }}>
-                        <div style={{ fontSize: '16px', fontWeight: 'bold', marginBottom: '6px', color: '#1890ff' }}>
-                          {leader.leaderName || `Leader ${leader.id}`}
+                    <Card
+                      key={leader.id}
+                      style={{
+                        marginBottom: '10px',
+                        borderRadius: '10px',
+                        boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
+                        border: '1px solid #e8e8e8',
+                        overflow: 'hidden'
+                      }}
+                      bodyStyle={{ padding: '0' }}
+                    >
+                      {/* 头部区域 - 名称和地址 */}
+                      <div style={{
+                        padding: '10px 12px',
+                        background: 'var(--ant-color-primary, #1677ff)',
+                        color: '#fff'
+                      }}>
+                        <div style={{ fontSize: '15px', fontWeight: '600', marginBottom: '2px', display: 'flex', alignItems: 'center', justifyContent: 'space-between' }}>
+                          <span>{leader.leaderName || `Leader ${leader.id}`}</span>
+                          {leader.website && (
+                            <GlobalOutlined
+                              style={{ fontSize: '13px', cursor: 'pointer', opacity: 0.8 }}
+                              onClick={() => window.open(leader.website, '_blank', 'noopener,noreferrer')}
+                            />
+                          )}
                        </div>
-                        <div style={{ fontSize: '12px', color: '#666', fontFamily: 'monospace', wordBreak: 'break-all' }}>
+                        <div style={{ fontSize: '10px', opacity: '0.85', fontFamily: 'monospace', wordBreak: 'break-all' }}>
                          {leader.leaderAddress}
                        </div>
                      </div>

-                      {balance && (
-                        <div style={{ marginBottom: '12px', padding: '12px', backgroundColor: '#f6ffed', borderRadius: '8px', border: '1px solid #b7eb8f' }}>
-                          <div style={{ fontSize: '13px', color: '#52c41a', fontWeight: 'bold', marginBottom: '4px' }}>
-                            {t('leaderDetail.availableBalance')}: {balance.available === '-' ? '-' : `${formatUSDC(balance.available)} USDC`}
+                      {/* 资产区域 - 常驻显示 */}
+                      <div style={{
+                        padding: '8px 12px',
+                        backgroundColor: '#fafafa',
+                        borderBottom: '1px solid #f0f0f0',
+                        minHeight: '42px',
+                        display: 'flex',
+                        alignItems: 'center'
+                      }}>
+                        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', width: '100%' }}>
+                          <div>
+                            <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
+                              {t('leaderDetail.availableBalance')}
+                            </div>
+                            <div style={{ fontSize: '14px', fontWeight: '600', color: '#52c41a' }}>
+                              {balance?.available && balance.available !== '-' ? `$${formatUSDC(balance.available)}` : '-'}
+                            </div>
                          </div>
-                          <div style={{ fontSize: '11px', color: '#666' }}>
-                            {t('leaderDetail.positionBalance')}: {formatUSDC(balance.position)}
+                          <div style={{ textAlign: 'right' }}>
+                            <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
+                              {t('leaderDetail.positionBalance')}
+                            </div>
+                            <div style={{ fontSize: '14px', fontWeight: '500', color: '#722ed1' }}>
+                              {balance?.position && balance.position !== '-' ? formatUSDC(balance.position) : '-'}
+                            </div>
                          </div>
                        </div>
-                      )}
-
-                      <Divider style={{ margin: '12px 0' }} />
-
-                      <div style={{ display: 'flex', gap: '8px', marginBottom: '12px', flexWrap: 'wrap' }}>
-                        <Button
-                          type="default"
-                          size="small"
-                          onClick={() => navigate(`/copy-trading?leaderId=${leader.id}`)}
-                          disabled={leader.copyTradingCount === 0}
-                          style={{ borderRadius: '6px', padding: '8px 16px' }}
-                        >
-                          {t('leaderList.viewCopyTradings')} ({leader.copyTradingCount})
-                        </Button>
-                        <Button
-                          type="default"
-                          size="small"
-                          onClick={() => navigate(`/backtest?leaderId=${leader.id}`)}
-                          disabled={leader.backtestCount === 0}
-                          style={{ borderRadius: '6px', padding: '8px 16px' }}
-                        >
-                          {t('leaderList.viewBacktests')} ({leader.backtestCount})
-                        </Button>
                      </div>

+                      {/* 备注区域 */}
                      {leader.remark && (
-                        <div style={{ marginBottom: '12px' }}>
-                          <Text type="secondary" style={{ fontSize: '12px' }}>{t('leaderList.remark')}：</Text>
-                          <Text style={{ fontSize: '12px', marginLeft: '4px' }}>{leader.remark}</Text>
+                        <div style={{
+                          padding: '6px 12px',
+                          backgroundColor: '#fffbe6',
+                          borderBottom: '1px solid #ffe58f',
+                          fontSize: '11px',
+                          color: '#8c8c8c'
+                        }}>
+                          <span style={{ color: '#d48806' }}>{t('leaderList.remark')}：</span>
+                          <span>{leader.remark}</span>
                        </div>
                      )}

-                      <div style={{ display: 'flex', gap: '8px', flexWrap: 'wrap' }}>
-                        <Button type="primary" size="small" icon={<EyeOutlined />} onClick={() => handleShowDetail(leader)} style={{ flex: 1, minWidth: '80px', borderRadius: '6px', padding: '8px 16px' }}>
-                          {t('common.viewDetail')}
-                        </Button>
-                        {leader.website && (
-                          <Button type="default" size="small" icon={<GlobalOutlined />} onClick={() => window.open(leader.website, '_blank', 'noopener,noreferrer')} style={{ flex: 1, minWidth: '80px', borderRadius: '6px', padding: '8px 16px' }}>
-                            {t('leaderList.openWebsite')}
-                          </Button>
-                        )}
-                        <Button type="default" size="small" icon={<EditOutlined />} onClick={() => navigate(`/leaders/edit?id=${leader.id}`)} style={{ flex: 1, minWidth: '80px', borderRadius: '6px', padding: '8px 16px' }}>
-                          {t('common.edit')}
-                        </Button>
+                      {/* 图标操作栏 */}
+                      <div style={{
+                        padding: '8px 12px',
+                        display: 'flex',
+                        justifyContent: 'space-around',
+                        alignItems: 'center'
+                      }}>
+                        <Tooltip title={t('common.viewDetail')}>
+                          <div
+                            onClick={() => handleShowDetail(leader)}
+                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
+                          >
+                            <EyeOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.viewDetail')}</span>
+                          </div>
+                        </Tooltip>
+
+                        <Tooltip title={t('common.edit')}>
+                          <div
+                            onClick={() => navigate(`/leaders/edit?id=${leader.id}`)}
+                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
+                          >
+                            <EditOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.edit')}</span>
+                          </div>
+                        </Tooltip>
+
+                        <Tooltip title={t('leaderList.viewCopyTradings')}>
+                          <div
+                            onClick={() => navigate(`/copy-trading?leaderId=${leader.id}`)}
+                            style={{
+                              display: 'flex',
+                              flexDirection: 'column',
+                              alignItems: 'center',
+                              cursor: leader.copyTradingCount === 0 ? 'not-allowed' : 'pointer',
+                              padding: '4px 8px',
+                              opacity: leader.copyTradingCount === 0 ? 0.4 : 1
+                            }}
+                          >
+                            <Badge count={leader.copyTradingCount} size="small" offset={[-2, -2]}>
+                              <CopyOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                            </Badge>
+                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('leaderList.viewCopyTradings')}</span>
+                          </div>
+                        </Tooltip>
+
+                        <Tooltip title={t('leaderList.viewBacktests')}>
+                          <div
+                            onClick={() => navigate(`/backtest?leaderId=${leader.id}`)}
+                            style={{
+                              display: 'flex',
+                              flexDirection: 'column',
+                              alignItems: 'center',
+                              cursor: leader.backtestCount === 0 ? 'not-allowed' : 'pointer',
+                              padding: '4px 8px',
+                              opacity: leader.backtestCount === 0 ? 0.4 : 1
+                            }}
+                          >
+                            <Badge count={leader.backtestCount} size="small" offset={[-2, -2]}>
+                              <LineChartOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                            </Badge>
+                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('leaderList.viewBacktests')}</span>
+                          </div>
+                        </Tooltip>
+
                        <Popconfirm
                          title={t('leaderList.deleteConfirm')}
                          description={leader.copyTradingCount > 0 ? t('leaderList.deleteConfirmDesc', { count: leader.copyTradingCount }) : undefined}
@@ -418,9 +588,12 @@ const LeaderList: React.FC = () => {
                          okText={t('common.confirm')}
                          cancelText={t('common.cancel')}
                        >
-                          <Button type="primary" danger size="small" icon={<DeleteOutlined />} style={{ flex: 1, minWidth: '80px', borderRadius: '6px', padding: '8px 16px' }}>
-                            {t('common.delete')}
-                          </Button>
+                          <Tooltip title={t('common.delete')}>
+                            <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                              <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
+                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.delete')}</span>
+                            </div>
+                          </Tooltip>
                        </Popconfirm>
                      </div>
                    </Card>
@@ -527,7 +700,7 @@ const LeaderList: React.FC = () => {
                        value={parseFloat(detailBalance.availableBalance)}
                        precision={4}
                        valueStyle={{ color: '#1890ff' }}
-                        suffix="USDC"
+                        prefix="$"
                        formatter={(value) => formatUSDC(value?.toString() || '0')}
                      />
                    </Card>
@@ -539,7 +712,7 @@ const LeaderList: React.FC = () => {
                        value={parseFloat(detailBalance.positionBalance)}
                        precision={4}
                        valueStyle={{ color: '#722ed1' }}
-                        suffix="USDC"
+                        prefix="$"
                        formatter={(value) => formatUSDC(value?.toString() || '0')}
                      />
                    </Card>
@@ -551,7 +724,7 @@ const LeaderList: React.FC = () => {
                        value={parseFloat(detailBalance.totalBalance)}
                        precision={4}
                        valueStyle={{ color: '#52c41a', fontWeight: 'bold' }}
-                        suffix="USDC"
+                        prefix="$"
                        formatter={(value) => formatUSDC(value?.toString() || '0')}
                      />
                    </Card>
@@ -0,0 +1,718 @@
+import React, { useEffect, useState, useCallback } from 'react'
+import { Card, Table, Button, Space, Tag, Popconfirm, message, Typography, Modal, Form, Input, Switch, Tooltip, Row, Col, Tabs } from 'antd'
+import { PlusOutlined, EditOutlined, DeleteOutlined, SendOutlined, ReloadOutlined, CheckOutlined, RobotOutlined, FormOutlined } from '@ant-design/icons'
+import { useTranslation } from 'react-i18next'
+import { apiService } from '../services/api'
+import type { NotificationConfig, NotificationConfigRequest, NotificationConfigUpdateRequest, NotificationTemplate, TemplateTypeInfo, TemplateVariablesResponse, TemplateVariable } from '../types'
+import { useMediaQuery } from 'react-responsive'
+import { TelegramConfigForm } from '../components/notifications'
+import TextArea from 'antd/es/input/TextArea'
+
+const { Title, Text, Paragraph } = Typography
+
+const variableTagStyle: React.CSSProperties = {
+  display: 'inline-flex',
+  alignItems: 'center',
+  cursor: 'pointer',
+  marginBottom: 6,
+  marginRight: 6,
+  borderRadius: 6,
+  padding: '4px 10px',
+  fontSize: 12,
+  transition: 'all 0.2s ease',
+  border: '1px solid #e8e8e8',
+  background: '#ffffff',
+  color: 'rgba(0, 0, 0, 0.65)',
+}
+
+const variableTagHoverStyle: React.CSSProperties = {
+  borderColor: '#1890ff',
+  background: '#e6f7ff',
+  color: '#1890ff',
+  transform: 'translateY(-1px)',
+  boxShadow: '0 2px 4px rgba(24, 144, 255, 0.2)',
+}
+
+/**
+ * 变量分类标签映射
+ */
+const CATEGORY_LABELS: Record<string, string> = {
+  common: 'notificationSettings.templates.commonVariables',
+  order: 'notificationSettings.templates.orderVariables',
+  copy_trading: 'notificationSettings.templates.copyTradingVariables',
+  redeem: 'notificationSettings.templates.redeemVariables',
+  error: 'notificationSettings.templates.errorVariables',
+  filter: 'notificationSettings.templates.filterVariables',
+  strategy: 'notificationSettings.templates.strategyVariables'
+}
+
+const NotificationSettingsPage: React.FC = () => {
+  const { t } = useTranslation()
+  const isMobile = useMediaQuery({ maxWidth: 768 })
+
+  // 机器人配置相关状态
+  const [configs, setConfigs] = useState<NotificationConfig[]>([])
+  const [loading, setLoading] = useState(false)
+  const [modalVisible, setModalVisible] = useState(false)
+  const [editingConfig, setEditingConfig] = useState<NotificationConfig | null>(null)
+  const [form] = Form.useForm()
+  const [testLoading, setTestLoading] = useState(false)
+
+  // 模板配置相关状态
+  const [templateTypes, setTemplateTypes] = useState<TemplateTypeInfo[]>([])
+  const [selectedTemplateType, setSelectedTemplateType] = useState<string>('ORDER_SUCCESS')
+  const [currentTemplate, setCurrentTemplate] = useState<NotificationTemplate | null>(null)
+  const [templateVariables, setTemplateVariables] = useState<TemplateVariablesResponse | null>(null)
+  const [templateContent, setTemplateContent] = useState('')
+  const [testTemplateLoading, setTestTemplateLoading] = useState(false)
+
+  // 加载机器人配置
+  useEffect(() => {
+    fetchConfigs()
+  }, [])
+
+  // 加载模板类型
+  useEffect(() => {
+    fetchTemplateTypes()
+  }, [])
+
+  // 当选中的模板类型改变时，加载模板详情和变量
+  useEffect(() => {
+    if (selectedTemplateType) {
+      fetchTemplateDetail(selectedTemplateType)
+      fetchTemplateVariables(selectedTemplateType)
+    }
+  }, [selectedTemplateType])
+
+  const fetchConfigs = async () => {
+    setLoading(true)
+    try {
+      const response = await apiService.notifications.list({ type: 'telegram' })
+      if (response.data.code === 0 && response.data.data) {
+        setConfigs(response.data.data)
+      } else {
+        message.error(response.data.msg || t('notificationSettings.fetchFailed'))
+      }
+    } catch (error: any) {
+      message.error(error.message || t('notificationSettings.fetchFailed'))
+    } finally {
+        setLoading(false)
+      }
+  }
+
+  const fetchTemplateTypes = async () => {
+    try {
+      const response = await apiService.notifications.getTemplateTypes()
+      if (response.data.code === 0 && response.data.data) {
+        setTemplateTypes(response.data.data)
+      }
+    } catch (error) {
+        console.error('获取模板类型失败:', error)
+      }
+  }
+
+  const fetchTemplateDetail = async (templateType: string) => {
+    try {
+      const response = await apiService.notifications.getTemplateDetail({ templateType })
+      if (response.data.code === 0 && response.data.data) {
+        setCurrentTemplate(response.data.data)
+        setTemplateContent(response.data.data.templateContent)
+      }
+    } catch (error) {
+        console.error('获取模板详情失败:', error)
+      }
+  }
+
+  const fetchTemplateVariables = async (templateType: string) => {
+    try {
+      const response = await apiService.notifications.getTemplateVariables({ templateType })
+      if (response.data.code === 0 && response.data.data) {
+        setTemplateVariables(response.data.data)
+      }
+    } catch (error) {
+        console.error('获取模板变量失败:', error)
+      }
+  }
+
+  // 机器人配置相关方法
+  const handleCreate = () => {
+    setEditingConfig(null)
+    form.resetFields()
+    form.setFieldsValue({
+      type: 'telegram',
+      enabled: true,
+      config: {
+        botToken: '',
+        chatIds: []
+      }
+    })
+    setModalVisible(true)
+  }
+
+  const handleEdit = (config: NotificationConfig) => {
+    setEditingConfig(config)
+    let botToken = ''
+    let chatIds = ''
+
+    if (config.config) {
+      if ('data' in config.config && config.config.data) {
+        const data = config.config.data as any
+        botToken = data.botToken || ''
+        if (data.chatIds) {
+          if (Array.isArray(data.chatIds)) {
+            chatIds = data.chatIds.join(',')
+          } else if (typeof data.chatIds === 'string') {
+            chatIds = data.chatIds
+          }
+        }
+      } else {
+        if ('botToken' in config.config) {
+          botToken = (config.config as any).botToken || ''
+        }
+        if ('chatIds' in config.config) {
+          const ids = (config.config as any).chatIds
+          if (Array.isArray(ids)) {
+            chatIds = ids.join(',')
+          } else if (typeof ids === 'string') {
+            chatIds = ids
+          }
+        }
+      }
+    }
+
+    form.setFieldsValue({
+      type: config.type,
+      name: config.name,
+      enabled: config.enabled,
+      config: {
+        botToken: botToken,
+        chatIds: chatIds
+      }
+    })
+    setModalVisible(true)
+  }
+
+  const handleDelete = async (id: number) => {
+    try {
+      const response = await apiService.notifications.delete({ id })
+      if (response.data.code === 0) {
+        message.success(t('notificationSettings.deleteSuccess'))
+        fetchConfigs()
+      } else {
+        message.error(response.data.msg || t('notificationSettings.deleteFailed'))
+      }
+    } catch (error: any) {
+      message.error(error.message || t('notificationSettings.deleteFailed'))
+    }
+  }
+
+  const handleUpdateEnabled = async (id: number, enabled: boolean) => {
+    try {
+      const response = await apiService.notifications.updateEnabled({ id, enabled })
+      if (response.data.code === 0) {
+        message.success(enabled ? t('notificationSettings.enableSuccess') : t('notificationSettings.disableSuccess'))
+        fetchConfigs()
+      } else {
+        message.error(response.data.msg || t('notificationSettings.updateStatusFailed'))
+      }
+    } catch (error: any) {
+      message.error(error.message || t('notificationSettings.updateStatusFailed'))
+    }
+  }
+
+  const handleTest = async () => {
+    setTestLoading(true)
+    try {
+      const response = await apiService.notifications.test({ message: '这是一条测试消息' })
+      if (response.data.code === 0 && response.data.data) {
+        message.success(t('notificationSettings.testSuccess'))
+      } else {
+        message.error(response.data.msg || t('notificationSettings.testFailed'))
+      }
+    } catch (error: any) {
+      message.error(error.message || t('notificationSettings.testFailed'))
+    } finally {
+      setTestLoading(false)
+    }
+  }
+
+  const handleSubmit = async () => {
+    try {
+      const values = await form.validateFields()
+      const chatIds = typeof values.config.chatIds === 'string'
+        ? values.config.chatIds.split(',').map((id: string) => id.trim()).filter((id: string) => id)
+        : values.config.chatIds || []
+
+      const configData: NotificationConfigRequest | NotificationConfigUpdateRequest = {
+        type: values.type,
+        name: values.name,
+        enabled: values.enabled,
+        config: {
+          botToken: values.config.botToken,
+          chatIds: chatIds
+        }
+      }
+
+      if (editingConfig?.id) {
+        const updateData = {
+          ...configData,
+          id: editingConfig.id
+        } as NotificationConfigUpdateRequest
+        const response = await apiService.notifications.update(updateData)
+        if (response.data.code === 0) {
+          message.success(t('notificationSettings.updateSuccess'))
+          setModalVisible(false)
+          fetchConfigs()
+        } else {
+          message.error(response.data.msg || t('notificationSettings.updateFailed'))
+        }
+      } else {
+        const response = await apiService.notifications.create(configData)
+        if (response.data.code === 0) {
+          message.success(t('notificationSettings.createSuccess'))
+          setModalVisible(false)
+          fetchConfigs()
+        } else {
+          message.error(response.data.msg || t('notificationSettings.createFailed'))
+        }
+      }
+    } catch (error: any) {
+      if (error.errorFields) {
+        return
+      }
+      message.error(error.message || t('message.error'))
+    }
+  }
+
+  const getConfigFormComponent = (type: string) => {
+    switch (type?.toLowerCase()) {
+      case 'telegram':
+        return <TelegramConfigForm form={form} />
+      default:
+        return null
+    }
+  }
+
+  // 模板配置相关方法
+  const handleTemplateTypeChange = (type: string) => {
+    setSelectedTemplateType(type)
+  }
+
+  const handleTemplateContentChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
+    setTemplateContent(e.target.value)
+  }
+
+  const handleSaveTemplate = async () => {
+    try {
+      const response = await apiService.notifications.updateTemplate({
+        templateType: selectedTemplateType,
+        templateContent: templateContent
+      })
+      if (response.data.code === 0) {
+        message.success(t('notificationSettings.templates.saveSuccess'))
+        fetchTemplateDetail(selectedTemplateType)
+      } else {
+        message.error(response.data.msg || t('notificationSettings.templates.saveFailed'))
+      }
+    } catch (error: any) {
+      message.error(error.message || t('notificationSettings.templates.saveFailed'))
+    }
+  }
+
+  const handleResetTemplate = async () => {
+    try {
+      const response = await apiService.notifications.resetTemplate({
+        templateType: selectedTemplateType
+      })
+      if (response.data.code === 0) {
+        message.success(t('notificationSettings.templates.resetSuccess'))
+        fetchTemplateDetail(selectedTemplateType)
+      } else {
+        message.error(response.data.msg || t('notificationSettings.templates.resetFailed'))
+      }
+    } catch (error: any) {
+      message.error(error.message || t('notificationSettings.templates.resetFailed'))
+    }
+  }
+
+  const handleTestTemplate = async () => {
+    setTestTemplateLoading(true)
+    try {
+      const response = await apiService.notifications.testTemplate({
+        templateType: selectedTemplateType,
+        templateContent: templateContent
+      })
+      if (response.data.code === 0 && response.data.data) {
+        message.success(t('notificationSettings.templates.testSuccess'))
+      } else {
+        message.error(response.data.msg || t('notificationSettings.templates.testFailed'))
+      }
+    } catch (error: any) {
+      message.error(error.message || t('notificationSettings.templates.testFailed'))
+    } finally {
+      setTestTemplateLoading(false)
+    }
+  }
+
+  const handleCopyVariable = useCallback((variable: string) => {
+    const text = `{{${variable}}}`
+
+    if (navigator.clipboard && window.isSecureContext) {
+      navigator.clipboard.writeText(text).then(() => {
+        message.success(t('notificationSettings.templates.copied'))
+      }).catch(() => {
+        fallbackCopy(text)
+      })
+    } else {
+      fallbackCopy(text)
+    }
+
+    function fallbackCopy(text: string) {
+      const textArea = document.createElement('textarea')
+      textArea.value = text
+      textArea.style.position = 'fixed'
+      textArea.style.left = '-9999px'
+      textArea.style.top = '-9999px'
+      document.body.appendChild(textArea)
+      textArea.focus()
+      textArea.select()
+      try {
+        document.execCommand('copy')
+        message.success(t('notificationSettings.templates.copied'))
+      } catch {
+        message.error(t('common.copyFailed'))
+      }
+      document.body.removeChild(textArea)
+    }
+  }, [t])
+
+  const [variableHoverKey, setVariableHoverKey] = useState<string | null>(null)
+
+  const renderVariableItem = (variable: TemplateVariable) => {
+    const isHover = variableHoverKey === variable.key
+    const label = t(`notificationSettings.templates.variableLabels.${variable.key}`)
+    const description = t(`notificationSettings.templates.variableDescriptions.${variable.key}`)
+    const variableElement = (
+      <span
+        role="button"
+        tabIndex={0}
+        style={{ ...variableTagStyle, ...(isHover && !isMobile ? variableTagHoverStyle : {}) }}
+        onClick={() => handleCopyVariable(variable.key)}
+        onMouseEnter={() => !isMobile && setVariableHoverKey(variable.key)}
+        onMouseLeave={() => !isMobile && setVariableHoverKey(null)}
+        onKeyDown={(e) => e.key === 'Enter' && handleCopyVariable(variable.key)}
+      >
+        <span style={{ fontFamily: 'monospace' }}>{label}</span>
+      </span>
+    )
+
+    if (isMobile) {
+      return (
+        <span key={variable.key} style={{ display: 'inline-block' }}>
+          {variableElement}
+        </span>
+      )
+    }
+
+    return (
+      <Tooltip key={variable.key} title={description || `{{${variable.key}}}`} placement="top">
+        {variableElement}
+      </Tooltip>
+    )
+  }
+
+  const renderVariablesPanel = () => {
+    if (!templateVariables) return null
+
+    return (
+      <Card
+        size="small"
+        title={
+          <span style={{ fontSize: 13, fontWeight: 500 }}>
+            {t('notificationSettings.templates.variables')}
+          </span>
+        }
+        style={{ height: '100%', borderRadius: 8 }}
+        bodyStyle={{ padding: '12px 16px', maxHeight: 420, overflowY: 'auto' }}
+      >
+        {templateVariables.categories.map(category => {
+          const categoryVariables = templateVariables.variables.filter(v => v.category === category.key)
+          if (categoryVariables.length === 0) return null
+          return (
+            <div key={category.key} style={{ marginBottom: 16 }}>
+              <Text type="secondary" style={{ marginBottom: 8, display: 'block', fontSize: 12 }}>
+                {t(CATEGORY_LABELS[category.key])}
+              </Text>
+              <div style={{ display: 'flex', flexWrap: 'wrap' }}>
+                {categoryVariables.sort((a, b) => a.sortOrder - b.sortOrder).map(renderVariableItem)}
+              </div>
+            </div>
+          )
+        })}
+        <Paragraph type="secondary" style={{ marginTop: 12, marginBottom: 0, fontSize: 11, textAlign: 'center' }}>
+          {t('notificationSettings.templates.clickToCopy')}
+        </Paragraph>
+      </Card>
+    )
+  }
+
+  // 机器人配置表格列
+  const configColumns = [
+    {
+      title: t('notificationSettings.configName'),
+      dataIndex: 'name',
+      key: 'name',
+    },
+    {
+      title: t('notificationSettings.type'),
+      dataIndex: 'type',
+      key: 'type',
+      render: (type: string) => <Tag color="blue">{type.toUpperCase()}</Tag>
+    },
+    {
+      title: t('notificationSettings.status'),
+      dataIndex: 'enabled',
+      key: 'enabled',
+      render: (enabled: boolean) => (
+        <Tag color={enabled ? 'green' : 'default'}>
+          {enabled ? t('notificationSettings.enabledStatus') : t('notificationSettings.disabledStatus')}
+        </Tag>
+      )
+    },
+    {
+      title: t('notificationSettings.chatIds'),
+      key: 'chatIds',
+      render: (_: any, record: NotificationConfig) => {
+        let chatIds: string[] = []
+        if (record.config) {
+          if ('data' in record.config && record.config.data) {
+            const data = (record.config as any).data
+            if (data.chatIds) {
+              if (Array.isArray(data.chatIds)) {
+                chatIds = data.chatIds.filter((id: any) => id && String(id).trim())
+              } else if (typeof data.chatIds === 'string') {
+                chatIds = data.chatIds.split(',').map((id: string) => id.trim()).filter((id: string) => id)
+              }
+            }
+          } else if ('chatIds' in record.config) {
+            const ids = (record.config as any).chatIds
+            if (Array.isArray(ids)) {
+              chatIds = ids.filter((id: any) => id && String(id).trim())
+            } else if (typeof ids === 'string') {
+              chatIds = (ids as string).split(',').map((id: string) => id.trim()).filter((id: string) => id)
+            }
+          }
+        }
+        return chatIds.length > 0 ? (
+          <Text type="secondary" style={{ fontSize: '12px' }}>
+            {chatIds.join(', ')}
+          </Text>
+        ) : (
+          <Text type="danger" style={{ fontSize: '12px' }}>{t('notificationSettings.chatIdsNotConfigured')}</Text>
+        )
+      }
+    },
+    {
+      title: t('common.actions'),
+      key: 'action',
+      width: isMobile ? 120 : 200,
+      render: (_: any, record: NotificationConfig) => (
+        <Space size="small" wrap>
+          <Button
+            type="link"
+            size="small"
+            icon={<EditOutlined />}
+            onClick={() => handleEdit(record)}
+          >
+            {t('notificationSettings.edit')}
+          </Button>
+          <Switch
+            checked={record.enabled}
+            size="small"
+            onChange={(checked) => handleUpdateEnabled(record.id!, checked)}
+          />
+          <Button
+            type="link"
+            size="small"
+            icon={<SendOutlined />}
+            loading={testLoading}
+            onClick={handleTest}
+          >
+            {t('notificationSettings.test')}
+          </Button>
+          <Popconfirm
+            title={t('notificationSettings.deleteConfirm')}
+            onConfirm={() => handleDelete(record.id!)}
+            okText={t('common.confirm')}
+            cancelText={t('common.cancel')}
+          >
+            <Button
+              type="link"
+              danger
+              size="small"
+              icon={<DeleteOutlined />}
+            >
+              {t('notificationSettings.delete')}
+            </Button>
+          </Popconfirm>
+        </Space>
+      )
+    }
+  ]
+
+  const templateTypeTabItems = templateTypes.map(type => ({
+    key: type.type,
+    label: (
+      <Tooltip title={t(`notificationSettings.templateTypeDescriptions.${type.type}`)} placement="top">
+        <span>{t(`notificationSettings.templateTypes.${type.type}`)}</span>
+      </Tooltip>
+    ),
+  }))
+
+  return (
+    <div>
+      <div style={{ marginBottom: '16px' }}>
+        <Title level={2} style={{ margin: 0 }}>{t('notificationSettings.title')}</Title>
+      </div>
+
+      {/* 机器人配置 */}
+      <Card
+        title={
+          <Space>
+            <RobotOutlined />
+            <span>{t('notificationSettings.botConfig')}</span>
+          </Space>
+        }
+        style={{ marginBottom: '16px' }}
+        extra={
+          <Button type="primary" icon={<PlusOutlined />} onClick={handleCreate}>
+            {t('notificationSettings.addConfig')}
+          </Button>
+        }
+      >
+        <Table
+          columns={configColumns}
+          dataSource={configs}
+          loading={loading}
+          rowKey="id"
+          pagination={false}
+          scroll={{ x: isMobile ? 600 : 'auto' }}
+        />
+      </Card>
+
+      {/* 模板配置 */}
+      <Card
+        title={
+          <Space>
+            <FormOutlined />
+            <span>{t('notificationSettings.templateConfig')}</span>
+          </Space>
+        }
+        style={{ marginBottom: '16px' }}
+      >
+        <Tabs
+          activeKey={selectedTemplateType}
+          onChange={handleTemplateTypeChange}
+          items={templateTypeTabItems}
+          style={{ marginBottom: 16 }}
+          tabBarStyle={{ marginBottom: 0 }}
+          type={isMobile ? 'line' : 'card'}
+          size={isMobile ? 'small' : 'middle'}
+        />
+        
+        <Row gutter={[16, 16]}>
+          <Col xs={24} sm={24} md={17}>
+            <Card size="small" bordered={false} style={{ background: '#fafafa', marginBottom: 12, borderRadius: 8 }} bodyStyle={{ padding: '10px 16px' }}>
+              <div style={{ display: 'flex', flexWrap: 'wrap', gap: 8, alignItems: 'center', justifyContent: 'space-between' }}>
+                <Space wrap size="small">
+                  <Text type="secondary" style={{ fontSize: 13 }}>{t('notificationSettings.templates.templateContent')}</Text>
+                  {currentTemplate && (
+                    <Tag color={currentTemplate.isDefault ? 'green' : 'blue'} style={{ margin: 0 }}>
+                      {currentTemplate.isDefault ? t('notificationSettings.templates.isDefault') : t('notificationSettings.templates.isCustom')}
+                    </Tag>
+                  )}
+                </Space>
+                <Space wrap size="small">
+                  <Popconfirm
+                    title={t('notificationSettings.templates.resetConfirm')}
+                    onConfirm={handleResetTemplate}
+                    okText={t('common.confirm')}
+                    cancelText={t('common.cancel')}
+                  >
+                    <Button size="small" icon={<ReloadOutlined />}>
+                      {t('notificationSettings.templates.resetToDefault')}
+                    </Button>
+                  </Popconfirm>
+                  <Button size="small" type="primary" icon={<CheckOutlined />} onClick={handleSaveTemplate}>
+                    {t('common.save')}
+                  </Button>
+                  <Button size="small" icon={<SendOutlined />} loading={testTemplateLoading} onClick={handleTestTemplate}>
+                    {t('notificationSettings.test')}
+                  </Button>
+                </Space>
+              </div>
+            </Card>
+            <TextArea
+              value={templateContent}
+              onChange={handleTemplateContentChange}
+              rows={isMobile ? 15 : 16}
+              style={{ fontFamily: 'monospace', fontSize: 13, borderRadius: 8, resize: 'none' }}
+              placeholder={t('notificationSettings.templates.contentPlaceholder')}
+            />
+          </Col>
+          <Col xs={24} sm={24} md={7}>
+            {renderVariablesPanel()}
+          </Col>
+        </Row>
+      </Card>
+
+      <Modal
+        title={editingConfig ? t('notificationSettings.editConfig') : t('notificationSettings.addConfig')}
+        open={modalVisible}
+        onOk={handleSubmit}
+        onCancel={() => setModalVisible(false)}
+        width={isMobile ? '90%' : 600}
+        okText={t('common.confirm')}
+        cancelText={t('common.cancel')}
+      >
+        <Form
+          form={form}
+          layout="vertical"
+        >
+          <Form.Item
+            name="type"
+            label={t('notificationSettings.type')}
+            rules={[{ required: true, message: t('notificationSettings.typeRequired') }]}
+          >
+            <Input disabled value="telegram" />
+          </Form.Item>
+          <Form.Item
+            name="name"
+            label={t('notificationSettings.configName')}
+            rules={[{ required: true, message: t('notificationSettings.configNameRequired') }]}
+          >
+            <Input placeholder={t('notificationSettings.configNamePlaceholder')} />
+          </Form.Item>
+          <Form.Item
+            name="enabled"
+            label={t('notificationSettings.enabled')}
+            valuePropName="checked"
+          >
+            <Switch />
+          </Form.Item>
+          <Form.Item shouldUpdate={(prevValues, currentValues) => {
+            return prevValues.type !== currentValues.type ||
+                   prevValues.config !== currentValues.config
+          }}>
+            {() => {
+              const currentType = form.getFieldValue('type') || 'telegram'
+              return getConfigFormComponent(currentType)
+            }}
+          </Form.Item>
+        </Form>
+      </Modal>
+    </div>
+  )
+}
+
+export default NotificationSettingsPage
@@ -118,7 +118,7 @@ const OrderList: React.FC = () => {
      key: 'pnl',
      render: (pnl: string | undefined) => pnl ? (
        <span style={{ color: pnl.startsWith('-') ? 'red' : 'green' }}>
-          {formatUSDC(pnl)} USDC
+          ${formatUSDC(pnl)}
        </span>
      ) : '-'
    },
@@ -695,7 +695,7 @@ const PositionList: React.FC = () => {
                        fontWeight: '500',
                        color: isProfit ? '#52c41a' : '#f5222d'
                      }}>
-                        {pnlNum >= 0 ? '+' : ''}{formatUSDC(position.pnl)} USDC
+                        {pnlNum >= 0 ? '+' : ''}${formatUSDC(position.pnl)}
                      </span>
                    </div>
                  )}
@@ -718,7 +718,7 @@ const PositionList: React.FC = () => {
                      <div style={{ display: 'flex', justifyContent: 'space-between', marginBottom: '8px' }}>
                        <span style={{ fontSize: '13px', color: '#666' }}>开仓价值</span>
                        <span style={{ fontSize: '13px', fontWeight: '500' }}>
-                          {formatUSDC(position.initialValue)} USDC
+                          ${formatUSDC(position.initialValue)}
                        </span>
                      </div>
                      {positionFilter === 'current' && position.currentPrice && (
@@ -732,7 +732,7 @@ const PositionList: React.FC = () => {
                          <div style={{ display: 'flex', justifyContent: 'space-between', marginBottom: '8px' }}>
                            <span style={{ fontSize: '13px', color: '#666' }}>当前价值</span>
                            <span style={{ fontSize: '13px', fontWeight: '600' }}>
-                              {formatUSDC(position.currentValue)} USDC
+                              ${formatUSDC(position.currentValue)}
                            </span>
                          </div>
                        </>
@@ -775,7 +775,7 @@ const PositionList: React.FC = () => {
                        fontWeight: 'bold',
                        color: isProfit ? '#52c41a' : '#f5222d'
                      }}>
-                        {pnlNum >= 0 ? '+' : ''}{formatUSDC(position.pnl)} USDC
+                        {pnlNum >= 0 ? '+' : ''}${formatUSDC(position.pnl)}
                      </span>
                    </div>
                    <div style={{ display: 'flex', justifyContent: 'flex-end' }}>
@@ -802,7 +802,7 @@ const PositionList: React.FC = () => {
                          color: parseFloat(position.realizedPnl) >= 0 ? '#52c41a' : '#f5222d',
                          fontWeight: '500'
                        }}>
-                          {parseFloat(position.realizedPnl) >= 0 ? '+' : ''}{formatUSDC(position.realizedPnl)} USDC
+                          {parseFloat(position.realizedPnl) >= 0 ? '+' : ''}${formatUSDC(position.realizedPnl)}
                        </span>
                      </div>
                    )}
@@ -833,7 +833,7 @@ const PositionList: React.FC = () => {
    )
  }

-  // 根据仓位类型动态生成列（历史仓位不显示当前价格、当前价值、状态列）
+  // 根据仓位类型动态生成列（优化后的紧凑布局）
  const columns = useMemo(() => {
    const baseColumns: any[] = [
      {
@@ -853,7 +853,6 @@ const PositionList: React.FC = () => {
                objectFit: 'cover'
              }}
              onError={(e) => {
-                // 图片加载失败时隐藏
                e.currentTarget.style.display = 'none'
              }}
            />
@@ -876,7 +875,7 @@ const PositionList: React.FC = () => {
          </div>
        ),
        fixed: isMobile ? ('left' as const) : undefined,
-        width: isMobile ? 150 : 200
+        width: isMobile ? 120 : 160
      },
      {
        title: '市场',
@@ -924,7 +923,7 @@ const PositionList: React.FC = () => {
            </div>
          )
        },
-        width: isMobile ? 200 : 250
+        width: isMobile ? 180 : 220
      },
      {
        title: '方向',
@@ -933,136 +932,76 @@ const PositionList: React.FC = () => {
        render: (side: string) => (
          <Tag color={getSideColor(side)}>{side}</Tag>
        ),
-        width: 80
+        width: 70
      },
      {
-        title: '数量',
-        dataIndex: 'quantity',
-        key: 'quantity',
-        render: (quantity: string) => formatNumber(quantity, 4),
+        title: '持仓',
+        key: 'position',
+        render: (_: any, record: AccountPosition) => (
+          <div>
+            <div style={{ fontWeight: '500' }}>{formatNumber(record.quantity, 4)}</div>
+            <div style={{ fontSize: '12px', color: '#999' }}>@{formatNumber(record.avgPrice, 4)}</div>
+          </div>
+        ),
        align: 'right' as const,
        width: 100
      },
-      {
-        title: '平均价格',
-        dataIndex: 'avgPrice',
-        key: 'avgPrice',
-        render: (price: string) => formatNumber(price, 4),
-        align: 'right' as const,
-        width: 120
-      },
      {
        title: '开仓价值',
        dataIndex: 'initialValue',
        key: 'initialValue',
        render: (value: string) => (
-          <span>
-            {formatUSDC(value)} USDC
-          </span>
+          <span>${formatUSDC(value)}</span>
        ),
        align: 'right' as const,
-        width: 120
+        width: 110
      },
    ]

-    // 只有当前仓位才显示当前价格和当前价值列
+    // 只有当前仓位才显示当前价值/盈亏合并列
    if (positionFilter === 'current') {
-      baseColumns.push(
-        {
-          title: '当前价格',
-          dataIndex: 'currentPrice',
-          key: 'currentPrice',
-          render: (price: string) => formatNumber(price, 4),
-          align: 'right' as const,
-          width: 120
-        },
-        {
-          title: '当前价值',
-          dataIndex: 'currentValue',
-          key: 'currentValue',
-          render: (value: string) => (
-            <span style={{ fontWeight: 'bold' }}>
-              {formatUSDC(value)} USDC
-            </span>
-          ),
-          align: 'right' as const,
-          width: 120,
-          sorter: (a: AccountPosition, b: AccountPosition) => {
-            const valA = parseFloat(a.currentValue || '0')
-            const valB = parseFloat(b.currentValue || '0')
-            return valA - valB
-          },
-          defaultSortOrder: 'descend' as const
-        }
-      )
-    }
+      baseColumns.push({
+        title: '当前价值 / 盈亏',
+        key: 'valueAndPnl',
+        render: (_: any, record: AccountPosition) => {
+          const pnlNum = parseFloat(record.pnl || '0')
+          const realizedPnl = record.realizedPnl ? parseFloat(record.realizedPnl) : null
+          const percentRealizedPnl = record.percentRealizedPnl ? parseFloat(record.percentRealizedPnl) : null

-    // 只有当前仓位才显示盈亏和已实现盈亏列
-    if (positionFilter === 'current') {
-      baseColumns.push(
-        {
-          title: '盈亏',
-          dataIndex: 'pnl',
-          key: 'pnl',
-          render: (pnl: string, record: AccountPosition) => {
-            const pnlNum = parseFloat(pnl || '0')
-            const percentPnl = parseFloat(record.percentPnl || '0')
-            return (
-              <div>
-                <div style={{
-                  color: pnlNum >= 0 ? '#3f8600' : '#cf1322',
-                  fontWeight: 'bold'
-                }}>
-                  {pnlNum >= 0 ? '+' : ''}{formatUSDC(pnl)} USDC
-                </div>
-                <div style={{
-                  fontSize: '12px',
-                  color: percentPnl >= 0 ? '#3f8600' : '#cf1322'
-                }}>
-                  {formatPercent(record.percentPnl)}
-                </div>
+          return (
+            <div>
+              <div style={{ fontWeight: '600', marginBottom: '2px' }}>
+                ${formatUSDC(record.currentValue)}
              </div>
-            )
-          },
-          align: 'right' as const,
-          width: 150,
-          sorter: (a: AccountPosition, b: AccountPosition) => {
-            const pnlA = parseFloat(a.pnl || '0')
-            const pnlB = parseFloat(b.pnl || '0')
-            return pnlA - pnlB
-          }
+              <div style={{
+                fontSize: '13px',
+                color: pnlNum >= 0 ? '#3f8600' : '#cf1322',
+                fontWeight: '500'
+              }}>
+                {pnlNum >= 0 ? '+' : ''}{formatUSDC(record.pnl)} ({formatPercent(record.percentPnl)})
+              </div>
+              {realizedPnl !== null && (
+                <div style={{
+                  fontSize: '11px',
+                  color: '#999',
+                  marginTop: '2px'
+                }}>
+                  已实现: {realizedPnl >= 0 ? '+' : ''}{formatUSDC(record.realizedPnl)}
+                  {percentRealizedPnl !== null && ` (${formatPercent(record.percentRealizedPnl)})`}
+                </div>
+              )}
+            </div>
+          )
        },
-        {
-          title: '已实现盈亏',
-          dataIndex: 'realizedPnl',
-          key: 'realizedPnl',
-          render: (realizedPnl: string | undefined, record: AccountPosition) => {
-            if (!realizedPnl) return '-'
-            const pnlNum = parseFloat(realizedPnl)
-            const percentPnl = parseFloat(record.percentRealizedPnl || '0')
-            return (
-              <div>
-                <div style={{
-                  color: pnlNum >= 0 ? '#3f8600' : '#cf1322',
-                  fontWeight: 'bold'
-                }}>
-                  {pnlNum >= 0 ? '+' : ''}{formatUSDC(realizedPnl)} USDC
-                </div>
-                {record.percentRealizedPnl && (
-                  <div style={{
-                    fontSize: '12px',
-                    color: percentPnl >= 0 ? '#3f8600' : '#cf1322'
-                  }}>
-                    {formatPercent(record.percentRealizedPnl)}
-                  </div>
-                )}
-              </div>
-            )
-          },
-          align: 'right' as const,
-          width: 150
-        }
-      )
+        align: 'right' as const,
+        width: 160,
+        sorter: (a: AccountPosition, b: AccountPosition) => {
+          const valA = parseFloat(a.currentValue || '0')
+          const valB = parseFloat(b.currentValue || '0')
+          return valA - valB
+        },
+        defaultSortOrder: 'descend' as const
+      })
    }

    // 只有当前仓位才显示操作列
@@ -1084,7 +1023,7 @@ const PositionList: React.FC = () => {
            )}
          </Space>
        ),
-        width: 150,
+        width: 80,
        fixed: isMobile ? ('right' as const) : undefined
      })
    }
@@ -1276,7 +1215,7 @@ const PositionList: React.FC = () => {
                  borderColor: '#52c41a'
                }}
              >
-                赎回 ({redeemableSummary.totalCount}个, {formatUSDC(redeemableSummary.totalValue)} USDC)
+                赎回 ({redeemableSummary.totalCount}个, ${formatUSDC(redeemableSummary.totalValue)})
              </Button>
            )}
          </div>
@@ -1299,13 +1238,13 @@ const PositionList: React.FC = () => {
            <span>
              开仓价值合计：{' '}
              <span style={{ fontWeight: 600 }}>
-                {formatUSDC(positionTotals.totalInitialValue.toString())} USDC
+                ${formatUSDC(positionTotals.totalInitialValue.toString())}
              </span>
            </span>
            <span>
              当前价值合计：{' '}
              <span style={{ fontWeight: 600 }}>
-                {formatUSDC(positionTotals.totalCurrentValue.toString())} USDC
+                ${formatUSDC(positionTotals.totalCurrentValue.toString())}
              </span>
            </span>
            <span>
@@ -1317,7 +1256,7 @@ const PositionList: React.FC = () => {
                }}
              >
                {positionTotals.totalPnl >= 0 ? '+' : ''}
-                {formatUSDC(positionTotals.totalPnl.toString())} USDC
+                ${formatUSDC(positionTotals.totalPnl.toString())}
              </span>
            </span>
            <span>
@@ -1329,7 +1268,7 @@ const PositionList: React.FC = () => {
                }}
              >
                {positionTotals.totalRealizedPnl >= 0 ? '+' : ''}
-                {formatUSDC(positionTotals.totalRealizedPnl.toString())} USDC
+                ${formatUSDC(positionTotals.totalRealizedPnl.toString())}
              </span>
            </span>
          </div>
@@ -1593,7 +1532,7 @@ const PositionList: React.FC = () => {
                  color: currentPnl.pnl >= 0 ? '#52c41a' : '#f5222d',
                  marginBottom: '4px'
                }}>
-                  {currentPnl.pnl >= 0 ? '+' : ''}{formatUSDC(currentPnl.pnl)} USDC
+                  {currentPnl.pnl >= 0 ? '+' : ''}${formatUSDC(currentPnl.pnl)}
                </div>
                <div style={{
                  fontSize: '14px',
@@ -1633,7 +1572,7 @@ const PositionList: React.FC = () => {
              </Descriptions.Item>
              <Descriptions.Item label="可赎回总价值">
                <span style={{ fontSize: '18px', fontWeight: 'bold', color: '#52c41a' }}>
-                  {formatUSDC(redeemableSummary.totalValue)} USDC
+                  ${formatUSDC(redeemableSummary.totalValue)}
                </span>
              </Descriptions.Item>
              <Descriptions.Item label="涉及账户">
@@ -1686,7 +1625,7 @@ const PositionList: React.FC = () => {
                    width: 120
                  },
                  {
-                    title: '价值 (USDC)',
+                    title: '价值 ($)',
                    dataIndex: 'value',
                    key: 'value',
                    align: 'right' as const,
@@ -101,9 +101,8 @@ const Statistics: React.FC = () => {
            <Statistic
              title={t('statistics.totalPnl') || '总盈亏'}
              value={formatUSDC(stats?.totalPnl || '0')}
-              prefix={stats?.totalPnl && parseFloat(stats.totalPnl) >= 0 ? <ArrowUpOutlined /> : <ArrowDownOutlined />}
+              prefix={<>{stats?.totalPnl && parseFloat(stats.totalPnl) >= 0 ? <ArrowUpOutlined /> : <ArrowDownOutlined />} $</>}
              valueStyle={{ color: stats?.totalPnl && parseFloat(stats.totalPnl || '0') >= 0 ? '#3f8600' : '#cf1322' }}
-              suffix="USDC"
              loading={loading}
            />
          </Card>
@@ -124,9 +123,8 @@ const Statistics: React.FC = () => {
            <Statistic
              title={t('statistics.avgPnl') || '平均盈亏'}
              value={formatUSDC(stats?.avgPnl || '0')}
-              prefix={stats?.avgPnl && parseFloat(stats.avgPnl || '0') >= 0 ? <ArrowUpOutlined /> : <ArrowDownOutlined />}
+              prefix={<>{stats?.avgPnl && parseFloat(stats.avgPnl || '0') >= 0 ? <ArrowUpOutlined /> : <ArrowDownOutlined />} $</>}
              valueStyle={{ color: stats?.avgPnl && parseFloat(stats.avgPnl || '0') >= 0 ? '#3f8600' : '#cf1322' }}
-              suffix="USDC"
              loading={loading}
            />
          </Card>
@@ -136,9 +134,8 @@ const Statistics: React.FC = () => {
            <Statistic
              title={t('statistics.maxProfit') || '最大盈利'}
              value={formatUSDC(stats?.maxProfit || '0')}
-              prefix={<ArrowUpOutlined />}
+              prefix={<><ArrowUpOutlined /> $</>}
              valueStyle={{ color: '#3f8600' }}
-              suffix="USDC"
              loading={loading}
            />
          </Card>
@@ -148,9 +145,8 @@ const Statistics: React.FC = () => {
            <Statistic
              title={t('statistics.maxLoss') || '最大亏损'}
              value={formatUSDC(stats?.maxLoss || '0')}
-              prefix={<ArrowDownOutlined />}
+              prefix={<><ArrowDownOutlined /> $</>}
              valueStyle={{ color: '#cf1322' }}
-              suffix="USDC"
              loading={loading}
            />
          </Card>
@@ -1,11 +1,11 @@
 import { useEffect, useState } from 'react'
-import { Card, Form, Button, Switch, Input, InputNumber, message, Typography, Space, Alert, Select, Table, Tag, Popconfirm, Modal } from 'antd'
-import { SaveOutlined, CheckCircleOutlined, ReloadOutlined, GlobalOutlined, NotificationOutlined, KeyOutlined, LinkOutlined, PlusOutlined, EditOutlined, DeleteOutlined, SendOutlined } from '@ant-design/icons'
+import { useNavigate } from 'react-router-dom'
+import { Card, Form, Button, Switch, Input, InputNumber, message, Typography, Space, Alert, Select } from 'antd'
+import { SaveOutlined, CheckCircleOutlined, ReloadOutlined, GlobalOutlined, NotificationOutlined, KeyOutlined, LinkOutlined, RightOutlined } from '@ant-design/icons'
 import { apiService } from '../services/api'
 import { useMediaQuery } from 'react-responsive'
 import { useTranslation } from 'react-i18next'
-import type { SystemConfig, BuilderApiKeyUpdateRequest, NotificationConfig, NotificationConfigRequest, NotificationConfigUpdateRequest } from '../types'
-import { TelegramConfigForm } from '../components/notifications'
+import type { SystemConfig, BuilderApiKeyUpdateRequest } from '../types'
 import SystemUpdate from './SystemUpdate'

 const { Title, Text, Paragraph } = Typography
@@ -33,20 +33,13 @@ interface ProxyCheckResponse {
 const SystemSettings: React.FC = () => {
  const { t, i18n: i18nInstance } = useTranslation()
  const isMobile = useMediaQuery({ maxWidth: 768 })
+  const navigate = useNavigate()

  // 第一部分：多语言
  const [languageForm] = Form.useForm()
  const [currentLang, setCurrentLang] = useState<string>('auto')

-  // 第二部分：消息推送设置
-  const [notificationConfigs, setNotificationConfigs] = useState<NotificationConfig[]>([])
-  const [notificationLoading, setNotificationLoading] = useState(false)
-  const [notificationModalVisible, setNotificationModalVisible] = useState(false)
-  const [editingNotificationConfig, setEditingNotificationConfig] = useState<NotificationConfig | null>(null)
-  const [notificationForm] = Form.useForm()
-  const [testLoading, setTestLoading] = useState(false)
-
-  // 第三部分：Relayer配置
+  // 第二部分：Relayer配置
  const [relayerForm] = Form.useForm()
  const [autoRedeemForm] = Form.useForm()
  const [systemConfig, setSystemConfig] = useState<SystemConfig | null>(null)
@@ -67,7 +60,6 @@ const SystemSettings: React.FC = () => {
    languageForm.setFieldsValue({ language: savedLanguage })

    // 加载其他配置
-    fetchNotificationConfigs()
    fetchSystemConfig()
    fetchProxyConfig()
  }, [])
@@ -103,246 +95,7 @@ const SystemSettings: React.FC = () => {
    }
  }

-  // ==================== 第二部分：消息推送设置 ====================
-  const fetchNotificationConfigs = async () => {
-    setNotificationLoading(true)
-    try {
-      const response = await apiService.notifications.list({ type: 'telegram' })
-      if (response.data.code === 0 && response.data.data) {
-        setNotificationConfigs(response.data.data)
-      } else {
-        message.error(response.data.msg || t('notificationSettings.fetchFailed'))
-      }
-    } catch (error: any) {
-      message.error(error.message || t('notificationSettings.fetchFailed'))
-    } finally {
-      setNotificationLoading(false)
-    }
-  }
-
-  const handleNotificationCreate = () => {
-    setEditingNotificationConfig(null)
-    notificationForm.resetFields()
-    notificationForm.setFieldsValue({
-      type: 'telegram',
-      enabled: true,
-      config: {
-        botToken: '',
-        chatIds: []
-      }
-    })
-    setNotificationModalVisible(true)
-  }
-
-  const handleNotificationEdit = (config: NotificationConfig) => {
-    setEditingNotificationConfig(config)
-
-    let botToken = ''
-    let chatIds = ''
-
-    if (config.config) {
-      if ('data' in config.config && config.config.data) {
-        const data = config.config.data as any
-        botToken = data.botToken || ''
-        if (data.chatIds) {
-          if (Array.isArray(data.chatIds)) {
-            chatIds = data.chatIds.join(',')
-          } else if (typeof data.chatIds === 'string') {
-            chatIds = data.chatIds
-          }
-        }
-      } else {
-        if ('botToken' in config.config) {
-          botToken = (config.config as any).botToken || ''
-        }
-        if ('chatIds' in config.config) {
-          const ids = (config.config as any).chatIds
-          if (Array.isArray(ids)) {
-            chatIds = ids.join(',')
-          } else if (typeof ids === 'string') {
-            chatIds = ids
-          }
-        }
-      }
-    }
-
-    notificationForm.setFieldsValue({
-      type: config.type,
-      name: config.name,
-      enabled: config.enabled,
-      config: {
-        botToken: botToken,
-        chatIds: chatIds
-      }
-    })
-    setNotificationModalVisible(true)
-  }
-
-  const handleNotificationDelete = async (id: number) => {
-    try {
-      const response = await apiService.notifications.delete({ id })
-      if (response.data.code === 0) {
-        message.success(t('notificationSettings.deleteSuccess'))
-        fetchNotificationConfigs()
-      } else {
-        message.error(response.data.msg || t('notificationSettings.deleteFailed'))
-      }
-    } catch (error: any) {
-      message.error(error.message || t('notificationSettings.deleteFailed'))
-    }
-  }
-
-  const handleNotificationUpdateEnabled = async (id: number, enabled: boolean) => {
-    try {
-      const response = await apiService.notifications.updateEnabled({ id, enabled })
-      if (response.data.code === 0) {
-        message.success(enabled ? t('notificationSettings.enableSuccess') : t('notificationSettings.disableSuccess'))
-        fetchNotificationConfigs()
-      } else {
-        message.error(response.data.msg || t('notificationSettings.updateStatusFailed'))
-      }
-    } catch (error: any) {
-      message.error(error.message || t('notificationSettings.updateStatusFailed'))
-    }
-  }
-
-  const handleNotificationTest = async () => {
-    setTestLoading(true)
-    try {
-      const response = await apiService.notifications.test({ message: '这是一条测试消息' })
-      if (response.data.code === 0 && response.data.data) {
-        message.success(t('notificationSettings.testSuccess'))
-      } else {
-        message.error(response.data.msg || t('notificationSettings.testFailed'))
-      }
-    } catch (error: any) {
-      message.error(error.message || t('notificationSettings.testFailed'))
-    } finally {
-      setTestLoading(false)
-    }
-  }
-
-  const handleNotificationSubmit = async () => {
-    try {
-      const values = await notificationForm.validateFields()
-
-      const chatIds = typeof values.config.chatIds === 'string'
-        ? values.config.chatIds.split(',').map((id: string) => id.trim()).filter((id: string) => id)
-        : values.config.chatIds || []
-
-      const configData: NotificationConfigRequest | NotificationConfigUpdateRequest = {
-        type: values.type,
-        name: values.name,
-        enabled: values.enabled,
-        config: {
-          botToken: values.config.botToken,
-          chatIds: chatIds
-        }
-      }
-
-      if (editingNotificationConfig?.id) {
-        const updateData = {
-          ...configData,
-          id: editingNotificationConfig.id
-        } as NotificationConfigUpdateRequest
-
-        const response = await apiService.notifications.update(updateData)
-        if (response.data.code === 0) {
-          message.success(t('notificationSettings.updateSuccess'))
-          setNotificationModalVisible(false)
-          fetchNotificationConfigs()
-        } else {
-          message.error(response.data.msg || t('notificationSettings.updateFailed'))
-        }
-      } else {
-        const response = await apiService.notifications.create(configData)
-        if (response.data.code === 0) {
-          message.success(t('notificationSettings.createSuccess'))
-          setNotificationModalVisible(false)
-          fetchNotificationConfigs()
-        } else {
-          message.error(response.data.msg || t('notificationSettings.createFailed'))
-        }
-      }
-    } catch (error: any) {
-      if (error.errorFields) {
-        return
-      }
-      message.error(error.message || t('message.error'))
-    }
-  }
-
-  const notificationColumns = [
-    {
-      title: t('notificationSettings.configName'),
-      dataIndex: 'name',
-      key: 'name',
-    },
-    {
-      title: t('notificationSettings.type'),
-      dataIndex: 'type',
-      key: 'type',
-      render: (type: string) => <Tag color="blue">{type.toUpperCase()}</Tag>
-    },
-    {
-      title: t('notificationSettings.status'),
-      dataIndex: 'enabled',
-      key: 'enabled',
-      render: (enabled: boolean) => (
-        <Tag color={enabled ? 'green' : 'default'}>
-          {enabled ? t('notificationSettings.enabledStatus') : t('notificationSettings.disabledStatus')}
-        </Tag>
-      )
-    },
-    {
-      title: t('common.actions'),
-      key: 'action',
-      width: isMobile ? 120 : 200,
-      render: (_: any, record: NotificationConfig) => (
-        <Space size="small" wrap>
-          <Button
-            type="link"
-            size="small"
-            icon={<EditOutlined />}
-            onClick={() => handleNotificationEdit(record)}
-          >
-            {t('notificationSettings.edit')}
-          </Button>
-          <Switch
-            checked={record.enabled}
-            size="small"
-            onChange={(checked) => handleNotificationUpdateEnabled(record.id!, checked)}
-          />
-          <Button
-            type="link"
-            size="small"
-            icon={<SendOutlined />}
-            loading={testLoading}
-            onClick={handleNotificationTest}
-          >
-            {t('notificationSettings.test')}
-          </Button>
-          <Popconfirm
-            title={t('notificationSettings.deleteConfirm')}
-            onConfirm={() => handleNotificationDelete(record.id!)}
-            okText={t('common.confirm')}
-            cancelText={t('common.cancel')}
-          >
-            <Button
-              type="link"
-              danger
-              size="small"
-              icon={<DeleteOutlined />}
-            >
-              {t('notificationSettings.delete')}
-            </Button>
-          </Popconfirm>
-        </Space>
-      )
-    }
-  ]
-
-  // ==================== 第三部分：Relayer配置 ====================
+  // ==================== 第二部分：Relayer配置 ====================
  const fetchSystemConfig = async () => {
    try {
      const response = await apiService.systemConfig.get()
@@ -551,7 +304,7 @@ const SystemSettings: React.FC = () => {
        </Form>
      </Card>

-      {/* 第二部分：消息推送设置 */}
+      {/* 第二部分：消息推送设置（独立页面入口） */}
      <Card
        title={
          <Space>
@@ -563,73 +316,24 @@ const SystemSettings: React.FC = () => {
        extra={
          <Button
            type="primary"
-            icon={<PlusOutlined />}
-            onClick={handleNotificationCreate}
+            icon={<RightOutlined />}
+            onClick={() => navigate('/system-settings/notification')}
          >
-            {t('notificationSettings.addConfig')}
+            {t('notificationSettings.title')}
          </Button>
        }
      >
-        <Table
-          columns={notificationColumns}
-          dataSource={notificationConfigs}
-          loading={notificationLoading}
-          rowKey="id"
-          pagination={false}
-          scroll={{ x: isMobile ? 600 : 'auto' }}
-        />
-
-        <Modal
-          title={editingNotificationConfig ? t('notificationSettings.editConfig') : t('notificationSettings.addConfig')}
-          open={notificationModalVisible}
-          onOk={handleNotificationSubmit}
-          onCancel={() => setNotificationModalVisible(false)}
-          width={isMobile ? '90%' : 600}
-          okText={t('common.confirm')}
-          cancelText={t('common.cancel')}
+        <Paragraph type="secondary" style={{ marginBottom: 16 }}>
+          {t('notificationSettings.botConfig')}、{t('notificationSettings.templateConfig')}等请在独立页面中配置。
+        </Paragraph>
+        <Button
+          type="link"
+          icon={<RightOutlined />}
+          onClick={() => navigate('/system-settings/notification')}
+          style={{ padding: 0 }}
        >
-          <Form
-            form={notificationForm}
-            layout="vertical"
-          >
-            <Form.Item
-              name="type"
-              label={t('notificationSettings.type')}
-              rules={[{ required: true, message: t('notificationSettings.typeRequired') }]}
-            >
-              <Input disabled value="telegram" />
-            </Form.Item>
-
-            <Form.Item
-              name="name"
-              label={t('notificationSettings.configName')}
-              rules={[{ required: true, message: t('notificationSettings.configNameRequired') }]}
-            >
-              <Input placeholder={t('notificationSettings.configNamePlaceholder')} />
-            </Form.Item>
-
-            <Form.Item
-              name="enabled"
-              label={t('notificationSettings.enabled')}
-              valuePropName="checked"
-            >
-              <Switch />
-            </Form.Item>
-
-            <Form.Item shouldUpdate={(prevValues, currentValues) => {
-              return prevValues.type !== currentValues.type ||
-                prevValues.config !== currentValues.config
-            }}>
-              {() => {
-                const currentType = notificationForm.getFieldValue('type') || 'telegram'
-                if (currentType === 'telegram') {
-                  return <TelegramConfigForm form={notificationForm} />
-                }
-                return null
-              }}
-            </Form.Item>
-          </Form>
-        </Modal>
+          {t('notificationSettings.title')} →
+        </Button>
      </Card>

      {/* 第三部分：Relayer配置 */}
@@ -154,7 +154,7 @@ const TemplateAdd: React.FC = () => {
          
          {copyMode === 'FIXED' && (
            <Form.Item
-              label={t('templateAdd.fixedAmount') || '固定跟单金额 (USDC)'}
+              label={t('templateAdd.fixedAmount') || '固定跟单金额 ($)'}
              name="fixedAmount"
              rules={[
                { required: true, message: t('templateAdd.fixedAmountRequired') || '请输入固定跟单金额' },
@@ -193,9 +193,9 @@ const TemplateAdd: React.FC = () => {
          {copyMode === 'RATIO' && (
            <>
              <Form.Item
-                label={t('templateAdd.maxOrderSize') || '单笔订单最大金额 (USDC)'}
+                label={t('templateAdd.maxOrderSize') || '单笔订单最大金额 ($)'}
                name="maxOrderSize"
-                tooltip={t('templateAdd.maxOrderSizeTooltip') || '比例模式下，限制单笔跟单订单的最大金额上限，用于防止跟单金额过大，控制风险。例如：设置为 1000，即使计算出的跟单金额超过 1000，也会限制为 1000 USDC。'}
+                tooltip={t('templateAdd.maxOrderSizeTooltip') || '比例模式下，限制单笔跟单订单的最大金额上限，用于防止跟单金额过大，控制风险。例如：设置为 1000，即使计算出的跟单金额超过 1000，也会限制为 $1000。'}
              >
                <InputNumber
                  min={0.0001}
@@ -213,9 +213,9 @@ const TemplateAdd: React.FC = () => {
              </Form.Item>
              
              <Form.Item
-                label={t('templateAdd.minOrderSize') || '单笔订单最小金额 (USDC)'}
+                label={t('templateAdd.minOrderSize') || '单笔订单最小金额 ($)'}
                name="minOrderSize"
-                tooltip={t('templateAdd.minOrderSizeTooltip') || '比例模式下，限制单笔跟单订单的最小金额下限，用于过滤掉金额过小的订单，避免频繁小额交易。如果填写，必须 >= 1 USDC。例如：设置为 10，如果计算出的跟单金额小于 10，则跳过该订单。'}
+                tooltip={t('templateAdd.minOrderSizeTooltip') || '比例模式下，限制单笔跟单订单的最小金额下限，用于过滤掉金额过小的订单，避免频繁小额交易。如果填写，必须 >= $1。例如：设置为 10，如果计算出的跟单金额小于 10，则跳过该订单。'}
                rules={[
                  { 
                    validator: (_, value) => {
@@ -282,7 +282,7 @@ const TemplateAdd: React.FC = () => {
          </Form.Item>
          
          <Form.Item
-            label={t('templateAdd.minOrderDepth') || '最小订单深度 (USDC)'}
+            label={t('templateAdd.minOrderDepth') || '最小订单深度 ($)'}
            name="minOrderDepth"
            tooltip={t('templateAdd.minOrderDepthTooltip') || '检查订单簿的总订单金额（买盘+卖盘），确保市场有足够的流动性。不填写则不启用此过滤'}
          >
@@ -189,9 +189,9 @@ const TemplateEdit: React.FC = () => {
          
          {copyMode === 'FIXED' && (
            <Form.Item
-              label={t('templateEdit.fixedAmount') || '固定跟单金额 (USDC)'}
+              label={t('templateEdit.fixedAmount') || '固定跟单金额 ($)'}
              name="fixedAmount"
-              tooltip={t('templateEdit.fixedAmountTooltip') || '固定金额模式下，每次跟单的固定金额，不随 Leader 订单大小变化。必须 >= 1 USDC。例如：设置为 10，则无论 Leader 买入多少，跟单金额始终为 10 USDC。'}
+              tooltip={t('templateEdit.fixedAmountTooltip') || '固定金额模式下，每次跟单的固定金额，不随 Leader 订单大小变化。必须 >= $1。例如：设置为 10，则无论 Leader 买入多少，跟单金额始终为 $10。'}
              rules={[
                { required: true, message: t('templateEdit.fixedAmountRequired') || '请输入固定跟单金额' },
                { 
@@ -229,9 +229,9 @@ const TemplateEdit: React.FC = () => {
          {copyMode === 'RATIO' && (
            <>
              <Form.Item
-                label={t('templateEdit.maxOrderSize') || '单笔订单最大金额 (USDC)'}
+                label={t('templateEdit.maxOrderSize') || '单笔订单最大金额 ($)'}
                name="maxOrderSize"
-                tooltip={t('templateEdit.maxOrderSizeTooltip') || '比例模式下，限制单笔跟单订单的最大金额上限，用于防止跟单金额过大，控制风险。例如：设置为 1000，即使计算出的跟单金额超过 1000，也会限制为 1000 USDC。'}
+                tooltip={t('templateEdit.maxOrderSizeTooltip') || '比例模式下，限制单笔跟单订单的最大金额上限，用于防止跟单金额过大，控制风险。例如：设置为 1000，即使计算出的跟单金额超过 1000，也会限制为 $1000。'}
              >
                <InputNumber
                  min={0.0001}
@@ -249,9 +249,9 @@ const TemplateEdit: React.FC = () => {
              </Form.Item>
              
              <Form.Item
-                label={t('templateEdit.minOrderSize') || '单笔订单最小金额 (USDC)'}
+                label={t('templateEdit.minOrderSize') || '单笔订单最小金额 ($)'}
                name="minOrderSize"
-                tooltip={t('templateEdit.minOrderSizeTooltip') || '比例模式下，限制单笔跟单订单的最小金额下限，用于过滤掉金额过小的订单，避免频繁小额交易。如果填写，必须 >= 1 USDC。例如：设置为 10，如果计算出的跟单金额小于 10，则跳过该订单。'}
+                tooltip={t('templateEdit.minOrderSizeTooltip') || '比例模式下，限制单笔跟单订单的最小金额下限，用于过滤掉金额过小的订单，避免频繁小额交易。如果填写，必须 >= $1。例如：设置为 10，如果计算出的跟单金额小于 10，则跳过该订单。'}
                rules={[
                  { 
                    validator: (_, value) => {
@@ -318,7 +318,7 @@ const TemplateEdit: React.FC = () => {
          </Form.Item>
          
          <Form.Item
-            label={t('templateEdit.minOrderDepth') || '最小订单深度 (USDC)'}
+            label={t('templateEdit.minOrderDepth') || '最小订单深度 ($)'}
            name="minOrderDepth"
            tooltip={t('templateEdit.minOrderDepthTooltip') || '检查订单簿的总订单金额（买盘+卖盘），确保市场有足够的流动性。不填写则不启用此过滤'}
          >
@@ -1,6 +1,6 @@
 import { useEffect, useState } from 'react'
 import { useNavigate } from 'react-router-dom'
-import { Card, Table, Button, Space, Tag, Popconfirm, message, Input, Modal, Form, Radio, InputNumber, Switch, Divider, Spin } from 'antd'
+import { Card, Table, Button, Space, Tag, Popconfirm, message, Input, Modal, Form, Radio, InputNumber, Switch, Divider, Spin, Empty, List, Tooltip } from 'antd'
 import { PlusOutlined, EditOutlined, DeleteOutlined, CopyOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import { apiService } from '../services/api'
@@ -176,7 +176,7 @@ const TemplateList: React.FC = () => {
        if (record.copyMode === 'RATIO') {
          return `${t('templateList.ratio') || '比例'} ${record.copyRatio}x`
        } else if (record.copyMode === 'FIXED' && record.fixedAmount) {
-          return `${t('templateList.fixedAmount') || '固定'} ${formatUSDC(record.fixedAmount)} USDC`
+          return `$${formatUSDC(record.fixedAmount)}`
        }
        return '-'
      }
@@ -212,25 +212,50 @@ const TemplateList: React.FC = () => {
    {
      title: t('common.actions') || '操作',
      key: 'action',
-      width: isMobile ? 120 : 200,
+      width: isMobile ? 120 : 120,
+      fixed: 'right' as const,
      render: (_: any, record: CopyTradingTemplate) => (
-        <Space size="small">
-          <Button
-            type="link"
-            size="small"
-            icon={<EditOutlined />}
-            onClick={() => navigate(`/templates/edit/${record.id}`)}
-          >
-            {t('common.edit') || '编辑'}
-          </Button>
-          <Button
-            type="link"
-            size="small"
-            icon={<CopyOutlined />}
-            onClick={() => handleCopy(record)}
-          >
-            {t('templateList.copy') || '复制'}
-          </Button>
+        <Space size={4}>
+          <Tooltip title={t('common.edit') || '编辑'}>
+            <div
+              onClick={() => navigate(`/templates/edit/${record.id}`)}
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                width: '32px',
+                height: '32px',
+                cursor: 'pointer',
+                borderRadius: '6px',
+                transition: 'background-color 0.2s'
+              }}
+              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
+              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+            >
+              <EditOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+            </div>
+          </Tooltip>
+
+          <Tooltip title={t('templateList.copy') || '复制'}>
+            <div
+              onClick={() => handleCopy(record)}
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                width: '32px',
+                height: '32px',
+                cursor: 'pointer',
+                borderRadius: '6px',
+                transition: 'background-color 0.2s'
+              }}
+              onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#f0f0f0'}
+              onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+            >
+              <CopyOutlined style={{ fontSize: '16px', color: '#1890ff' }} />
+            </div>
+          </Tooltip>
+
          <Popconfirm
            title={t('templateList.deleteConfirm') || '确定要删除这个模板吗？'}
            description={t('templateList.deleteConfirmDesc') || '删除后无法恢复，请确保没有跟单关系在使用该模板'}
@@ -238,14 +263,24 @@ const TemplateList: React.FC = () => {
            okText={t('common.confirm') || '确定'}
            cancelText={t('common.cancel') || '取消'}
          >
-            <Button
-              type="link"
-              size="small"
-              danger
-              icon={<DeleteOutlined />}
-            >
-              {t('common.delete') || '删除'}
-            </Button>
+            <Tooltip title={t('common.delete') || '删除'}>
+              <div
+                style={{
+                  display: 'flex',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                  width: '32px',
+                  height: '32px',
+                  cursor: 'pointer',
+                  borderRadius: '6px',
+                  transition: 'background-color 0.2s'
+                }}
+                onMouseEnter={(e) => e.currentTarget.style.backgroundColor = '#fff1f0'}
+                onMouseLeave={(e) => e.currentTarget.style.backgroundColor = 'transparent'}
+              >
+                <DeleteOutlined style={{ fontSize: '16px', color: '#ff4d4f' }} />
+              </div>
+            </Tooltip>
          </Popconfirm>
        </Space>
      )
@@ -254,26 +289,29 @@ const TemplateList: React.FC = () => {
  
  return (
    <div>
-      <Card>
-        <div style={{ marginBottom: 16, display: 'flex', justifyContent: 'space-between', alignItems: 'center', flexWrap: 'wrap', gap: 16 }}>
-          <h2 style={{ margin: 0 }}>{t('templateList.title') || '跟单模板管理'}</h2>
-          <Space>
-            <Search
-              placeholder={t('templateList.searchPlaceholder') || '搜索模板名称'}
-              allowClear
-              style={{ width: isMobile ? 150 : 250 }}
-              onSearch={setSearchText}
-              onChange={(e) => setSearchText(e.target.value)}
-            />
+      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px', flexWrap: 'wrap', gap: '12px' }}>
+        <h2 style={{ margin: 0, fontSize: isMobile ? '20px' : '24px' }}>{t('templateList.title') || '跟单模板管理'}</h2>
+        <Space size={8}>
+          <Search
+            placeholder={t('templateList.searchPlaceholder') || '搜索模板名称'}
+            allowClear
+            style={{ width: isMobile ? 120 : 200 }}
+            onSearch={setSearchText}
+            onChange={(e) => setSearchText(e.target.value)}
+          />
+          <Tooltip title={t('templateList.addTemplate') || '新增模板'}>
            <Button
              type="primary"
              icon={<PlusOutlined />}
              onClick={() => navigate('/templates/add')}
-            >
-              {t('templateList.addTemplate') || '新增模板'}
-            </Button>
-          </Space>
-        </div>
+              size={isMobile ? 'middle' : 'large'}
+              style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}
+            />
+          </Tooltip>
+        </Space>
+      </div>
+
+      <Card style={{ borderRadius: '12px', boxShadow: '0 2px 8px rgba(0,0,0,0.08)', border: '1px solid #e8e8e8' }} bodyStyle={{ padding: isMobile ? '12px' : '24px' }}>
        
        {isMobile ? (
          // 移动端卡片布局
@@ -283,116 +321,133 @@ const TemplateList: React.FC = () => {
                <Spin size="large" />
              </div>
            ) : filteredTemplates.length === 0 ? (
-              <div style={{ textAlign: 'center', padding: '40px', color: '#999' }}>
-                {t('templateList.noData') || '暂无模板数据'}
-              </div>
+              <Empty description={t('templateList.noData') || '暂无模板数据'} />
            ) : (
-              <div style={{ display: 'flex', flexDirection: 'column', gap: '12px' }}>
-                {filteredTemplates.map((template) => {
-                  const date = new Date(template.createdAt)
-                  const formattedDate = date.toLocaleString(i18n.language || 'zh-CN', {
-                    year: 'numeric',
-                    month: '2-digit',
-                    day: '2-digit',
-                    hour: '2-digit',
-                    minute: '2-digit'
-                  })
-                  
+              <List
+                dataSource={filteredTemplates}
+                renderItem={(template) => {
                  return (
                    <Card
                      key={template.id}
                      style={{
-                        borderRadius: '12px',
-                        boxShadow: '0 2px 8px rgba(0,0,0,0.08)',
-                        border: '1px solid #e8e8e8'
+                        marginBottom: '10px',
+                        borderRadius: '10px',
+                        boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
+                        border: '1px solid #e8e8e8',
+                        overflow: 'hidden'
                      }}
-                      bodyStyle={{ padding: '16px' }}
+                      bodyStyle={{ padding: '0' }}
                    >
-                      {/* 模板名称和模式 */}
-                      <div style={{ marginBottom: '12px' }}>
-                        <div style={{ 
-                          fontSize: '16px', 
-                          fontWeight: 'bold', 
-                          marginBottom: '8px',
-                          color: '#1890ff'
-                        }}>
+                      {/* 头部区域 - 模板名称 */}
+                      <div style={{
+                        padding: '10px 12px',
+                        background: 'var(--ant-color-primary, #1677ff)',
+                        color: '#fff'
+                      }}>
+                        <div style={{ fontSize: '15px', fontWeight: '600', marginBottom: '2px' }}>
                          {template.templateName}
                        </div>
-                        <div style={{ display: 'flex', flexWrap: 'wrap', gap: '6px', alignItems: 'center' }}>
-                          <Tag color={template.copyMode === 'RATIO' ? 'blue' : 'green'}>
-                            {template.copyMode === 'RATIO' ? (t('templateList.ratioMode') || '比例模式') : (t('templateList.fixedAmountMode') || '固定金额模式')}
-                          </Tag>
-                          <Tag color={template.supportSell ? 'green' : 'red'}>
-                            {template.supportSell ? (t('templateList.supportSell') || '跟单卖出') : (t('templateList.notSupportSell') || '不跟单卖出')}
-                          </Tag>
-                        </div>
-                      </div>
-                      
-                      <Divider style={{ margin: '12px 0' }} />
-                      
-                      {/* 跟单配置 */}
-                      <div style={{ marginBottom: '12px' }}>
-                        <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('templateList.copyConfig') || '跟单配置'}</div>
-                        <div style={{ fontSize: '14px', fontWeight: '500' }}>
+                        <div style={{ fontSize: '12px', opacity: '0.9' }}>
                          {template.copyMode === 'RATIO' 
-                            ? `${t('templateList.ratio') || '比例'} ${template.copyRatio}x`
-                            : template.fixedAmount 
-                              ? `${t('templateList.fixedAmount') || '固定'} ${formatUSDC(template.fixedAmount)} USDC`
-                              : '-'
+                            ? `${t('templateList.ratioMode') || '比例模式'} ${(parseFloat(template.copyRatio || '0') * 100).toFixed(0).replace(/\.0+$/, '')}%`
+                            : `$${formatUSDC(template.fixedAmount || '0')}`
                          }
                        </div>
                      </div>
-                      
-                      {/* 其他配置信息 */}
-                      {template.copyMode === 'RATIO' && (
-                        <div style={{ marginBottom: '12px' }}>
-                          <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('templateList.amountLimit') || '金额限制'}</div>
-                          <div style={{ fontSize: '13px', color: '#333' }}>
-                            {template.maxOrderSize && (
-                              <span>{t('templateList.max') || '最大'}: {formatUSDC(template.maxOrderSize)} USDC</span>
-                            )}
-                            {template.maxOrderSize && template.minOrderSize && <span> | </span>}
-                            {template.minOrderSize && (
-                              <span>{t('templateList.min') || '最小'}: {formatUSDC(template.minOrderSize)} USDC</span>
-                            )}
-                            {!template.maxOrderSize && !template.minOrderSize && <span style={{ color: '#999' }}>{t('templateList.notSet') || '未设置'}</span>}
+
+                      {/* 配置信息区域 */}
+                      <div style={{
+                        padding: '8px 12px',
+                        backgroundColor: '#fafafa',
+                        borderBottom: '1px solid #f0f0f0',
+                        minHeight: '42px',
+                        display: 'flex',
+                        alignItems: 'center'
+                      }}>
+                        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', width: '100%' }}>
+                          <div>
+                            <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
+                              {t('templateList.supportSell') || '跟单卖出'}
+                            </div>
+                            <div style={{ fontSize: '12px', fontWeight: '500' }}>
+                              <Tag color={template.supportSell ? 'green' : 'red'} style={{ margin: 0, fontSize: '10px' }}>
+                                {template.supportSell ? (t('common.yes') || '是') : (t('common.no') || '否')}
+                              </Tag>
+                            </div>
+                          </div>
+                          <div style={{ textAlign: 'right' }}>
+                            <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
+                              {t('templateList.maxDailyOrders') || '每日最大'}
+                            </div>
+                            <div style={{ fontSize: '12px', fontWeight: '500', color: '#1890ff' }}>
+                              {template.maxDailyOrders} {t('common.orders') || '单'}
+                            </div>
                          </div>
                        </div>
+                      </div>
+
+                      {/* 金额限制区域（仅比例模式显示） */}
+                      {template.copyMode === 'RATIO' && (
+                        <div style={{
+                          padding: '6px 12px',
+                          fontSize: '11px',
+                          color: '#8c8c8c',
+                          borderBottom: '1px solid #f0f0f0'
+                        }}>
+                          <span style={{ color: '#d48806' }}>{t('templateList.amountLimit') || '金额限制'}: </span>
+                          {template.maxOrderSize && (
+                            <span>{t('templateList.max') || '最大'} ${formatUSDC(template.maxOrderSize)}</span>
+                          )}
+                          {template.maxOrderSize && template.minOrderSize && <span> | </span>}
+                          {template.minOrderSize && (
+                            <span>{t('templateList.min') || '最小'} ${formatUSDC(template.minOrderSize)}</span>
+                          )}
+                          {!template.maxOrderSize && !template.minOrderSize && <span style={{ color: '#bfbfbf' }}>{t('templateList.notSet') || '未设置'}</span>}
+                        </div>
                      )}
-                      
-                      <div style={{ marginBottom: '12px' }}>
-                        <div style={{ fontSize: '12px', color: '#666', marginBottom: '4px' }}>{t('templateList.otherConfig') || '其他配置'}</div>
-                        <div style={{ fontSize: '13px', color: '#333' }}>
-                          {t('templateList.maxDailyOrders') || '每日最大订单'}: {template.maxDailyOrders} | {t('templateList.priceTolerance') || '价格容忍度'}: {template.priceTolerance}%
-                        </div>
-                      </div>
-                      
+
                      {/* 创建时间 */}
-                      <div style={{ marginBottom: '16px' }}>
-                        <div style={{ fontSize: '12px', color: '#999' }}>
-                          {t('common.createdAt') || '创建时间'}: {formattedDate}
-                        </div>
+                      <div style={{
+                        padding: '6px 12px',
+                        fontSize: '11px',
+                        color: '#8c8c8c'
+                      }}>
+                        {t('common.createdAt') || '创建时间'}: {new Date(template.createdAt).toLocaleString(i18n.language || 'zh-CN', {
+                          year: 'numeric',
+                          month: '2-digit',
+                          day: '2-digit',
+                          hour: '2-digit',
+                          minute: '2-digit'
+                        })}
                      </div>
-                      
-                      {/* 操作按钮 */}
-                      <div style={{ display: 'flex', gap: '8px', flexWrap: 'wrap' }}>
-                        <Button
-                          type="primary"
-                          size="small"
-                          icon={<EditOutlined />}
-                          onClick={() => navigate(`/templates/edit/${template.id}`)}
-                          style={{ flex: 1, minWidth: '80px' }}
-                        >
-                          {t('common.edit') || '编辑'}
-                        </Button>
-                        <Button
-                          size="small"
-                          icon={<CopyOutlined />}
-                          onClick={() => handleCopy(template)}
-                          style={{ flex: 1, minWidth: '80px' }}
-                        >
-                          {t('templateList.copy') || '复制'}
-                        </Button>
+
+                      {/* 图标操作栏 */}
+                      <div style={{
+                        padding: '8px 12px',
+                        display: 'flex',
+                        justifyContent: 'space-around',
+                        alignItems: 'center'
+                      }}>
+                        <Tooltip title={t('common.edit') || '编辑'}>
+                          <div
+                            onClick={() => navigate(`/templates/edit/${template.id}`)}
+                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
+                          >
+                            <EditOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.edit') || '编辑'}</span>
+                          </div>
+                        </Tooltip>
+
+                        <Tooltip title={t('templateList.copy') || '复制'}>
+                          <div
+                            onClick={() => handleCopy(template)}
+                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
+                          >
+                            <CopyOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('templateList.copy') || '复制'}</span>
+                          </div>
+                        </Tooltip>
+
                        <Popconfirm
                          title={t('templateList.deleteConfirm') || '确定要删除这个模板吗？'}
                          description={t('templateList.deleteConfirmDesc') || '删除后无法恢复，请确保没有跟单关系在使用该模板'}
@@ -400,20 +455,18 @@ const TemplateList: React.FC = () => {
                          okText={t('common.confirm') || '确定'}
                          cancelText={t('common.cancel') || '取消'}
                        >
-                          <Button
-                            danger
-                            size="small"
-                            icon={<DeleteOutlined />}
-                            style={{ flex: 1, minWidth: '80px' }}
-                          >
-                            {t('common.delete') || '删除'}
-                          </Button>
+                          <Tooltip title={t('common.delete') || '删除'}>
+                            <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                              <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
+                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.delete') || '删除'}</span>
+                            </div>
+                          </Tooltip>
                        </Popconfirm>
                      </div>
                    </Card>
                  )
-                })}
-              </div>
+                }}
+              />
            )}
          </div>
        ) : (
@@ -498,7 +551,7 @@ const TemplateList: React.FC = () => {
          
          {copyMode === 'FIXED' && (
            <Form.Item
-              label="固定跟单金额 (USDC)"
+              label="固定跟单金额 ($)"
              name="fixedAmount"
              rules={[
                { required: true, message: '请输入固定跟单金额' },
@@ -536,9 +589,9 @@ const TemplateList: React.FC = () => {
          {copyMode === 'RATIO' && (
            <>
              <Form.Item
-                label="单笔订单最大金额 (USDC)"
+                label="单笔订单最大金额 ($)"
                name="maxOrderSize"
-                tooltip="比例模式下，限制单笔跟单订单的最大金额上限，用于防止跟单金额过大，控制风险。例如：设置为 1000，即使计算出的跟单金额超过 1000，也会限制为 1000 USDC。"
+                tooltip="比例模式下，限制单笔跟单订单的最大金额上限，用于防止跟单金额过大，控制风险。例如：设置为 1000，即使计算出的跟单金额超过 1000，也会限制为 $1000。"
              >
                <InputNumber
                  min={0.01}
@@ -556,9 +609,9 @@ const TemplateList: React.FC = () => {
              </Form.Item>
              
              <Form.Item
-                label="单笔订单最小金额 (USDC)"
+                label="单笔订单最小金额 ($)"
                name="minOrderSize"
-                tooltip="比例模式下，限制单笔跟单订单的最小金额下限，用于过滤掉金额过小的订单，避免频繁小额交易。如果填写，必须 >= 1 USDC。例如：设置为 10，如果计算出的跟单金额小于 10，则跳过该订单。"
+                tooltip="比例模式下，限制单笔跟单订单的最小金额下限，用于过滤掉金额过小的订单，避免频繁小额交易。如果填写，必须 >= $1。例如：设置为 10，如果计算出的跟单金额小于 10，则跳过该订单。"
                rules={[
                  { 
                    validator: (_, value) => {
@@ -645,7 +698,7 @@ const TemplateList: React.FC = () => {
          <Divider>过滤条件（可选）</Divider>
          
          <Form.Item
-            label="最小订单深度 (USDC)"
+            label="最小订单深度 ($)"
            name="minOrderDepth"
            tooltip="检查订单簿的总订单金额（买盘+卖盘），确保市场有足够的流动性。不填写则不启用此过滤"
          >
@@ -1,6 +1,6 @@
 import { useEffect, useState } from 'react'
-import { Card, Table, Button, Space, Tag, Popconfirm, message, Typography, Modal, Form, Input } from 'antd'
-import { PlusOutlined, ReloadOutlined, DeleteOutlined, EditOutlined } from '@ant-design/icons'
+import { Card, Table, Button, Space, Tag, Popconfirm, message, Typography, Modal, Form, Input, List, Empty, Tooltip, Spin } from 'antd'
+import { PlusOutlined, ReloadOutlined, DeleteOutlined, EditOutlined, UserOutlined, KeyOutlined } from '@ant-design/icons'
 import { useTranslation } from 'react-i18next'
 import { apiService } from '../services/api'
 import { useMediaQuery } from 'react-responsive'
@@ -219,46 +219,164 @@ const UserList: React.FC = () => {

  return (
    <div>
-      <Card>
-        <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '16px' }}>
-          <Title level={4} style={{ margin: 0 }}>{t('userList.title') || '用户管理'}</Title>
-          <Space>
-            <Button
-              icon={<EditOutlined />}
-              onClick={() => setUpdateOwnPasswordModalVisible(true)}
-            >
-              {t('userList.updateMyPassword') || '修改我的密码'}
-            </Button>
-            <Button
-              icon={<ReloadOutlined />}
-              onClick={fetchUsers}
-              loading={loading}
-            >
-              {t('common.refresh') || '刷新'}
-            </Button>
-            {isDefaultUser && (
+      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', marginBottom: '20px', flexWrap: 'wrap', gap: '12px' }}>
+        <Title level={isMobile ? 4 : 3} style={{ margin: 0, fontSize: isMobile ? '18px' : undefined }}>{t('userList.title') || '用户管理'}</Title>
+        <Space size={8} wrap>
+          <Button
+            icon={<KeyOutlined />}
+            onClick={() => setUpdateOwnPasswordModalVisible(true)}
+            size={isMobile ? 'middle' : 'large'}
+            style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px' }}
+          >
+            {isMobile ? (t('userList.updateMyPassword') || '改密') : (t('userList.updateMyPassword') || '修改我的密码')}
+          </Button>
+          <Button
+            icon={<ReloadOutlined />}
+            onClick={fetchUsers}
+            loading={loading}
+            size={isMobile ? 'middle' : 'large'}
+            style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px' }}
+          >
+            {t('common.refresh') || '刷新'}
+          </Button>
+          {isDefaultUser && (
+            <Tooltip title={t('userList.addUser') || '新增用户'}>
              <Button
                type="primary"
                icon={<PlusOutlined />}
                onClick={() => setCreateModalVisible(true)}
-              >
-                {t('userList.addUser') || '新增用户'}
-              </Button>
+                size={isMobile ? 'middle' : 'large'}
+                style={{ borderRadius: '8px', height: isMobile ? '40px' : '48px', fontSize: isMobile ? '14px' : '16px' }}
+              />
+            </Tooltip>
+          )}
+        </Space>
+      </div>
+
+      <Card style={{ borderRadius: '12px', boxShadow: '0 2px 8px rgba(0,0,0,0.08)', border: '1px solid #e8e8e8' }} bodyStyle={{ padding: isMobile ? '12px' : '24px' }}>
+        {isMobile ? (
+          // 移动端卡片布局
+          <div>
+            {loading ? (
+              <div style={{ textAlign: 'center', padding: '40px' }}>
+                <Spin size="large" />
+              </div>
+            ) : users.length === 0 ? (
+              <Empty description={t('userList.noData') || '暂无用户数据'} />
+            ) : (
+              <List
+                dataSource={users}
+                renderItem={(user) => (
+                  <Card
+                    key={user.id}
+                    style={{
+                      marginBottom: '10px',
+                      borderRadius: '10px',
+                      boxShadow: '0 1px 3px rgba(0,0,0,0.08)',
+                      border: '1px solid #e8e8e8',
+                      overflow: 'hidden'
+                    }}
+                    bodyStyle={{ padding: '0' }}
+                  >
+                    {/* 头部区域 - 用户名 */}
+                    <div style={{
+                      padding: '10px 12px',
+                      background: 'var(--ant-color-primary, #1677ff)',
+                      color: '#fff'
+                    }}>
+                      <div style={{ fontSize: '15px', fontWeight: '600', marginBottom: '2px', display: 'flex', alignItems: 'center', gap: '6px' }}>
+                        <UserOutlined style={{ fontSize: '14px' }} />
+                        <span>{user.username}</span>
+                      </div>
+                      <div style={{ fontSize: '12px', opacity: '0.9' }}>
+                        ID: {user.id}
+                      </div>
+                    </div>
+
+                    {/* 角色信息区域 */}
+                    <div style={{
+                      padding: '8px 12px',
+                      backgroundColor: '#fafafa',
+                      borderBottom: '1px solid #f0f0f0',
+                      minHeight: '42px',
+                      display: 'flex',
+                      alignItems: 'center'
+                    }}>
+                      <div style={{ display: 'flex', justifyContent: 'space-between', alignItems: 'center', width: '100%' }}>
+                        <div>
+                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
+                            {t('userList.role') || '角色'}
+                          </div>
+                          <Tag color={user.isDefault ? 'red' : 'blue'} style={{ margin: 0 }}>
+                            {user.isDefault ? (t('userList.defaultAccount') || '默认账户') : (t('userList.normalUser') || '普通用户')}
+                          </Tag>
+                        </div>
+                        <div style={{ textAlign: 'right' }}>
+                          <div style={{ fontSize: '10px', color: '#8c8c8c' }}>
+                            {t('common.createdAt') || '创建时间'}
+                          </div>
+                          <div style={{ fontSize: '12px', fontWeight: '500', color: '#666' }}>
+                            {new Date(user.createdAt).toLocaleDateString(i18n.language || 'zh-CN')}
+                          </div>
+                        </div>
+                      </div>
+                    </div>
+
+                    {/* 操作区域（仅管理员可见） */}
+                    {isDefaultUser && !user.isDefault && (
+                      <div style={{
+                        padding: '8px 12px',
+                        display: 'flex',
+                        justifyContent: 'space-around',
+                        alignItems: 'center'
+                      }}>
+                        <Tooltip title={t('userList.updatePassword') || '修改密码'}>
+                          <div
+                            onClick={() => {
+                              setSelectedUser(user)
+                              setUpdatePasswordModalVisible(true)
+                            }}
+                            style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}
+                          >
+                            <KeyOutlined style={{ fontSize: '18px', color: '#1890ff' }} />
+                            <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('userList.updatePassword') || '改密'}</span>
+                          </div>
+                        </Tooltip>
+
+                        <Popconfirm
+                          title={t('userList.deleteConfirm') || '确定要删除这个用户吗？'}
+                          onConfirm={() => handleDelete(user)}
+                          okText={t('common.confirm') || '确定'}
+                          cancelText={t('common.cancel') || '取消'}
+                        >
+                          <Tooltip title={t('common.delete') || '删除'}>
+                            <div style={{ display: 'flex', flexDirection: 'column', alignItems: 'center', cursor: 'pointer', padding: '4px 8px' }}>
+                              <DeleteOutlined style={{ fontSize: '18px', color: '#ff4d4f' }} />
+                              <span style={{ fontSize: '10px', color: '#8c8c8c', marginTop: '2px' }}>{t('common.delete') || '删除'}</span>
+                            </div>
+                          </Tooltip>
+                        </Popconfirm>
+                      </div>
+                    )}
+                  </Card>
+                )}
+              />
            )}
-          </Space>
-        </div>
-        <Table
-          columns={columns}
-          dataSource={users}
-          rowKey="id"
-          loading={loading}
-          pagination={{
-            pageSize: isMobile ? 10 : 20,
-            showSizeChanger: !isMobile,
-            showTotal: (total) => t('userList.total', { total }) || `共 ${total} 条`
-          }}
-          scroll={isMobile ? { x: 600 } : undefined}
-        />
+          </div>
+        ) : (
+          <Table
+            columns={columns}
+            dataSource={users}
+            rowKey="id"
+            loading={loading}
+            pagination={{
+              pageSize: isMobile ? 10 : 20,
+              showSizeChanger: !isMobile,
+              showTotal: (total) => t('userList.total', { total }) || `共 ${total} 条`
+            }}
+            scroll={isMobile ? { x: 600 } : undefined}
+          />
+        )}
      </Card>

      {/* 创建用户弹窗 */}
@@ -1,5 +1,5 @@
 import axios, { AxiosInstance, AxiosError } from 'axios'
-import type { ApiResponse, NotificationConfig, NotificationConfigRequest, NotificationConfigUpdateRequest } from '../types'
+import type { ApiResponse, NotificationConfig, NotificationConfigRequest, NotificationConfigUpdateRequest, NotificationTemplate, TemplateTypeInfo, TemplateVariablesResponse } from '../types'
 import { getToken, setToken, removeToken } from '../utils'
 import { wsManager } from './websocket'
 import i18n from '../i18n/config'
@@ -284,9 +284,21 @@ export const apiService = {
    /**
     * 赎回仓位
     */
-    redeemPositions: (data: any) => 
+    redeemPositions: (data: any) =>
      apiClient.post<ApiResponse<any>>('/accounts/positions/redeem', data),
-    
+
+    /**
+     * 将 USDC.e wrap 为 pUSD（V2 迁移）
+     */
+    wrapToPusd: (accountId: number) =>
+      apiClient.post<ApiResponse<{ transactionHash: string | null }>>('/accounts/wrap-to-pusd', { accountId }),
+
+    /**
+     * 查询 USDC.e 余额（V2 迁移用）
+     */
+    getUsdceBalance: (accountId: number) =>
+      apiClient.post<ApiResponse<{ balance: string }>>('/accounts/usdce-balance', { accountId }),
+
  },
  
  /**
@@ -494,14 +506,26 @@ export const apiService = {
      endDate?: number
    }) =>
      apiClient.post<ApiResponse<{ list: import('../types').CryptoTailStrategyTriggerDto[]; total: number }>>('/crypto-tail-strategy/triggers', data),
+    pnlCurve: (data: import('../types').CryptoTailPnlCurveRequest) =>
+      apiClient.post<ApiResponse<import('../types').CryptoTailPnlCurveResponse>>('/crypto-tail-strategy/pnl-curve', data),
    marketOptions: () =>
      apiClient.post<ApiResponse<import('../types').CryptoTailMarketOptionDto[]>>('/crypto-tail-strategy/market-options', {}),
    autoMinSpread: (data: { intervalSeconds: number }) =>
      apiClient.post<ApiResponse<import('../types').CryptoTailAutoMinSpreadResponse>>('/crypto-tail-strategy/auto-min-spread', data),
-    monitorInit: (strategyId: number) =>
-      apiClient.post<ApiResponse<import('../types').CryptoTailMonitorInitResponse>>('/crypto-tail-strategy/monitor/init', { strategyId })
+    monitorInit: (data: { strategyId: number; periodStartUnix?: number }) =>
+      apiClient.post<ApiResponse<import('../types').CryptoTailMonitorInitResponse>>('/crypto-tail-strategy/monitor/init', data),
+    manualOrder: (data: {
+      strategyId: number
+      periodStartUnix: number
+      direction: 'UP' | 'DOWN'
+      price: string
+      size: string
+      marketTitle: string
+      tokenIds: string[]
+    }) =>
+      apiClient.post<ApiResponse<import('../types').CryptoTailManualOrderResponse>>('/crypto-tail-strategy/manual-order', data)
  },
-  
+
  /**
   * 订单管理 API
   */
@@ -674,7 +698,51 @@ export const apiService = {
     * 获取 Telegram Chat IDs
     */
    getTelegramChatIds: (data: { botToken: string }) =>
-      apiClient.post<ApiResponse<string[]>>('/system/notifications/telegram/get-chat-ids', data)
+      apiClient.post<ApiResponse<string[]>>('/system/notifications/telegram/get-chat-ids', data),
+
+    // ==================== 模板相关 API ====================
+
+    /**
+     * 获取所有模板类型
+     */
+    getTemplateTypes: () =>
+      apiClient.post<ApiResponse<TemplateTypeInfo[]>>('/system/notifications/templates/types', {}),
+
+    /**
+     * 获取所有模板列表
+     */
+    getTemplates: () =>
+      apiClient.post<ApiResponse<NotificationTemplate[]>>('/system/notifications/templates/list', {}),
+
+    /**
+     * 获取单个模板详情
+     */
+    getTemplateDetail: (data: { templateType: string }) =>
+      apiClient.post<ApiResponse<NotificationTemplate>>('/system/notifications/templates/detail', data),
+
+    /**
+     * 获取模板可用变量
+     */
+    getTemplateVariables: (data: { templateType: string }) =>
+      apiClient.post<ApiResponse<TemplateVariablesResponse>>('/system/notifications/templates/variables', data),
+
+    /**
+     * 更新模板
+     */
+    updateTemplate: (data: { templateType: string; templateContent: string }) =>
+      apiClient.post<ApiResponse<NotificationTemplate>>('/system/notifications/templates/update', data),
+
+    /**
+     * 重置模板为默认
+     */
+    resetTemplate: (data: { templateType: string }) =>
+      apiClient.post<ApiResponse<NotificationTemplate>>('/system/notifications/templates/reset', data),
+
+    /**
+     * 发送模板测试消息
+     */
+    testTemplate: (data: { templateType: string; templateContent?: string }) =>
+      apiClient.post<ApiResponse<boolean>>('/system/notifications/templates/test', data)
  },
  
  /**
@@ -580,12 +580,13 @@ export interface OrderMessage {

 /**
 * 订单详情（通过 API 获取）
+ * price 为订单限价，avgFilledPrice 为平均成交价（有成交时优先用于展示）
 */
 export interface OrderDetail {
  id: string  // 订单 ID
  market: string  // 市场 ID (condition ID)
  side: string  // BUY/SELL
-  price: string  // 价格
+  price: string  // 订单限价
  size: string  // 订单大小
  filled: string  // 已成交数量
  status: string  // 订单状态
@@ -593,6 +594,7 @@ export interface OrderDetail {
  marketName?: string  // 市场名称
  marketSlug?: string  // 市场 slug
  marketIcon?: string  // 市场图标
+  avgFilledPrice?: string  // 平均成交价（有成交时优先展示）
 }

 /**
@@ -1097,6 +1099,33 @@ export interface CryptoTailStrategyTriggerDto {
  createdAt: number
 }

+/** 收益曲线请求 */
+export interface CryptoTailPnlCurveRequest {
+  strategyId: number
+  startDate?: number
+  endDate?: number
+}
+
+/** 收益曲线单点 */
+export interface CryptoTailPnlCurvePoint {
+  timestamp: number
+  cumulativePnl: string
+  pointPnl: string
+  settledCount: number
+}
+
+/** 收益曲线响应 */
+export interface CryptoTailPnlCurveResponse {
+  strategyId: number
+  strategyName: string
+  totalRealizedPnl: string
+  settledCount: number
+  winCount: number
+  winRate: string | null
+  maxDrawdown: string | null
+  curveData: CryptoTailPnlCurvePoint[]
+}
+
 /**
 * 加密价差策略市场选项
 */
@@ -1156,6 +1185,10 @@ export interface CryptoTailMonitorInitResponse {
  currentTimestamp: number
  /** 是否启用 */
  enabled: boolean
+  /** 投入金额模式: FIXED or RATIO */
+  amountMode?: string
+  /** 投入金额数值 */
+  amountValue?: string
 }

 /**
@@ -1203,3 +1236,76 @@ export interface CryptoTailMonitorPushData {
  /** 周期是否已结束 */
  periodEnded: boolean
 }
+
+export interface CryptoTailManualOrderResponse {
+  /** 是否成功 */
+  success: boolean
+  /** 订单ID */
+  orderId?: string
+  /** 提示消息 */
+  message: string
+  /** 下单详情 */
+  orderDetails?: ManualOrderDetails
+}
+
+export interface ManualOrderDetails {
+  /** 策略ID */
+  strategyId: number
+  /** 方向 */
+  direction: string
+  /** 下单价格 */
+  price: string
+  /** 下单数量 */
+  size: string
+  /** 总金额 */
+  totalAmount: string
+}
+
+// ==================== 消息模板相关类型 ====================
+
+/**
+ * 消息模板
+ */
+export interface NotificationTemplate {
+  id?: number
+  templateType: string  // 模板类型
+  templateContent: string  // 模板内容
+  isDefault: boolean  // 是否使用默认模板
+  createdAt?: number
+  updatedAt?: number
+}
+
+/**
+ * 模板类型信息
+ */
+export interface TemplateTypeInfo {
+  type: string  // 模板类型
+  name: string  // 类型名称
+  description: string  // 类型描述
+}
+
+/**
+ * 模板变量
+ */
+export interface TemplateVariable {
+  key: string  // 变量名
+  category: string  // 分类
+  sortOrder: number  // 排序顺序
+}
+
+/**
+ * 模板变量分类
+ */
+export interface TemplateVariableCategory {
+  key: string  // 分类 key
+  sortOrder: number  // 排序顺序
+}
+
+/**
+ * 模板变量列表响应
+ */
+export interface TemplateVariablesResponse {
+  templateType: string  // 模板类型
+  categories: TemplateVariableCategory[]  // 分类列表
+  variables: TemplateVariable[]  // 变量列表
+}
Author	SHA1	Message	Date
WrBug	6a6af6f5e9	fix: handle neg_risk market in sellPosition Fixes #38 The sellPosition method was not checking if the market uses Neg Risk Exchange contract. For neg_risk markets, the order signing must use the Neg Risk Exchange address, otherwise the order will be rejected by Polymarket. The copy trading service already handles this correctly, but the manual sell position flow was missing this check.	2026-04-29 14:35:43 +08:00
WrBug	4b58b7cd46	Merge pull request #57 from WrBug/dev	2026-04-28 22:32:45 +08:00
WrBug	8ab8ae5205	style: 全局将 USDC 展示替换为 $ 符号前端所有金额展示从 "100.00 USDC" 改为 "$100.00" 格式，后端 Telegram 通知模板和错误提示同步更新。 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-04-28 22:23:49 +08:00
WrBug	0769022878	feat: 添加 CLOB 2.0 迁移弹窗提醒与账户页迁移引导登录后首次进入显示迁移提醒弹窗，引导用户前往账户页；账户页首次进入时显示 Alert 提示 USDC.e → pUSD 迁移按钮；移动端账户卡片补充 swap 操作按钮。 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-04-28 21:59:15 +08:00
WrBug	06a122dd34	fix: 迁移链路外统一改为仅识别 pUSD 移除链上监听中对 USDC.e 的抵押品匹配，并将解包与审批相关说明统一为 pUSD 语义，避免在非 swap/wrap 流程继续使用 USDC.e。 Made-with: Cursor	2026-04-28 21:40:41 +08:00
WrBug	fb6b469e9f	fix: 修复 CLOB V2 下代理交易与链上成交解析问题调整 CLOB API 地址并优化 Magic Proxy 的执行与 gas 限制，避免 wrap 与 relay 调用在 V2 环境下异常回滚。同时补充 pUSD/USDC.e 兼容与 ERC1155-only 成交价格回填逻辑，提升链上成交解析稳定性。 Made-with: Cursor	2026-04-28 21:34:43 +08:00
WrBug	22a6544373	feat: CLOB V1 → V2 完整迁移 - 更新 EIP-712 签名结构: domain version "1"→"2", 移除 taker/expiration/nonce/feeRateBps, 新增 timestamp/metadata/builder - 更新合约地址为 V2 (CTF_EXCHANGE, NEG_RISK_EXCHANGE) - CLOB URL 切换到 clob-v2.polymarket.com - 抵押品代币 USDC.e → pUSD (0xC011a7E12a19f7B1f670d46F03B03f3342E82DFB) - 新增 USDC.e → pUSD wrap 功能 (CollateralOnramp 合约) - SignedOrderObject 补充 API payload 必需的 taker/expiration 字段 - NewOrderRequest 补充 deferExec/postOnly 字段 - 前端账户管理新增 pUSD 迁移按钮 - 移除所有 feeRateBps 相关逻辑 Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>	2026-04-20 22:24:50 +08:00
WrBug	04b7505094	Merge branch 'dev' Made-with: Cursor	2026-03-30 12:55:20 +08:00
WrBug	2056417749	Merge pull request #41 from WrBug/ai_fix/n_39 fix: backtest equity curve bugs	2026-03-30 11:32:36 +08:00
WrBug	748c871af4	fix: backtest equity curve bugs (#39 ) - Fix SELL logic: correctly reduce position.quantity after selling (core bug) Previously positions were never decremented, causing sold positions to be settled again at backtest end, inflating final balance. - Fix settleRemainingPositions: profitLoss now correctly computes settlementValue - cost (was incorrectly using settlementValue.negate()) - Fix max drawdown calculation: use current balance instead of previous iteration's runningBalance - Frontend: add comment noting chart shows cash balance, not total equity	2026-03-28 18:06:06 +08:00
WrBug	53f1381c3b	chore: 移除 Bug 报告模板中手动添加 label 的文案 Made-with: Cursor	2026-03-10 12:53:06 +08:00
WrBug	4a3ebb674e	chore: 移除 Bug 报告模板中的 AI 自动修复确认复选框 Made-with: Cursor	2026-03-10 12:46:41 +08:00
WrBug	2b570a432a	fix(ci): 解析 Issue 编号时 grep 无匹配导致 step 退出 PR 描述中无 Closes/Fixes/Resolves #N 时，grep 返回 1，set -e 导致脚本在未执行分支名回退逻辑前即退出。为管道添加 \|\| true，使无匹配时继续从分支名 ai_fix/N_xxx 解析 Issue 编号。 Made-with: Cursor	2026-03-10 12:44:52 +08:00
WrBug	5412a0eb49	Merge pull request #37 from WrBug/ai_fix/35_bug_1usdc fix: #35 [Bug] / 价差策略按比例买入，购买的价值小于1usdc时，会下单失败	2026-03-10 12:40:12 +08:00
WrBug	7b4e702da9	ci(close-issue): add Telegram notification when AI-fixed issue is closed - Get issue details (title, url) for TG message - Send TG via TELEGRAM_BOT_TOKEN/TELEGRAM_CHAT_ID (same as docker-build) - Use GH_TOKEN from GITHUB_TOKEN for gh CLI Made-with: Cursor	2026-03-10 12:39:33 +08:00
WrBug	e32697e7ee	ci: add workflow to close issue when PR is merged - Trigger on pull_request closed (merged) to main - Parse issue number from PR body (Closes #N) or branch name (ai_fix/N_xxx) - Close linked issue via GitHub API if still open Made-with: Cursor	2026-03-10 12:34:35 +08:00
WrBug	d8a75fc8dd	fix: #35 [Bug] / 价差策略按比例买入，购买的价值小于1usdc时，会下单失败	2026-03-10 12:18:03 +08:00
WrBug	6cb48bb6cc	Update AI bug report template to bilingual (English/Chinese)	2026-03-10 02:59:34 +08:00
WrBug	e78785de7c	Add AI bug report template	2026-03-10 02:59:33 +08:00
WrBug	915d4570df	Update AI bug report template to bilingual (English/Chinese)	2026-03-10 02:39:50 +08:00
WrBug	48d6e82f43	Add AI bug report template	2026-03-10 02:30:26 +08:00
WrBug	46c32df421	fix(notification): 优化移动端消息设置页面交互体验 - 修复移动端 Tooltip 与点击事件冲突导致变量无法复制的问题 - 添加移动端备用复制方法（textarea + execCommand） - 移除变量标签中的复制图标 - 移动端模板输入框调整为 15 行 - 调整系统设置菜单顺序 Made-with: Cursor	2026-03-02 23:32:26 +08:00
WrBug	686d14b6e5	fix(account): 卖出订单通知与创建订单失败错误展示 - 手动卖出订单通知：side 固定为 SELL，outcome 使用 request.side（市场方向） - 创建订单失败时从 API errorBody 解析 error 字段（Gson），用于 TG 通知展示 - 成功/失败分支均使用 NewOrderResponse.getErrorMessage() 获取错误文案 Made-with: Cursor	2026-03-02 23:08:23 +08:00
WrBug	561ebf0ce3	feat(订单推送/通知): 按实际成交价与 size_matched 展示价格与数量 - 实际成交价公式: original_size * price / size_matched，数量展示用 size_matched - OrderPushService/OrderStatusUpdateService/CryptoTail: 用公式计算 avgFilledPrice，移除 getTrades 依赖 - TelegramNotificationService: 有 avgFilledPrice 时展示数量用 filled，ORDER_SUCCESS/CRYPTO_TAIL 一致 - 前端订单推送: 有成交时展示 size_matched；无 orderDetail 时用 WebSocket 数据计算价格与数量 - OrderDetailDto 增加 avgFilledPrice；PolymarketClobService 移除 getAvgFilledPriceFromTradeIds Made-with: Cursor	2026-03-02 23:05:15 +08:00
WrBug	b8e10f340c	feat(skills): 添加 create-release skill 支持自动发布公告 - 将 create-release.sh 脚本改造为 Cursor skill - 支持生成中英文 Release 内容 - 自动在 Issue #1 发布面向用户的公告 - 支持 commit 过滤（排除版本内修复） Made-with: Cursor	2026-03-02 22:16:28 +08:00
WrBug	9c70dc762f	fix(frontend): 移除未使用变量与导入以消除 TS 报错 Made-with: Cursor	2026-03-02 22:07:04 +08:00
WrBug	8f0a49493c	refactor(notification): 优化模板配置布局并完善多语言支持 - 布局优化：模板类型改为顶部Tabs，内容区70%+变量面板30% - 变量Tag UI优化：更精致的样式和悬浮效果 - 多语言：添加模板类型描述、变量label/description的i18n key（三语言） - 后端精简：移除DTO中冗余的label/description/templateTypeName字段 - 清理：移除未使用的templates状态和fetchTemplates方法 Made-with: Cursor	2026-03-02 22:02:00 +08:00
WrBug	e7af4d4821	feat: 消息推送自定义模板与独立设置页后端: - 新增通知模板表与实体、DTO、Repository、NotificationTemplateService - 支持 {{variable}} 模板语法，提供模板类型与变量接口 - TelegramNotificationService 改为通过模板渲染发送（ORDER_SUCCESS/ORDER_FAILED/ORDER_FILTERED/CRYPTO_TAIL_SUCCESS/REDEEM_SUCCESS/REDEEM_NO_RETURN） - 模板 CRUD、重置默认、测试发送接口 - 补全订单过滤相关 i18n key（zh/en/zh-TW）前端: - 消息推送设置抽离为独立页 /system-settings/notification - 系统设置概览改为入口卡片，侧栏增加「消息推送设置」菜单 - NotificationSettingsPage: 机器人配置 + 模板配置双卡片布局（与概览一致） - 模板配置支持选择类型、编辑内容、变量面板（点击复制、悬停说明）、保存/重置/测试 - 多语言 key 补全（notificationSettings.templates.、templateTypes.） Made-with: Cursor	2026-03-02 21:31:45 +08:00
WrBug	83bc209489	refactor(ci): simplify docker-build workflow and update TG notifications - Remove package-only build type, unify to single build flow - Add TG notification after package upload (before Docker build) - Add TG notification after Docker image push - Update notification messages to English - Rename "Tag" to "Version" in notifications Made-with: Cursor	2026-03-02 17:58:36 +08:00
WrBug	9b6cc63158	refactor(frontend): 优化仓位管理列表视图列结构将12列精简为8列： - 合并"数量"和"平均价格"为"持仓"列 - 合并"当前价格"、"当前价值"、"盈亏"、"已实现盈亏"为"当前价值/盈亏"列 - 减少列宽度，提升表格紧凑性 Made-with: Cursor	2026-03-02 17:54:03 +08:00
WrBug	96d224a5a3	fix(frontend): 移除 CryptoTailStrategyList 未使用的 useRef 导入 Made-with: Cursor	2026-03-02 17:44:10 +08:00
WrBug	97249db546	style(copy-trading): 跟单列表操作列改为图标按钮样式 - 操作列编辑、统计等改为 Tooltip+图标点击，与策略列表风格统一 - 操作列宽度 200 -> 160 Made-with: Cursor	2026-03-02 17:40:44 +08:00
WrBug	46e10ebdd8	feat(crypto-tail): 加密价差策略收益曲线与交互优化 - 后端: 收益曲线 API (pnl-curve)、CryptoTailStrategyService.getPnlCurve、gt 扩展导入 - 前端: CryptoTailPnlCurveModal 弹窗，统计卡片+时间筛选+ECharts 累计收益图 - 策略列表: 桌面/移动端「收益曲线」入口，图标改为蓝色(#1890ff) - 切换时间范围保留旧数据避免图表容器卸载导致空白 - 今日/7天/30天用折线、全部用平滑曲线 - 多语言: viewPnlCurve、pnlCurve.* (zh-CN/zh-TW/en) Made-with: Cursor	2026-03-02 17:39:23 +08:00
WrBug	4ebfacfc21	feat(frontend): 优化多个列表页面 UI，添加空状态提示 - 优化 AccountList、BacktestList、CopyTradingList、CryptoTailStrategyList、LeaderList、TemplateList、UserList 页面操作栏 - 添加空数据状态提示 - 添加相关多语言翻译 key Made-with: Cursor	2026-03-01 06:48:51 +08:00
WrBug	f86749e85d	feat(frontend): 优化 Leader 列表 UI，使用图标操作栏 - 移动端：Cell 样式美化，渐变背景头部，资产常驻显示 - PC 端：操作列改用图标，合并跟单/回测数到图标 Badge - 跟单/回测数量用 Badge 显示，数量为 0 时半透明禁用 Made-with: Cursor	2026-03-01 05:57:34 +08:00
WrBug	3cc37dac55	feat(backend): 优化通知推送，区分输赢并显示可用余额 - 赎回通知区分输赢：赢的仓位显示"赎回成功"，输的仓位显示"已结算（无收益）" - 买入/卖出/赎回通知消息中添加钱包可用余额显示 - 新增多语言文案支持 Made-with: Cursor	2026-03-01 05:41:04 +08:00
WrBug	5483a1aa77	feat(frontend): 优化加密价差监控页面体验 - 刷新页面时保留当前选择的策略（localStorage 缓存） - 移动端下单弹窗改为 BottomSheet 样式，更紧凑 - 买入按钮实时显示当前价格，如 "买入 Up (0.50)" - 周期切换时自动关闭弹窗并提示用户 Made-with: Cursor	2026-02-27 04:11:55 +08:00
WrBug	e5acad5091	fix(frontend): 限制下单价格最高为 0.99 - 修改所有价格限制从 1 改为 0.99 - 影响位置： - handleOpenManualOrderModal: 默认价格计算 - handlePriceChange: 手动修改价格 - handleFetchLatestPrice: 获取最新价 - handleSizeChange: 修改数量时重新计算价格 - handleManualOrder: 提交订单时 - 确保价格不会超过 Polymarket 的最高限制 0.99 Made-with: Cursor	2026-02-26 21:36:59 +08:00
WrBug	1688fa9633	feat(frontend): 优化"最大"按钮计算，支持保留2位小数 - 修改前：只能整数数量，导致余额浪费 - 示例：余额2.95U，价格0.86 → 数量3张（浪费0.37U） - 修改后：保留2位小数，充分利用余额 - 示例：余额2.95U，价格0.86 → 数量3.43张（利用全部余额） Made-with: Cursor	2026-02-26 21:30:18 +08:00
WrBug	1967d97c31	fix(frontend): 修复 RATIO 模式下金额被错误截断的问题 - 移除 RATIO 模式下对 defaultAmountUsdc 的 Math.floor 取整 - 保持精确的金额用于计算数量，确保符合用户预期 - 修复示例：60%比例，余额2.95U，价格0.682 - 修复前：数量 = 1.47（金额被截断为1U） - 修复后：数量 = 2.60（金额正确为1.77U） Made-with: Cursor	2026-02-26 21:26:12 +08:00
WrBug	79b154515d	feat(frontend): 手动下单功能增强与金额模式支持 - 后端返回 amountMode 和 amountValue 字段，支持前端获取策略配置 - 手动下单确认弹窗显示用户可用余额（绿色高亮） - 价格输入框右侧添加"获取最新价"按钮，支持实时更新价格 - 数量输入框右侧添加"最大"按钮，根据余额自动计算最大购买数量 - 修正数量计算逻辑：FIXED 和 RATIO 模式均按实际金额计算数量，保留2位小数 - FIXED 模式：使用配置的固定金额 - RATIO 模式：按比例计算可用余额 - 数量计算使用保留小数方式（而非向上取整），确保精确匹配投入金额 - 示例：固定1U，价格0.4，自动填充2.5张 - 示例：比例30%，余额20U，价格0.4，自动填充15张 Made-with: Cursor	2026-02-26 21:19:06 +08:00
WrBug	9b4d8fc001	feat(frontend): 优化加密价差策略监控页面移动端体验 - 移动端策略选择器：标题与下拉框垂直布局，支持换行显示 - 下拉框选项支持文本换行，避免长策略名称被截断 - 移动端手动下单按钮改为底部悬浮固定显示 - 两个按钮均分屏幕宽度，符合移动端触摸操作规范 Made-with: Cursor	2026-02-26 20:50:46 +08:00
WrBug	cb1f43871a	fix(crypto-tail): 周期切换时按周期拉取 tokenIds，修复手动下单 orderbook 不存在 - 后端 initMonitor 支持可选 periodStartUnix，按指定周期取市场与 tokenIds - 前端周期切换时调用 monitorInit 传入 pushPeriod，确保 tokenIds 与当前周期一致 - 修复切换周期无变化及手动下单报 orderbook does not exist Made-with: Cursor	2026-02-26 20:43:27 +08:00
WrBug	a2be5b7f52	feat(crypto-tail): 价差策略监控页手动下单与 UI 优化 - 后端：手动下单 API，trigger_type 区分 AUTO/MANUAL，价格 4 位小数向上取整 - 前端：监控页手动买入 Up/Down 按钮、二次确认弹窗、策略信息移动端适配 - 下单价格最多 4 位小数；确认页方向仅显示 Up/Down；按钮文案改为「买入 Up/Down」 Made-with: Cursor	2026-02-26 19:23:00 +08:00
WrBug	708d6ddb41	fix(binance): 修复 K 线 WebSocket 断开后无法重连导致 openPrice/closePrice 丢失的问题当 WebSocket 因网络问题断开时，updateSubscriptions() 只检查订阅集合是否相同，未检查连接是否真的存在，导致断开后无法重连。现在会额外检查需要的连接是否都存在，如果缺失则重新建立连接。 Made-with: Cursor	2026-02-26 10:28:28 +08:00
WrBug	0fb015f6d3	Merge pull request #33 from WrBug/dev Release v2.3.3: 加密价差策略与尾盘监控优化	2026-02-25 21:34:54 +08:00
WrBug	a0c2d7995b	Merge pull request #32 from WrBug/dev Release v2.3.2: 尾盘策略多市场与币安按需订阅	2026-02-20 23:50:10 +08:00
WrBug	7c1f8df590	Merge pull request #31 from WrBug/dev feat: 账户设置、尾盘策略与文档整理	2026-02-18 03:29:38 +08:00