open-git/nofx
1
0
Fork 0
mirror of https://github.com/NoFxAiOS/nofx.git synced 2025-12-06 13:54:41 +08:00
Code Issues Packages Projects Releases Wiki Activity

merge dev

Browse Source
This commit is contained in:
Icy
2025-11-12 23:40:58 +08:00
parent 802a4df7c1 db9851b993
commit 190b0c29d4
140 changed files with 33470 additions and 4481 deletions
Download Patch File Download Diff File Expand all files Collapse all files

329
.claude/commands/20-code-review.md Normal file
View File

@@ -0,0 +1,329 @@
---
name: code-review
description: 通用代码审查命令，基于业务需求进行白盒逻辑正确性审查和技术架构评估
---
# 代码审查命令
## 审查任务
请对当前工作区的代码修改进行全面审查，重点关注业务逻辑的正确性和技术架构的合理性。
## 审查维度
### 1. 业务层面审查（BLOCKING级别）
- **需求来源验证**：寻找并验证业务需求来源（不能基于代码反推需求）
- **需求实现完整性**：验证代码是否100%满足业务需求
- **业务流程逻辑正确性**：检查状态转换、数据流、条件判断的逻辑
- **数据结构正确性**：验证模型定义、字段约束、业务规则映射
- **Edge Case处理**：评估边界条件和异常场景的处理合理性
### 2. 技术层面审查
- **架构合理性**：模块化、职责分离、依赖关系
- **KISS原则遵循**：避免过度工程化
- **扩展性评估**：未来功能添加的容易程度
- **非Adhoc修改验证**：是否遵循现有代码模式
- **性能问题检测**：查找明显的性能问题（如N+1查询等）
- **单元测试完备性**：核心逻辑90%覆盖率要求
### 3. 契约与连通性专项检查（BLOCKING）
- 端点一致性：前端端点集中配置；路径/动态段/大小写/末尾分隔符与后端路由完全一致；HTTP 方法语义匹配（幂等/副作用）。
- 认证与跨域：统一的认证机制（会话/令牌）；前端传递方式与后端期望一致（Cookie/Authorization 等）；跨域与 CSRF 策略匹配。
- 请求/响应 Schema：字段名、类型、必选/可选一致；时间/数值/布尔的编码一致；分页/排序参数与响应元信息对齐。
- 错误与状态码：4xx/5xx 使用合理；错误负载结构稳定且可解析；前端根据错误类型提供可恢复提示。
- 异步/事件（如有）：事件类型与载荷字段与文档一致；开始/结束/错误/心跳等语义完整；增量合并无丢失/重复；存在降级路径。
- 端到端透传：API→Service→下游（存储/第三方）参数（上下文/会话/区域/幂等键）无遗漏；写操作具备幂等/去重策略。
- 日志与隐私：日志含必要上下文（追踪/用户/会话），敏感信息脱敏；UI 默认不展示内部实现细节。
#### 全链路 Contract Crosswalk（必做）
- 选取关键用户流，建立“参数对齐矩阵”：
- 前端请求 → 后端路由/处理 → 服务层 → 下游（存储/第三方）→ 持久化字段。
- 列出每个参数：`name | type | required | default | source-of-truth(文件:行)`。
- 如存在事件/流式契约，补充事件类型与载荷字段，以及必要的状态回写。
- 输出差异点与最小修复建议（谁改、改哪、如何不破坏现有行为）。
### 4. 高发问题清单（优先排查）
- 命名错位：不同层对同一概念使用了不同命名风格或名称（例如 `camelCase` ↔ `snake_case`、标识符命名不一致）。
- 路径错位：端点路径或动态段命名不一致；末尾分隔符导致重定向或方法失败。
- 类型漂移：数字/字符串/布尔/时间类型在层间编码不一致或未正确转换。
- 认证混用：请求在不同处使用了不同认证方式；跨域请求未按需携带凭证；CSRF 保护缺失。
- 事件缺口：后端新增事件类型或字段未在前端解析；增量合并逻辑导致重复/丢失。
- 可见性/状态：后端状态位或可见性字段被忽略，导致 UI 展示与真实状态不一致。
### 5. 零假设验证（VERIFY-FIRST Gate，BLOCKING）
- 禁止基于“猜测的字段/API/事件”写逻辑。每个关键元素必须给出证据：
- 模型/字段定义位置（文件:行）
- 路由/处理方法签名（文件:行）
- 前端类型/解析/调用代码（文件:行）
- 无证据的假设一律不通过。
### 6. 用户视角 E2E 可见性审计（BLOCKING）
⚠️ **这是最关键的检查** - "代码完美但功能不工作"的主要原因就是跳过了这一步！
**MANDATORY USER FLOW VERIFICATION (必须执行):**
- **完整点击路径追踪**：从用户点击开始，逐步追踪到最终状态
- 用户点击X → 调用函数Y → 导航到页面Z → 显示内容W
- **必须验证每个步骤都正确执行**
- **URL路由验证**：所有导航路径在路由配置中存在且正确处理参数
- **状态传递验证**：点击后的状态变化是否正确反映在UI中
- **错误场景测试**：参数缺失、网络错误、权限不足等场景的处理
**具体检查项目:**
- 入口可见：对应功能的入口（按钮/导航/控件）在默认场景与目标设备上可达；不被误判条件隐藏。
- **链接落地（核心）**：页面路由/回跳/深链接一致；从入口到完成形成闭环。
- 点击通知 → 是否真的跳转到预期页面？
- 分享链接 → 是否真的加载预期内容？
- 所有导航路径都必须实际追踪验证！
- 状态完整：加载/空数据/错误/权限不足 均有清晰呈现与可恢复路径。
- 角色/开关：与权限/Feature Flag 的可见性符合预期；默认值不阻断主流程。
**⛔ 禁止行为:**
- ❌ 只看代码结构，不追踪实际执行流程
- ❌ 假设navigate()调用就等于用户到达了目标页面
- ❌ 不验证URL参数处理逻辑
- ❌ 说"看起来正确"而不验证"实际正确"
### 7. Web3 AI 交易系统安全审查（BLOCKING 级别）
🔐 **资金安全是生死线** - 一个安全漏洞可能导致所有资金损失！
#### 7.1 私钥与密钥管理（CRITICAL）
- **零泄露原则**：
- ❌ 禁止：私钥/助记词出现在日志、错误消息、前端代码、Git 历史中
- ❌ 禁止：明文存储私钥（环境变量、配置文件、数据库）
- ✅ 必需：使用硬件钱包、HSM、或加密密钥管理服务（AWS KMS/Vault）
- ✅ 必需：API Key、密钥材料必须加密存储，运行时解密
- **最小权限原则**：
- 交易签名密钥与只读查询密钥分离
- 每个功能使用独立的子账户/权限
- 定期轮换 API Key 和访问令牌
- **验证检查**：
- [ ] grep 搜索 `private_key`、`mnemonic`、`seed` 等关键词，确保无硬编码
- [ ] 检查所有密钥存储位置的加密状态
- [ ] 验证密钥访问日志和审计追踪
#### 7.2 交易安全（CRITICAL）
- **签名验证**：
- ✅ 必需：所有交易必须经过签名验证
- ✅ 必需：验证交易发起者身份（防止伪造）
- ✅ 必需：使用 nonce/序列号防止重放攻击
- **交易参数验证**：
- ✅ 必需：验证接收地址合法性（checksum、白名单）
- ✅ 必需：金额/价格/滑点限制（防止异常大额交易）
- ✅ 必需：Gas Price/Gas Limit 上限保护（防止 Gas 耗尽攻击）
- ✅ 必需：Deadline/超时保护（防止过期交易执行）
- **滑点与价格保护**：
- ✅ 必需：设置合理的滑点容忍度（如 0.5%-2%）
- ✅ 必需：价格预言机验证（多源对比、时间戳检查）
- ✅ 必需：异常价格波动拒绝交易
- **验证检查**：
- [ ] 所有交易调用都有 nonce 或幂等键
- [ ] 金额/价格参数都有上下限验证
- [ ] Gas 费用有最大限制
- [ ] 滑点保护代码存在且正确
#### 7.3 AI 决策安全（CRITICAL）
- **提示注入防护**：
- ❌ 禁止：直接将用户输入拼接到 AI prompt 中
- ✅ 必需：用户输入消毒/转义（防止 prompt injection）
- ✅ 必需：系统提示与用户输入明确分离（使用角色隔离）
- ✅ 必需：敏感操作需要用户明确确认，AI 不能自主决定大额交易
- **决策审计**：
- ✅ 必需：记录所有 AI 决策的完整上下文（输入、输出、时间戳、模型版本）
- ✅ 必需：决策可追溯、可回放、可审计
- ✅ 必需：异常决策告警（如突然的大额交易建议）
- **模型安全**：
- ✅ 必需：使用官方 API，避免第三方代理（防止中间人攻击）
- ✅ 必需：API 响应验证（检测异常输出、格式错误）
- ✅ 必需：模型输出不直接执行，必须经过参数验证
- **验证检查**：
- [ ] 搜索用户输入拼接点，确保有消毒处理
- [ ] 检查决策日志是否完整（包含所有关键参数）
- [ ] 验证大额交易需要额外确认机制
#### 7.4 智能合约交互安全（CRITICAL）
- **授权范围控制**：
- ❌ 禁止：无限授权（`approve(spender, type(uint256).max)`）
- ✅ 必需：按需授权，每次交易前计算精确授权额度
- ✅ 必需：定期清理过期授权
- ✅ 必需：监控授权事件，异常授权告警
- **合约调用验证**：
- ✅ 必需：合约地址白名单（只与已审计合约交互）
- ✅ 必需：函数选择器验证（防止调用错误函数）
- ✅ 必需：调用参数类型/范围验证
- ✅ 必需：模拟执行（dry-run）后再真实执行
- **重入与异常处理**：
- ✅ 必需：处理合约调用失败情况（revert、out of gas）
- ✅ 必需：检查返回值，不假设调用成功
- ✅ 必需：避免在外部调用后修改关键状态（防重入）
- **验证检查**：
- [ ] grep `approve` 确保无无限授权
- [ ] 所有合约地址来自配置/白名单，无硬编码
- [ ] 调用失败有完整的错误处理和回退逻辑
#### 7.5 资金保护机制（BLOCKING）
- **限额控制**：
- ✅ 必需：单笔交易金额上限（如 $1000）
- ✅ 必需：日/周/月累计限额
- ✅ 必需：异常交易频率限制（防止快速耗尽资金）
- ✅ 必需：大额交易需要多重签名或延迟执行
- **紧急暂停**：
- ✅ 必需：全局紧急停止按钮（kill switch）
- ✅ 必需：异常检测自动暂停（如价格异常、Gas 费暴涨）
- ✅ 必需：暂停后资金安全提取机制
- **余额监控**：
- ✅ 必需：实时余额监控，低于阈值告警
- ✅ 必需：异常资金流出告警（大额转出、未知接收方）
- ✅ 必需：定期对账（链上余额 vs 系统记录）
- **验证检查**：
- [ ] 限额配置存在且合理
- [ ] 紧急暂停功能可测试且有权限控制
- [ ] 余额监控代码存在且接入告警系统
#### 7.6 链上数据验证（CRITICAL）
- **预言机安全**：
- ❌ 禁止：单一数据源（可被操纵）
- ✅ 必需：多预言机对比（Chainlink、Band、UMA 等）
- ✅ 必需：价格偏差检测（多源价格差异超阈值拒绝）
- ✅ 必需：时间戳验证（数据新鲜度检查，拒绝过期数据）
- **区块确认**：
- ✅ 必需：等待足够的区块确认（主网建议 ≥12 块，L2 根据实际情况）
- ✅ 必需：处理链重组可能（pending → confirmed → finalized）
- ✅ 必需：交易回执验证（status=1 成功）
- **数据完整性**：
- ✅ 必需：事件日志完整性检查（topic、参数匹配）
- ✅ 必需：合约状态一致性验证（链上 vs 本地缓存）
- ✅ 必需：MEV 保护（使用私有内存池或 Flashbots）
- **验证检查**：
- [ ] 价格数据来自多个预言机
- [ ] 区块确认数配置合理
- [ ] 交易状态检查包含 finalized 状态
## 审查结果
请给出以下三种结果之一：
- ✅ **通过**：可以直接提交
- ❌ **不通过**：存在BLOCKING问题，必须修复
- ⚠️ **需要修复**：有改进空间，建议修复
## 核心原则
1. **白盒逻辑正确性是根本**：业务逻辑错误是生死线
2. **需求驱动**：必须找到真实需求来源
3. **客观分析**：基于实际代码和需求，不自我欺骗
4. **actionable建议**：提供具体的修复指导
## 评审交付物（必须包含）
- **问题清单**：逐条指出"谁与谁不一致"（路径/参数/字段/事件/状态码），附最小复现样本。
- **最小修复建议**：明确"谁改、改哪里、如何不破坏现有调用"（可附 1-3 行级 diff 建议）。
- **兼容/过渡策略**：必要时说明双解析/版本前缀/灰度开关/降级方案。
- **🚨 E2E验证报告**：对每个用户交互流程的完整追踪验证（MANDATORY）
## 强制性E2E验证清单（必须逐项检查）
在给出审查结果前，必须完成以下验证：
### ✅ 用户点击验证
- [ ] 所有onClick处理器都能正确执行
- [ ] 处理器中的navigate()调用指向正确的路径
- [ ] 目标路径在路由配置中存在
- [ ] 目标页面能正确处理URL参数
### ✅ 导航流程验证
- [ ] 从点击到页面加载的完整路径畅通
- [ ] URL参数正确传递和解析
- [ ] 页面状态正确初始化
- [ ] 用户看到预期的内容和界面
### ✅ 状态一致性验证
- [ ] 点击后应用状态正确更新
- [ ] UI界面反映状态变化
- [ ] 没有状态不同步的问题
### ✅ 安全验证（Web3 AI 交易系统 - MANDATORY）
- [ ] **密钥安全**：无私钥泄露（日志/错误/前端/Git）
- [ ] **密钥管理**：私钥加密存储，无明文环境变量
- [ ] **交易验证**：所有交易有签名验证、nonce、金额限制
- [ ] **滑点保护**：价格/滑点验证存在且合理
- [ ] **AI 安全**：用户输入有消毒处理，无直接拼接到 prompt
- [ ] **决策审计**：AI 决策有完整日志（输入/输出/时间戳）
- [ ] **合约安全**：无无限授权，合约地址来自白名单
- [ ] **限额保护**：存在单笔/累计交易限额
- [ ] **紧急机制**：有 kill switch 或暂停功能
- [ ] **预言机安全**：价格数据来自多源，有偏差检测
- [ ] **确认机制**：大额交易需要用户明确确认
### ⛔ 审查失败条件
如果以下任一项为真，审查必须标记为❌不通过：
**功能性问题：**
- 存在navigate()指向不存在或错误的路径
- 用户点击后无法到达预期页面
- 状态更新不完整导致UI不一致
- 关键用户流程无法完成
**安全性问题（Web3 AI 系统）：**
- 私钥/助记词出现在日志、错误消息、前端代码、Git 历史中
- 私钥明文存储（环境变量/配置文件/数据库）
- 交易缺少签名验证、nonce、或金额限制
- 存在无限授权（`approve(spender, type(uint256).max)`）
- 用户输入直接拼接到 AI prompt（prompt injection 风险）
- AI 可以自主决定大额交易（无用户确认）
- 缺少紧急暂停机制
- 单一预言机数据源（可被操纵）
- 大额交易无多重签名或延迟执行
**记住：代码编译通过 ≠ 功能正确工作 ≠ 资金安全**
## 技术验证方法（MANDATORY）
### 🔍 导航路径验证脚本
执行以下检查来验证导航逻辑：
```bash
# 1. 找出所有navigate()调用
grep -r "navigate(" frontend/src --include="*.tsx" --include="*.ts" -n
# 2. 找出所有路由定义
grep -r "path=" frontend/src --include="*.tsx" --include="*.ts" -n
# 3. 检查URL参数处理
grep -r "useSearchParams\|URLSearchParams" frontend/src --include="*.tsx" --include="*.ts" -n
```
### 🔍 状态管理验证
```bash
# 检查状态更新逻辑
grep -r "useState\|useEffect.*navigate" frontend/src --include="*.tsx" --include="*.ts" -n
# 检查onClick处理器
grep -r "onClick.*=>" frontend/src --include="*.tsx" --include="*.ts" -n
```
### 🚨 必须回答的验证问题
对于每个用户交互，审查者必须回答：
1. **点击发生什么？**
- onClick处理器具体做了什么操作？
- 调用了哪些函数？传递了什么参数？
2. **导航去哪里？**
- navigate()的目标路径是什么？
- 这个路径在路由配置中存在吗？
- 路径参数格式正确吗？
3. **目标页面做什么？**
- 目标页面/组件如何处理URL参数？
- 是否正确提取和使用参数？
- 用户最终看到什么内容？
4. **状态是否一致？**
- 点击后应用状态如何变化？
- UI是否正确反映状态变化？
- 有没有状态不同步问题？
**如果审查者无法回答这些问题，审查必须标记为❌不通过**
## 快速验证提示
- 端点集中来源：前端禁止硬编码 URL；新增/变更端点已同步到常量/SDK。
- 认证一致：跨域/跨端口请求按需携带凭证（Cookie/Token），不依赖未声明的自定义头。
- 异步降级：在不支持事件/流式或网络异常时具备降级路径与用户提示。
- 可见性扫描：关键入口在默认态与目标设备上可见；空/错误/加载可复现且可恢复。
- 自动化检查：加入简单脚本/CI 规则检查硬编码端点、路径格式、必需认证头/凭证的使用一致性。

1
.env.example
View File

@@ -26,3 +26,4 @@ NOFX_FRONTEND_PORT=3000
# Timezone Setting
# System timezone for container time synchronization
NOFX_TIMEZONE=Asia/Shanghai

140
.github/workflows/docker-build.yml vendored
View File

@@ -15,81 +15,167 @@ on:
env:
REGISTRY_GHCR: ghcr.io
IMAGE_NAME_BACKEND: ${{ github.repository }}/nofx-backend
IMAGE_NAME_FRONTEND: ${{ github.repository }}/nofx-frontend
jobs:
build-and-push:
prepare:
name: Prepare repository metadata
runs-on: ubuntu-22.04
outputs:
image_base: ${{ steps.lowercase.outputs.image_base }}
steps:
- name: Convert repository name to lowercase
id: lowercase
run: |
REPO_LOWER=$(echo "${{ github.repository }}" | tr '[:upper:]' '[:lower:]')
echo "image_base=${REPO_LOWER}" >> $GITHUB_OUTPUT
echo "Lowercase repository: ${REPO_LOWER}"
build-and-push:
name: Build ${{ matrix.name }} (${{ matrix.arch_tag }})
needs: prepare
runs-on: ${{ matrix.runner }}
permissions:
contents: read
packages: write
strategy:
fail-fast: false
matrix:
include:
- name: backend
dockerfile: ./docker/Dockerfile.backend
image_suffix: backend
platform: linux/amd64
arch_tag: amd64
runner: ubuntu-22.04
- name: backend
dockerfile: ./docker/Dockerfile.backend
image_suffix: backend
platform: linux/arm64
arch_tag: arm64
runner: ubuntu-22.04-arm
- name: frontend
dockerfile: ./docker/Dockerfile.frontend
image_suffix: frontend
platform: linux/amd64
arch_tag: amd64
runner: ubuntu-22.04
- name: frontend
dockerfile: ./docker/Dockerfile.frontend
image_suffix: frontend
platform: linux/arm64
arch_tag: arm64
runner: ubuntu-22.04-arm
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Set up QEMU
uses: docker/setup-qemu-action@v3
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Log in to GitHub Container Registry
uses: docker/login-action@v3
with:
registry: ${{ env.REGISTRY_GHCR }}
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: Log in to Docker Hub
uses: docker/login-action@v3
with:
username: ${{ secrets.DOCKERHUB_USERNAME }}
password: ${{ secrets.DOCKERHUB_TOKEN }}
continue-on-error: true
- name: Extract metadata
id: meta
uses: docker/metadata-action@v5
with:
images: |
${{ env.REGISTRY_GHCR }}/${{ github.repository }}/nofx-${{ matrix.image_suffix }}
${{ env.REGISTRY_GHCR }}/${{ needs.prepare.outputs.image_base }}/nofx-${{ matrix.image_suffix }}
${{ secrets.DOCKERHUB_USERNAME && format('{0}/nofx-{1}', secrets.DOCKERHUB_USERNAME, matrix.image_suffix) || '' }}
tags: |
type=ref,event=branch
type=ref,event=pr
type=semver,pattern={{version}}
type=semver,pattern={{major}}.{{minor}}
type=semver,pattern={{major}}
type=sha,prefix={{branch}}
type=raw,value=latest,enable={{is_default_branch}}
- name: Build and push ${{ matrix.name }} image
type=ref,event=branch,suffix=-${{ matrix.arch_tag }}
type=semver,pattern={{version}},suffix=-${{ matrix.arch_tag }}
type=semver,pattern={{major}}.{{minor}},suffix=-${{ matrix.arch_tag }}
type=semver,pattern={{major}},suffix=-${{ matrix.arch_tag }}
type=sha,prefix={{branch}}-,suffix=-${{ matrix.arch_tag }}
- name: Build and push ${{ matrix.name }}-${{ matrix.arch_tag }} image
uses: docker/build-push-action@v5
with:
context: .
file: ${{ matrix.dockerfile }}
platforms: linux/amd64,linux/arm64
platforms: ${{ matrix.platform }}
push: ${{ github.event_name != 'pull_request' }}
tags: ${{ steps.meta.outputs.tags }}
labels: ${{ steps.meta.outputs.labels }}
cache-from: type=gha
cache-to: type=gha,mode=max
cache-from: type=gha,scope=${{ matrix.name }}-${{ matrix.arch_tag }}
cache-to: type=gha,mode=max,scope=${{ matrix.name }}-${{ matrix.arch_tag }}
build-args: |
BUILD_DATE=${{ github.event.head_commit.timestamp }}
VCS_REF=${{ github.sha }}
VERSION=${{ github.ref_name }}
- name: Image digest
run: echo "Image digest for ${{ matrix.name }} - ${{ steps.meta.outputs.digest }}"
run: |
echo "✅ Built: ${{ matrix.name }}-${{ matrix.arch_tag }}"
echo "Platform: ${{ matrix.platform }}"
echo "Tags: ${{ steps.meta.outputs.tags }}"
create-manifest:
name: Create multi-arch manifests
if: github.event_name != 'pull_request'
needs: [prepare, build-and-push]
runs-on: ubuntu-22.04
permissions:
contents: read
packages: write
strategy:
matrix:
image_suffix: [backend, frontend]
steps:
- name: Log in to GitHub Container Registry
uses: docker/login-action@v3
with:
registry: ${{ env.REGISTRY_GHCR }}
username: ${{ github.actor }}
password: ${{ secrets.GITHUB_TOKEN }}
- name: Log in to Docker Hub
uses: docker/login-action@v3
with:
username: ${{ secrets.DOCKERHUB_USERNAME }}
password: ${{ secrets.DOCKERHUB_TOKEN }}
continue-on-error: true
- name: Create and push multi-arch manifest
env:
IMAGE_BASE: ${{ needs.prepare.outputs.image_base }}
run: |
REF_NAME="${{ github.ref_name }}"
GHCR_IMAGE="${{ env.REGISTRY_GHCR }}/${IMAGE_BASE}/nofx-${{ matrix.image_suffix }}"
echo "📦 Creating manifest for ${{ matrix.image_suffix }}"
echo "Repository: ${IMAGE_BASE}"
echo "Image: ${GHCR_IMAGE}"
docker buildx imagetools create -t "${GHCR_IMAGE}:${REF_NAME}" \
"${GHCR_IMAGE}:${REF_NAME}-amd64" \
"${GHCR_IMAGE}:${REF_NAME}-arm64"
if [[ "${{ github.ref }}" == "refs/heads/main" ]] || [[ "${{ github.ref }}" == "refs/heads/dev" ]]; then
docker buildx imagetools create -t "${GHCR_IMAGE}:latest" \
"${GHCR_IMAGE}:${REF_NAME}-amd64" \
"${GHCR_IMAGE}:${REF_NAME}-arm64"
echo "✅ Created latest tag"
fi
if [[ -n "${{ secrets.DOCKERHUB_USERNAME }}" ]]; then
DOCKERHUB_IMAGE="${{ secrets.DOCKERHUB_USERNAME }}/nofx-${{ matrix.image_suffix }}"
docker buildx imagetools create -t "${DOCKERHUB_IMAGE}:${REF_NAME}" \
"${DOCKERHUB_IMAGE}:${REF_NAME}-amd64" \
"${DOCKERHUB_IMAGE}:${REF_NAME}-arm64" || true
echo "✅ Created Docker Hub manifest"
fi
echo "🎉 Multi-arch manifest created successfully!"

246
.github/workflows/pr-docker-check.yml vendored Normal file
View File

@@ -0,0 +1,246 @@
name: PR Docker Build Check
# PR 时只做轻量级构建检查,不推送镜像
# 策略: 快速验证 amd64 + 抽样检查 arm64 (backend only)
on:
pull_request:
branches:
- main
- dev
paths:
- 'docker/**'
- 'Dockerfile*'
- 'go.mod'
- 'go.sum'
- '**.go'
- 'web/**'
- '.github/workflows/docker-build.yml'
- '.github/workflows/pr-docker-check.yml'
jobs:
# 快速检查: 所有镜像的 amd64 版本
docker-build-amd64:
name: Build Check (amd64)
runs-on: ubuntu-22.04
permissions:
contents: read
strategy:
fail-fast: false
matrix:
include:
- name: backend
dockerfile: ./docker/Dockerfile.backend
test_run: true # 需要测试运行
- name: frontend
dockerfile: ./docker/Dockerfile.frontend
test_run: true
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Build ${{ matrix.name }} image (amd64)
id: build
uses: docker/build-push-action@v5
with:
context: .
file: ${{ matrix.dockerfile }}
platforms: linux/amd64
push: false
load: true # 加载到本地 Docker,用于测试运行
tags: nofx-${{ matrix.name }}:pr-test
cache-from: type=gha,scope=${{ matrix.name }}-amd64
cache-to: type=gha,mode=max,scope=${{ matrix.name }}-amd64
build-args: |
BUILD_DATE=${{ github.event.pull_request.updated_at }}
VCS_REF=${{ github.event.pull_request.head.sha }}
VERSION=pr-${{ github.event.pull_request.number }}
- name: Test run container (smoke test)
if: matrix.test_run
timeout-minutes: 2
run: |
echo "🧪 Testing container startup..."
# 启动容器
docker run -d --name test-${{ matrix.name }} \
--health-cmd="exit 0" \
nofx-${{ matrix.name }}:pr-test
# 等待容器启动 (最多 30 秒)
for i in {1..30}; do
if docker ps | grep -q test-${{ matrix.name }}; then
echo "✅ Container started successfully"
docker logs test-${{ matrix.name }}
docker stop test-${{ matrix.name }} || true
exit 0
fi
sleep 1
done
echo "❌ Container failed to start"
docker logs test-${{ matrix.name }} || true
exit 1
- name: Check image size
run: |
SIZE=$(docker image inspect nofx-${{ matrix.name }}:pr-test --format='{{.Size}}')
SIZE_MB=$((SIZE / 1024 / 1024))
echo "📦 Image size: ${SIZE_MB} MB"
# 警告阈值
if [ "${{ matrix.name }}" = "backend" ] && [ $SIZE_MB -gt 500 ]; then
echo "⚠️ Warning: Backend image is larger than 500MB"
elif [ "${{ matrix.name }}" = "frontend" ] && [ $SIZE_MB -gt 200 ]; then
echo "⚠️ Warning: Frontend image is larger than 200MB"
else
echo "✅ Image size is reasonable"
fi
# ARM64 原生构建检查: 使用 GitHub 原生 ARM64 runner (快速!)
docker-build-arm64-native:
name: Build Check (arm64 native - backend)
runs-on: ubuntu-22.04-arm # 原生 ARM64 runner
permissions:
contents: read
steps:
- name: Checkout code
uses: actions/checkout@v4
# 原生 ARM64 不需要 QEMU,直接构建
- name: Set up Docker Buildx
uses: docker/setup-buildx-action@v3
- name: Build backend image (arm64 native)
uses: docker/build-push-action@v5
timeout-minutes: 15 # 原生构建更快!
with:
context: .
file: ./docker/Dockerfile.backend
platforms: linux/arm64
push: false
load: true # 加载到本地,用于测试
tags: nofx-backend:pr-test-arm64
cache-from: type=gha,scope=backend-arm64
cache-to: type=gha,mode=max,scope=backend-arm64
build-args: |
BUILD_DATE=${{ github.event.pull_request.updated_at }}
VCS_REF=${{ github.event.pull_request.head.sha }}
VERSION=pr-${{ github.event.pull_request.number }}
- name: Test run ARM64 container
timeout-minutes: 2
run: |
echo "🧪 Testing ARM64 container startup..."
# 启动容器
docker run -d --name test-backend-arm64 \
--health-cmd="exit 0" \
nofx-backend:pr-test-arm64
# 等待启动
for i in {1..30}; do
if docker ps | grep -q test-backend-arm64; then
echo "✅ ARM64 container started successfully"
docker logs test-backend-arm64
docker stop test-backend-arm64 || true
exit 0
fi
sleep 1
done
echo "❌ ARM64 container failed to start"
docker logs test-backend-arm64 || true
exit 1
- name: ARM64 build summary
run: |
echo "✅ Backend ARM64 native build successful!"
echo "Using GitHub native ARM64 runner - no QEMU needed!"
echo "Build time is ~3x faster than emulation"
# 汇总检查结果
check-summary:
name: Docker Build Summary
needs: [docker-build-amd64, docker-build-arm64-native]
runs-on: ubuntu-22.04
if: always()
permissions:
pull-requests: write # 用于发布评论
steps:
- name: Check build results
id: check
run: |
echo "## 🐳 Docker Build Check Results" >> $GITHUB_STEP_SUMMARY
echo "" >> $GITHUB_STEP_SUMMARY
# 检查 amd64 构建
if [[ "${{ needs.docker-build-amd64.result }}" == "success" ]]; then
echo "✅ **AMD64 builds**: All passed" >> $GITHUB_STEP_SUMMARY
AMD64_OK=true
else
echo "❌ **AMD64 builds**: Failed" >> $GITHUB_STEP_SUMMARY
AMD64_OK=false
fi
# 检查 arm64 构建
if [[ "${{ needs.docker-build-arm64-native.result }}" == "success" ]]; then
echo "✅ **ARM64 build** (native): Backend passed (frontend will be verified after merge)" >> $GITHUB_STEP_SUMMARY
ARM64_OK=true
else
echo "❌ **ARM64 build** (native): Backend failed" >> $GITHUB_STEP_SUMMARY
ARM64_OK=false
fi
echo "" >> $GITHUB_STEP_SUMMARY
if [ "$AMD64_OK" = true ] && [ "$ARM64_OK" = true ]; then
echo "### 🎉 All checks passed!" >> $GITHUB_STEP_SUMMARY
echo "" >> $GITHUB_STEP_SUMMARY
echo "After merge:" >> $GITHUB_STEP_SUMMARY
echo "- Full multi-arch builds (amd64 + arm64) will run in parallel" >> $GITHUB_STEP_SUMMARY
echo "- Estimated time: 15-20 minutes" >> $GITHUB_STEP_SUMMARY
exit 0
else
echo "### ❌ Build checks failed" >> $GITHUB_STEP_SUMMARY
echo "" >> $GITHUB_STEP_SUMMARY
echo "Please check the build logs above and fix the errors." >> $GITHUB_STEP_SUMMARY
exit 1
fi
- name: Comment on PR
if: always() && github.event.pull_request.head.repo.full_name == github.repository
uses: actions/github-script@v7
with:
script: |
const amd64Status = '${{ needs.docker-build-amd64.result }}';
const arm64Status = '${{ needs.docker-build-arm64-native.result }}';
const successIcon = '✅';
const failIcon = '❌';
const comment = [
'## 🐳 Docker Build Check Results',
'',
`**AMD64 builds**: ${amd64Status === 'success' ? successIcon : failIcon} ${amd64Status}`,
`**ARM64 build** (native runner): ${arm64Status === 'success' ? successIcon : failIcon} ${arm64Status}`,
'',
amd64Status === 'success' && arm64Status === 'success'
? '### 🎉 All Docker builds passed!\n\n✨ Using GitHub native ARM64 runners - 3x faster than emulation!\n\nAfter merge, full multi-arch builds will run in ~10-12 minutes.'
: '### ⚠️ Some builds failed\n\nPlease check the Actions tab for details.',
'',
'<sub>Checked: Backend (amd64 + arm64 native), Frontend (amd64) | Powered by GitHub ARM64 Runners</sub>'
].join('\n');
await github.rest.issues.createComment({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: context.payload.pull_request.number,
body: comment
});

84
.github/workflows/pr-go-test-coverage.yml vendored Normal file
View File

@@ -0,0 +1,84 @@
name: Go Test Coverage
on:
pull_request:
types: [opened, synchronize, reopened]
branches:
- dev
- main
push:
branches:
- dev
- main
permissions:
contents: read
pull-requests: write
jobs:
test-coverage:
name: Go Unit Tests & Coverage
runs-on: ubuntu-latest
permissions:
contents: read
pull-requests: write
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Set up Go
uses: actions/setup-go@v5
with:
go-version: '1.25'
- name: Set up Python
uses: actions/setup-python@v5
with:
python-version: '3.11'
- name: Install Python dependencies
run: |
python -m pip install --upgrade pip
pip install -r .github/workflows/scripts/requirements.txt
- name: Cache Go modules
uses: actions/cache@v4
with:
path: ~/go/pkg/mod
key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
restore-keys: |
${{ runner.os }}-go-
- name: Download dependencies
run: go mod download
- name: Verify Go coverage tool
run: |
go tool cover -h || echo "Warning: go tool cover not available"
- name: Run tests with coverage
env:
DATA_ENCRYPTION_KEY: "test-encryption-key-for-ci-only-not-production"
run: |
go test -v -race -coverprofile=coverage.out -covermode=atomic ./...
- name: Calculate coverage and generate report
id: coverage
run: |
chmod +x .github/workflows/scripts/calculate_coverage.py
python .github/workflows/scripts/calculate_coverage.py coverage.out coverage_report.md
- name: Comment PR with coverage
if: github.event_name == 'pull_request'
continue-on-error: true
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
run: |
chmod +x .github/workflows/scripts/comment_pr.py
python .github/workflows/scripts/comment_pr.py \
${{ github.event.pull_request.number }} \
"${{ steps.coverage.outputs.coverage }}" \
"${{ steps.coverage.outputs.emoji }}" \
"${{ steps.coverage.outputs.status }}" \
"${{ steps.coverage.outputs.badge_color }}" \
coverage_report.md

192
.github/workflows/scripts/calculate_coverage.py vendored Executable file
View File

@@ -0,0 +1,192 @@
#!/usr/bin/env python3
"""
Calculate Go test coverage and generate reports.
This script parses the coverage.out file generated by `go test -coverprofile`,
extracts coverage statistics, and generates formatted reports.
"""
import sys
import re
import os
from typing import Dict, List, Tuple
def parse_coverage_file(coverage_file: str) -> Tuple[float, Dict[str, float]]:
"""
Parse coverage output file and extract coverage data.
Args:
coverage_file: Path to coverage.out file
Returns:
Tuple of (total_coverage, package_coverage_dict)
"""
if not os.path.exists(coverage_file):
print(f"Error: Coverage file {coverage_file} not found", file=sys.stderr)
sys.exit(1)
# Run go tool cover to get coverage data
import subprocess
try:
result = subprocess.run(
['go', 'tool', 'cover', '-func', coverage_file],
capture_output=True,
text=True,
check=True
)
except subprocess.CalledProcessError as e:
print(f"Error running go tool cover: {e}", file=sys.stderr)
sys.exit(1)
lines = result.stdout.strip().split('\n')
package_coverage = {}
total_coverage = 0.0
for line in lines:
# Skip empty lines
if not line.strip():
continue
# Check for total coverage line
if line.startswith('total:'):
# Extract percentage from "total: (statements) XX.X%"
match = re.search(r'(\d+\.\d+)%', line)
if match:
total_coverage = float(match.group(1))
continue
# Parse package/file coverage
# Format: "package/file.go:function statements coverage%"
parts = line.split()
if len(parts) >= 3:
file_path = parts[0]
coverage_str = parts[-1]
# Extract package name from file path
package = file_path.split(':')[0]
package_name = '/'.join(package.split('/')[:-1]) if '/' in package else package
# Extract coverage percentage
match = re.search(r'(\d+\.\d+)%', coverage_str)
if match:
coverage_pct = float(match.group(1))
# Aggregate by package
if package_name not in package_coverage:
package_coverage[package_name] = []
package_coverage[package_name].append(coverage_pct)
# Calculate average coverage per package
package_avg = {
pkg: sum(coverages) / len(coverages)
for pkg, coverages in package_coverage.items()
}
return total_coverage, package_avg
def get_coverage_status(coverage: float) -> Tuple[str, str, str]:
"""
Get coverage status based on percentage.
Args:
coverage: Coverage percentage
Returns:
Tuple of (emoji, status_text, badge_color)
"""
if coverage >= 80:
return '🟢', 'excellent', 'brightgreen'
elif coverage >= 60:
return '🟡', 'good', 'yellow'
elif coverage >= 40:
return '🟠', 'fair', 'orange'
else:
return '🔴', 'needs improvement', 'red'
def generate_coverage_report(coverage_file: str, output_file: str) -> None:
"""
Generate a detailed coverage report in markdown format.
Args:
coverage_file: Path to coverage.out file
output_file: Path to output markdown file
"""
import subprocess
try:
result = subprocess.run(
['go', 'tool', 'cover', '-func', coverage_file],
capture_output=True,
text=True,
check=True
)
except subprocess.CalledProcessError as e:
print(f"Error generating coverage report: {e}", file=sys.stderr)
sys.exit(1)
with open(output_file, 'w') as f:
f.write("## Coverage by Package\n\n")
f.write("```\n")
f.write(result.stdout)
f.write("```\n")
def set_github_output(name: str, value: str) -> None:
"""
Set GitHub Actions output variable.
Args:
name: Output variable name
value: Output variable value
"""
github_output = os.environ.get('GITHUB_OUTPUT')
if github_output:
with open(github_output, 'a') as f:
f.write(f"{name}={value}\n")
else:
print(f"::set-output name={name}::{value}")
def main():
"""Main entry point."""
if len(sys.argv) < 2:
print("Usage: calculate_coverage.py <coverage_file> [output_file]", file=sys.stderr)
sys.exit(1)
coverage_file = sys.argv[1]
output_file = sys.argv[2] if len(sys.argv) > 2 else 'coverage_report.md'
# Parse coverage data
total_coverage, package_coverage = parse_coverage_file(coverage_file)
# Get coverage status
emoji, status, badge_color = get_coverage_status(total_coverage)
# Generate detailed report
generate_coverage_report(coverage_file, output_file)
# Output results
print(f"Total Coverage: {total_coverage}%")
print(f"Status: {status}")
print(f"Badge Color: {badge_color}")
# Set GitHub Actions outputs
set_github_output('coverage', f'{total_coverage}%')
set_github_output('coverage_num', str(total_coverage))
set_github_output('status', status)
set_github_output('emoji', emoji)
set_github_output('badge_color', badge_color)
# Print package breakdown
if package_coverage:
print("\nCoverage by Package:")
for package, coverage in sorted(package_coverage.items()):
print(f" {package}: {coverage:.1f}%")
if __name__ == '__main__':
main()

246
.github/workflows/scripts/comment_pr.py vendored Executable file
View File

@@ -0,0 +1,246 @@
#!/usr/bin/env python3
"""
Post or update coverage report comment on GitHub Pull Request.
This script generates a formatted coverage report comment and posts it to a PR,
or updates an existing coverage comment if one already exists.
"""
import os
import sys
import json
import requests
from typing import Optional
def read_file(file_path: str) -> str:
"""Read file content."""
try:
with open(file_path, 'r') as f:
return f.read()
except FileNotFoundError:
print(f"Warning: File {file_path} not found", file=sys.stderr)
return ""
def generate_comment_body(coverage: str, emoji: str, status: str,
badge_color: str, coverage_report_path: str) -> str:
"""
Generate the PR comment body.
Args:
coverage: Coverage percentage (e.g., "75.5%")
emoji: Status emoji
status: Status text
badge_color: Badge color
coverage_report_path: Path to detailed coverage report
Returns:
Formatted comment body in markdown
"""
coverage_report = read_file(coverage_report_path)
# URL encode the coverage percentage for the badge
coverage_encoded = coverage.replace('%', '%25')
comment = f"""## {emoji} Go Test Coverage Report
**Total Coverage:** `{coverage}` ({status})
![Coverage](https://img.shields.io/badge/coverage-{coverage_encoded}-{badge_color})
<details>
<summary>📊 Detailed Coverage Report (click to expand)</summary>
{coverage_report}
</details>
### Coverage Guidelines
- 🟢 >= 80%: Excellent
- 🟡 >= 60%: Good
- 🟠 >= 40%: Fair
- 🔴 < 40%: Needs improvement
---
*This is an automated coverage report. The coverage requirement is advisory and does not block PR merging.*
"""
return comment
def find_existing_comment(token: str, repo: str, pr_number: int) -> Optional[int]:
"""
Find existing coverage comment in the PR.
Args:
token: GitHub token
repo: Repository in format "owner/repo"
pr_number: Pull request number
Returns:
Comment ID if found, None otherwise
"""
url = f"https://api.github.com/repos/{repo}/issues/{pr_number}/comments"
headers = {
'Authorization': f'token {token}',
'Accept': 'application/vnd.github.v3+json'
}
try:
response = requests.get(url, headers=headers)
response.raise_for_status()
comments = response.json()
# Look for existing coverage comment
for comment in comments:
if (comment.get('user', {}).get('type') == 'Bot' and
'Go Test Coverage Report' in comment.get('body', '')):
return comment['id']
except requests.exceptions.RequestException as e:
print(f"Error fetching comments: {e}", file=sys.stderr)
return None
def post_comment(token: str, repo: str, pr_number: int, body: str) -> bool:
"""
Post a new comment to the PR.
Args:
token: GitHub token
repo: Repository in format "owner/repo"
pr_number: Pull request number
body: Comment body
Returns:
True if successful, False otherwise
"""
url = f"https://api.github.com/repos/{repo}/issues/{pr_number}/comments"
headers = {
'Authorization': f'token {token}',
'Accept': 'application/vnd.github.v3+json'
}
data = {'body': body}
try:
response = requests.post(url, headers=headers, json=data)
response.raise_for_status()
print("✅ Coverage comment posted successfully")
return True
except requests.exceptions.RequestException as e:
print(f"Error posting comment: {e}", file=sys.stderr)
if hasattr(e, 'response') and e.response is not None:
print(f"Response: {e.response.text}", file=sys.stderr)
return False
def update_comment(token: str, repo: str, comment_id: int, body: str) -> bool:
"""
Update an existing comment.
Args:
token: GitHub token
repo: Repository in format "owner/repo"
comment_id: Comment ID to update
body: New comment body
Returns:
True if successful, False otherwise
"""
url = f"https://api.github.com/repos/{repo}/issues/comments/{comment_id}"
headers = {
'Authorization': f'token {token}',
'Accept': 'application/vnd.github.v3+json'
}
data = {'body': body}
try:
response = requests.patch(url, headers=headers, json=data)
response.raise_for_status()
print("✅ Coverage comment updated successfully")
return True
except requests.exceptions.RequestException as e:
print(f"Error updating comment: {e}", file=sys.stderr)
if hasattr(e, 'response') and e.response is not None:
print(f"Response: {e.response.text}", file=sys.stderr)
return False
def is_fork_pr(event_path: str) -> bool:
"""
Check if the PR is from a fork.
Args:
event_path: Path to GitHub event JSON file
Returns:
True if fork PR, False otherwise
"""
try:
with open(event_path, 'r') as f:
event = json.load(f)
pr = event.get('pull_request', {})
head_repo = pr.get('head', {}).get('repo', {}).get('full_name')
base_repo = pr.get('base', {}).get('repo', {}).get('full_name')
return head_repo != base_repo
except (FileNotFoundError, json.JSONDecodeError, KeyError) as e:
print(f"Warning: Could not determine if fork PR: {e}", file=sys.stderr)
return False
def main():
"""Main entry point."""
# Get environment variables
token = os.environ.get('GITHUB_TOKEN')
repo = os.environ.get('GITHUB_REPOSITORY')
event_path = os.environ.get('GITHUB_EVENT_PATH', '')
# Get arguments
if len(sys.argv) < 6:
print("Usage: comment_pr.py <pr_number> <coverage> <emoji> <status> <badge_color> [coverage_report_path]",
file=sys.stderr)
sys.exit(1)
pr_number = int(sys.argv[1])
coverage = sys.argv[2]
emoji = sys.argv[3]
status = sys.argv[4]
badge_color = sys.argv[5]
coverage_report_path = sys.argv[6] if len(sys.argv) > 6 else 'coverage_report.md'
# Validate environment
if not token:
print("Error: GITHUB_TOKEN environment variable not set", file=sys.stderr)
sys.exit(1)
if not repo:
print("Error: GITHUB_REPOSITORY environment variable not set", file=sys.stderr)
sys.exit(1)
# Check if fork PR
if event_path and is_fork_pr(event_path):
print("ℹ️ Fork PR detected - skipping comment (no write permissions)")
sys.exit(0)
# Generate comment body
comment_body = generate_comment_body(coverage, emoji, status, badge_color, coverage_report_path)
# Check for existing comment
existing_comment_id = find_existing_comment(token, repo, pr_number)
# Post or update comment
if existing_comment_id:
print(f"Found existing comment (ID: {existing_comment_id}), updating...")
success = update_comment(token, repo, existing_comment_id, comment_body)
else:
print("No existing comment found, creating new one...")
success = post_comment(token, repo, pr_number, comment_body)
sys.exit(0 if success else 1)
if __name__ == '__main__':
main()

2
.github/workflows/scripts/requirements.txt vendored Normal file
View File

@@ -0,0 +1,2 @@
# Python dependencies for GitHub Actions scripts
requests>=2.31.0

80
.gitignore vendored
View File

@@ -5,6 +5,7 @@
# AI 工具
.claude/
CLAUDE.md
# 编译产物
nofx-auto
@@ -29,7 +30,9 @@ Thumbs.db
# 环境变量
.env
config.json
config.db
config.db*
nofx.db
configbak.json
# 生产配置
nginx/
@@ -54,3 +57,78 @@ web/.vite/
# ESLint 临时报告文件（调试时生成，不纳入版本控制）
eslint-*.json
# VS code
.vscode
# 密钥和敏感文件
# 注意：crypto目录包含加密服务代码，应该被提交
# 只忽略密钥文件本身
secrets/
*.key
*.pem
*.p12
*.pfx
rsa_key*
# 加密相关
DATA_ENCRYPTION_KEY=*
*.enc
# Python
__pycache__/
*.py[cod]
*$py.class
*.so
.Python
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
wheels/
pip-wheel-metadata/
share/python-wheels/
*.egg-info/
.installed.cfg
*.egg
MANIFEST
# Python 虚拟环境
.venv/
venv/
ENV/
env/
.env/
# uv
.uv/
uv.lock
# Pytest
.pytest_cache/
.coverage
htmlcov/
*.cover
.hypothesis/
# Jupyter Notebook
.ipynb_checkpoints
*.ipynb
# pyenv
.python-version
# mypy
.mypy_cache/
.dmypy.json
dmypy.json
# Pyre type checker
.pyre/

136
ENCRYPTION_README.md Normal file
View File

@@ -0,0 +1,136 @@
# 🔐 End-to-End Encryption System
## Quick Start (5 Minutes)
```bash
# 1. Deploy encryption system
./deploy_encryption.sh
# 2. Restart application
go run main.go
```
## What's Changed?
### New Files
- `crypto/` - Core encryption modules
- `api/crypto_handler.go` - Encryption API endpoints
- `web/src/lib/crypto.ts` - Frontend encryption module
- `scripts/migrate_encryption.go` - Data migration tool
- `deploy_encryption.sh` - One-click deployment script
### Modified Files
None (backward compatible, no breaking changes)
## Architecture
```
┌─────────────────────────────────────────────────────────┐
│ Three-Layer Security │
├─────────────────────────────────────────────────────────┤
│ Frontend: Two-stage input + clipboard obfuscation │
│ Transport: RSA-4096 + AES-256-GCM encryption │
│ Storage: Database encryption + audit logs │
└─────────────────────────────────────────────────────────┘
```
## Integration
### 1. Initialize Encryption Manager (main.go)
```go
import "nofx/crypto"
func main() {
// Initialize secure storage
secureStorage, err := crypto.NewSecureStorage(db.GetDB())
if err != nil {
log.Fatalf("Encryption init failed: %v", err)
}
// Migrate existing data (optional, one-time)
secureStorage.MigrateToEncrypted()
// Register API routes
cryptoHandler, _ := api.NewCryptoHandler(secureStorage)
http.HandleFunc("/api/crypto/public-key", cryptoHandler.HandleGetPublicKey)
// ... rest of your code
}
```
### 2. Frontend Integration
```typescript
import { twoStagePrivateKeyInput, fetchServerPublicKey } from '../lib/crypto';
// When saving exchange config
const serverPublicKey = await fetchServerPublicKey();
const { encryptedKey } = await twoStagePrivateKeyInput(serverPublicKey);
// Send encrypted data to backend
await api.post('/api/exchange/config', {
encrypted_key: encryptedKey,
});
```
## Features
- ✅ **Zero Breaking Changes**: Backward compatible with existing data
- ✅ **Automatic Migration**: Old data automatically encrypted on first access
- ✅ **Audit Logs**: Complete tracking of all key operations
- ✅ **Key Rotation**: Built-in mechanism for periodic key updates
- ✅ **Performance**: <25ms overhead per operation
## Security Improvements
| Before | After | Improvement |
|--------|-------|-------------|
| Plaintext in DB | AES-256 encrypted | ∞ |
| Clipboard sniffing | Obfuscated | 90%+ |
| Browser extension theft | End-to-end encrypted | 99% |
| Server breach | Requires key theft | 80% |
## Testing
```bash
# Run encryption tests
go test ./crypto -v
# Expected output:
# ✅ RSA key pair generation
# ✅ AES encryption/decryption
# ✅ Hybrid encryption
```
## Cost
- **Development**: 0 (implemented)
- **Runtime**: <0.1ms per operation
- **Storage**: +30% (encrypted data size)
- **Maintenance**: Minimal (automated)
## Rollback
If needed, rollback is simple:
```bash
# Restore backup
cp config.db.backup config.db
# Comment out 3 lines in main.go
# (encryption initialization)
# Restart
go run main.go
```
## Support
- **Documentation**: See inline code comments
- **Issues**: Report via GitHub issues
- **Questions**: Check `crypto/encryption_test.go` for examples
---
**No configuration required. Just deploy and it works.**

144
README.md
View File

@@ -6,11 +6,11 @@
[![License](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](LICENSE)
[![Backed by Amber.ac](https://img.shields.io/badge/Backed%20by-Amber.ac-orange.svg)](https://amber.ac)
**Languages:** [English](README.md) | [中文](docs/i18n/zh-CN/README.md) | [Українська](docs/i18n/uk/README.md) | [Русский](docs/i18n/ru/README.md)
**Languages:** [English](README.md) | [中文](docs/i18n/zh-CN/README.md) | [Українська](docs/i18n/uk/README.md) | [Русский](docs/i18n/ru/README.md) | [日本語](docs/i18n/ja/README.md)
**Official Twitter:** [@nofx_ai](https://x.com/nofx_ai)
**📚 Documentation:** [Docs Home](docs/README.md) | [Getting Started](docs/getting-started/README.md) | [Changelog](CHANGELOG.md) | [Contributing](CONTRIBUTING.md) | [Security](SECURITY.md)
**📚 Documentation:** [Docs Home](docs/README.md) | [Getting Started](docs/getting-started/README.md) | [Prompt Writing Guide](docs/prompt-guide.md) ([中文](docs/prompt-guide.zh-CN.md)) | [Changelog](CHANGELOG.md) | [Contributing](CONTRIBUTING.md) | [Security](SECURITY.md)
---
@@ -24,11 +24,14 @@
- [🔮 Roadmap](#-roadmap---universal-market-expansion)
- [🏗️ Technical Architecture](#️-technical-architecture)
- [💰 Register Binance Account](#-register-binance-account-save-on-fees)
- [🔷 Register Hyperliquid Account](#-using-hyperliquid-exchange)
- [🔶 Register Aster DEX Account](#-using-aster-dex-exchange)
- [🚀 Quick Start](#-quick-start)
- [📖 AI Decision Flow](#-ai-decision-flow)
- [🧠 AI Self-Learning](#-ai-self-learning-example)
- [📊 Web Interface Features](#-web-interface-features)
- [🎛️ API Endpoints](#️-api-endpoints)
- [🔐 Admin Mode (Single-User)](#-admin-mode-single-user)
- [⚠️ Important Risk Warnings](#️-important-risk-warnings)
- [🛠️ Common Issues](#️-common-issues)
- [📈 Performance Tips](#-performance-optimization-tips)
@@ -242,6 +245,48 @@ NOFX is built with a modern, modular architecture:
---
## 🔐 Admin Mode (Single-User)
For self-hosted or single-tenant setups, NOFX supports a strict admin-only mode that disables public features and requires an admin password for all access.
### How it works
- All API endpoints require a valid JWT when `admin_mode=true`, except:
- `GET /api/health`
- `GET /api/config`
- `POST /api/admin-login`
- Logout invalidates the current token via an in-memory blacklist (sufficient for single instance; use Redis for multi-instance – see Notes).
### Quick setup
1) Set flags in `config.json`:
```jsonc
{
// ... other config
"admin_mode": true,
"jwt_secret": "YOUR_JWT_SCR"
}
```
2) Provide required environment variables:
- `NOFX_ADMIN_PASSWORD` — plaintext admin password (only used at startup to derive a bcrypt hash)
Docker Compose example (already wired):
```yaml
services:
nofx:
environment:
- NOFX_ADMIN_PASSWORD=${NOFX_ADMIN_PASSWORD}
```
1) Login flow (admin mode):
- Open the web UI → you’ll be redirected to the login page
- Enter admin password → the server returns a JWT
- The UI stores the token and authenticates subsequent API calls
### Notes
- Token lifetime: 24h. On logout, tokens are blacklisted in-memory until expiry. For multi-instance deployments, use a shared store (e.g., Redis) to sync the blacklist.
---
## 💰 Register Binance Account (Save on Fees!)
Before using this system, you need a Binance Futures account. **Use our referral link to save on trading fees:**
@@ -489,18 +534,93 @@ Open your browser and visit: **🌐 http://localhost:3000**
---
#### 🔷 Alternative: Using Hyperliquid Exchange
#### 🔷 Using Hyperliquid Exchange
**NOFX also supports Hyperliquid** - a decentralized perpetual futures exchange. To use Hyperliquid instead of Binance:
**NOFX supports Hyperliquid** - a high-performance decentralized perpetual futures exchange!
**Step 1**: Get your Ethereum private key (for Hyperliquid authentication)
**Why Choose Hyperliquid?**
- 🚀 **High Performance**: Lightning-fast execution on L1 blockchain
- 💰 **Low Fees**: Competitive maker/taker fees
- 🔐 **Non-Custodial**: Your keys, your coins
- 🌐 **No KYC**: Anonymous trading
- 💎 **Deep Liquidity**: Institutional-grade order book
1. Open **MetaMask** (or any Ethereum wallet)
2. Export your private key
3. **Remove the `0x` prefix** from the key
4. Fund your wallet on [Hyperliquid](https://hyperliquid.xyz)
---
**Step 2**: ~~Configure `config.json` for Hyperliquid~~ *Configure through web interface*
### 📝 Registration & Setup Guide
**Step 1: Register Hyperliquid Account**
1. **Visit Hyperliquid with Referral Link** (get benefits!):
**🎁 [Register Hyperliquid - Join AITRADING](https://app.hyperliquid.xyz/join/AITRADING)**
2. **Connect Your Wallet**:
- Click "Connect Wallet" on the top right
- Choose MetaMask, WalletConnect, or other Web3 wallets
- Approve the connection
3. **Enable Trading**:
- First connection will prompt you to sign a message
- This authorizes your wallet for trading (no gas fees)
- You'll see your wallet address displayed
**Step 2: Fund Your Wallet**
1. **Bridge Assets to Arbitrum**:
- Hyperliquid runs on Arbitrum L2
- Bridge USDC from Ethereum mainnet or other chains
- Or directly withdraw USDC from exchanges to Arbitrum
2. **Deposit to Hyperliquid**:
- Click "Deposit" on Hyperliquid interface
- Select USDC amount to deposit
- Confirm the transaction (small gas fee on Arbitrum)
- Funds appear in your Hyperliquid account within seconds
**Step 3: Set Up Agent Wallet (Recommended)**
Hyperliquid supports **Agent Wallets** - secure sub-wallets specifically for trading automation!
⚠️ **Why Use Agent Wallet:**
- ✅ **More Secure**: Never expose your main wallet private key
- ✅ **Limited Access**: Agent only has trading permissions
- ✅ **Revocable**: Can be disabled anytime from Hyperliquid interface
- ✅ **Separate Funds**: Keep main holdings safe
**How to Create Agent Wallet:**
1. **Log in to Hyperliquid** using your main wallet
- Visit [https://app.hyperliquid.xyz](https://app.hyperliquid.xyz)
- Connect with the wallet you registered (from referral link)
2. **Navigate to Agent Settings**:
- Click on your wallet address (top right)
- Go to "Settings" → "API & Agents"
- Or visit: [https://app.hyperliquid.xyz/agents](https://app.hyperliquid.xyz/agents)
3. **Create New Agent**:
- Click "Create Agent" or "Add Agent"
- System will generate a new agent wallet automatically
- **Save the agent wallet address** (starts with `0x`)
- **Save the agent private key** (shown only once!)
4. **Agent Wallet Details**:
- Main Wallet: Your connected wallet (holds funds)
- Agent Wallet: The sub-wallet for trading (NOFX will use this)
- Private Key: Only needed for NOFX configuration
5. **Fund Your Agent** (Optional):
- Transfer USDC from main wallet to agent wallet
- Or keep funds in main wallet (agent can trade from it)
6. **Save Credentials for NOFX**:
- Main Wallet Address: `0xYourMainWalletAddress` (with `0x`)
- Agent Private Key: `YourAgentPrivateKeyWithout0x` (remove `0x` prefix)
---
~~Configure `config.json` for Hyperliquid~~ *Configure through web interface*
```json
{
@@ -533,9 +653,9 @@ Open your browser and visit: **🌐 http://localhost:3000**
---
#### 🔶 Alternative: Using Aster DEX Exchange
#### 🔶 Using Aster DEX Exchange
**NOFX also supports Aster DEX** - a Binance-compatible decentralized perpetual futures exchange!
**NOFX supports Aster DEX** - a Binance-compatible decentralized perpetual futures exchange!
**Why Choose Aster?**
- 🎯 Binance-compatible API (easy migration)

72
api/crypto_handler.go Normal file
View File

@@ -0,0 +1,72 @@
package api
import (
"log"
"net/http"
"nofx/crypto"
"github.com/gin-gonic/gin"
)
// CryptoHandler 加密 API 處理器
type CryptoHandler struct {
cryptoService *crypto.CryptoService
}
// NewCryptoHandler 創建加密處理器
func NewCryptoHandler(cryptoService *crypto.CryptoService) *CryptoHandler {
return &CryptoHandler{
cryptoService: cryptoService,
}
}
// ==================== 公鑰端點 ====================
// HandleGetPublicKey 獲取伺服器公鑰
func (h *CryptoHandler) HandleGetPublicKey(c *gin.Context) {
publicKey := h.cryptoService.GetPublicKeyPEM()
c.JSON(http.StatusOK, map[string]string{
"public_key": publicKey,
"algorithm": "RSA-OAEP-2048",
})
}
// ==================== 加密數據解密端點 ====================
// HandleDecryptSensitiveData 解密客戶端傳送的加密数据
func (h *CryptoHandler) HandleDecryptSensitiveData(c *gin.Context) {
var payload crypto.EncryptedPayload
if err := c.ShouldBindJSON(&payload); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "Invalid request"})
return
}
// 解密
decrypted, err := h.cryptoService.DecryptSensitiveData(&payload)
if err != nil {
log.Printf("❌ 解密失敗: %v", err)
c.JSON(http.StatusInternalServerError, gin.H{"error": "Decryption failed"})
return
}
c.JSON(http.StatusOK, map[string]string{
"plaintext": decrypted,
})
}
// ==================== 審計日誌查詢端點 ====================
// 删除审计日志相关功能，在当前简化的实现中不需要
// ==================== 工具函數 ====================
// isValidPrivateKey 驗證私鑰格式
func isValidPrivateKey(key string) bool {
// EVM 私鑰: 64 位十六進制 (可選 0x 前綴)
if len(key) == 64 || (len(key) == 66 && key[:2] == "0x") {
return true
}
// TODO: 添加其他鏈的驗證
return false
}

252
api/register_otp_test.go Normal file
View File

@@ -0,0 +1,252 @@
package api
import (
"testing"
)
// MockUser 模擬用戶結構
type MockUser struct {
ID int
Email string
OTPSecret string
OTPVerified bool
}
// TestOTPRefetchLogic 測試 OTP 重新獲取邏輯
func TestOTPRefetchLogic(t *testing.T) {
tests := []struct {
name string
existingUser *MockUser
userExists bool
expectedAction string // "allow_refetch", "reject_duplicate", "create_new"
expectedMessage string
}{
{
name: "新用戶註冊_郵箱不存在",
existingUser: nil,
userExists: false,
expectedAction: "create_new",
expectedMessage: "創建新用戶",
},
{
name: "未完成OTP驗證_允許重新獲取",
existingUser: &MockUser{
ID: 1,
Email: "test@example.com",
OTPSecret: "SECRET123",
OTPVerified: false,
},
userExists: true,
expectedAction: "allow_refetch",
expectedMessage: "检测到未完成的注册，请继续完成OTP设置",
},
{
name: "已完成OTP驗證_拒絕重複註冊",
existingUser: &MockUser{
ID: 2,
Email: "verified@example.com",
OTPSecret: "SECRET456",
OTPVerified: true,
},
userExists: true,
expectedAction: "reject_duplicate",
expectedMessage: "邮箱已被注册",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// 模擬邏輯處理流程
var actualAction string
var actualMessage string
if !tt.userExists {
// 用戶不存在，創建新用戶
actualAction = "create_new"
actualMessage = "創建新用戶"
} else {
// 用戶已存在，檢查 OTP 驗證狀態
if !tt.existingUser.OTPVerified {
// 未完成 OTP 驗證，允許重新獲取
actualAction = "allow_refetch"
actualMessage = "检测到未完成的注册，请继续完成OTP设置"
} else {
// 已完成驗證，拒絕重複註冊
actualAction = "reject_duplicate"
actualMessage = "邮箱已被注册"
}
}
// 驗證結果
if actualAction != tt.expectedAction {
t.Errorf("Action 不符: got %s, want %s", actualAction, tt.expectedAction)
}
if actualMessage != tt.expectedMessage {
t.Errorf("Message 不符: got %s, want %s", actualMessage, tt.expectedMessage)
}
})
}
}
// TestOTPVerificationStates 測試 OTP 驗證狀態判斷
func TestOTPVerificationStates(t *testing.T) {
tests := []struct {
name string
otpVerified bool
shouldAllowRefetch bool
}{
{
name: "OTP已驗證_不允許重新獲取",
otpVerified: true,
shouldAllowRefetch: false,
},
{
name: "OTP未驗證_允許重新獲取",
otpVerified: false,
shouldAllowRefetch: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// 模擬驗證邏輯
allowRefetch := !tt.otpVerified
if allowRefetch != tt.shouldAllowRefetch {
t.Errorf("Refetch logic error: OTPVerified=%v, allowRefetch=%v, expected=%v",
tt.otpVerified, allowRefetch, tt.shouldAllowRefetch)
}
})
}
}
// TestRegistrationFlow 測試完整註冊流程的邏輯分支
func TestRegistrationFlow(t *testing.T) {
tests := []struct {
name string
scenario string
userExists bool
otpVerified bool
expectHTTPCode int // 模擬的 HTTP 狀態碼
expectResponse string
}{
{
name: "場景1_新用戶首次註冊",
scenario: "新用戶首次訪問註冊接口",
userExists: false,
otpVerified: false,
expectHTTPCode: 200,
expectResponse: "創建用戶並返回 OTP 設置信息",
},
{
name: "場景2_用戶中斷註冊後重新訪問",
scenario: "用戶之前註冊但未完成 OTP 設置，現在重新訪問",
userExists: true,
otpVerified: false,
expectHTTPCode: 200,
expectResponse: "返回現有用戶的 OTP 信息，允許繼續完成",
},
{
name: "場景3_已註冊用戶嘗試重複註冊",
scenario: "用戶已完成註冊，嘗試用同一郵箱再次註冊",
userExists: true,
otpVerified: true,
expectHTTPCode: 409, // Conflict
expectResponse: "邮箱已被注册",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// 模擬註冊流程邏輯
var actualHTTPCode int
var actualResponse string
if !tt.userExists {
// 新用戶，創建並返回 OTP 信息
actualHTTPCode = 200
actualResponse = "創建用戶並返回 OTP 設置信息"
} else {
// 用戶已存在
if !tt.otpVerified {
// 未完成 OTP 驗證，允許重新獲取
actualHTTPCode = 200
actualResponse = "返回現有用戶的 OTP 信息，允許繼續完成"
} else {
// 已完成驗證，拒絕重複註冊
actualHTTPCode = 409
actualResponse = "邮箱已被注册"
}
}
// 驗證
if actualHTTPCode != tt.expectHTTPCode {
t.Errorf("HTTP code 不符: got %d, want %d (scenario: %s)",
actualHTTPCode, tt.expectHTTPCode, tt.scenario)
}
if actualResponse != tt.expectResponse {
t.Errorf("Response 不符: got %s, want %s (scenario: %s)",
actualResponse, tt.expectResponse, tt.scenario)
}
t.Logf("✓ %s: HTTP %d, %s", tt.scenario, actualHTTPCode, actualResponse)
})
}
}
// TestEdgeCases 測試邊界情況
func TestEdgeCases(t *testing.T) {
tests := []struct {
name string
user *MockUser
expectAllow bool
description string
}{
{
name: "用戶ID為0_視為新用戶",
user: &MockUser{
ID: 0,
Email: "new@example.com",
OTPVerified: false,
},
expectAllow: true,
description: "ID為0通常表示用戶還未創建",
},
{
name: "OTPSecret為空_仍可重新獲取",
user: &MockUser{
ID: 1,
Email: "test@example.com",
OTPSecret: "",
OTPVerified: false,
},
expectAllow: true,
description: "即使 OTPSecret 為空，只要未驗證就允許重新獲取",
},
{
name: "OTPSecret存在但已驗證_不允許",
user: &MockUser{
ID: 2,
Email: "verified@example.com",
OTPSecret: "SECRET789",
OTPVerified: true,
},
expectAllow: false,
description: "OTP 已驗證的用戶不能重新獲取",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// 核心邏輯：只要 OTPVerified 為 false，就允許重新獲取
allowRefetch := !tt.user.OTPVerified
if allowRefetch != tt.expectAllow {
t.Errorf("Edge case failed: %s\nUser: ID=%d, OTPVerified=%v\nExpected allow=%v, got=%v",
tt.description, tt.user.ID, tt.user.OTPVerified, tt.expectAllow, allowRefetch)
}
t.Logf("✓ %s", tt.description)
})
}
}

564
api/server.go
View File

@@ -1,6 +1,7 @@
package api
import (
"context"
"encoding/json"
"fmt"
"log"
@@ -10,12 +11,12 @@ import (
"nofx/config"
"nofx/crypto"
"nofx/decision"
"nofx/hook"
"nofx/manager"
"nofx/trader"
"strconv"
"strings"
"time"
"github.com/gin-gonic/gin"
"github.com/google/uuid"
)
@@ -23,14 +24,15 @@ import (
// Server HTTP API服务器
type Server struct {
router *gin.Engine
httpServer *http.Server
traderManager *manager.TraderManager
database config.DatabaseInterface
cryptoService *crypto.CryptoService
database *config.Database
cryptoHandler *CryptoHandler
port int
}
// NewServer 创建API服务器
func NewServer(traderManager *manager.TraderManager, database config.DatabaseInterface, cryptoService *crypto.CryptoService, port int) *Server {
func NewServer(traderManager *manager.TraderManager, database *config.Database, cryptoService *crypto.CryptoService, port int) *Server {
// 设置为Release模式（减少日志输出）
gin.SetMode(gin.ReleaseMode)
@@ -39,17 +41,14 @@ func NewServer(traderManager *manager.TraderManager, database config.DatabaseInt
// 启用CORS
router.Use(corsMiddleware())
if cryptoService == nil {
log.Printf("⚠️ 加密服务未初始化，敏感数据加解密功能不可用")
} else {
database.SetCryptoService(cryptoService)
}
// 创建加密处理器
cryptoHandler := NewCryptoHandler(cryptoService)
s := &Server{
router: router,
traderManager: traderManager,
database: database,
cryptoService: cryptoService,
cryptoHandler: cryptoHandler,
port: port,
}
@@ -83,19 +82,19 @@ func (s *Server) setupRoutes() {
// 健康检查
api.Any("/health", s.handleHealth)
// 认证相关路由（无需认证）
api.POST("/register", s.handleRegister)
api.POST("/login", s.handleLogin)
api.POST("/verify-otp", s.handleVerifyOTP)
api.POST("/complete-registration", s.handleCompleteRegistration)
// 管理员登录（管理员模式下使用，公共）
// 系统支持的模型和交易所（无需认证）
api.GET("/supported-models", s.handleGetSupportedModels)
api.GET("/supported-exchanges", s.handleGetSupportedExchanges)
// 系统配置（无需认证）
// 系统配置（无需认证，用于前端判断是否管理员模式/注册是否开启）
api.GET("/config", s.handleGetSystemConfig)
// 加密相关接口（无需认证）
api.GET("/crypto/public-key", s.cryptoHandler.HandleGetPublicKey)
api.POST("/crypto/decrypt", s.cryptoHandler.HandleDecryptSensitiveData)
// 系统提示词模板管理（无需认证）
api.GET("/prompt-templates", s.handleGetPromptTemplates)
api.GET("/prompt-templates/:name", s.handleGetPromptTemplate)
@@ -108,9 +107,18 @@ func (s *Server) setupRoutes() {
api.POST("/equity-history-batch", s.handleEquityHistoryBatch)
api.GET("/traders/:id/public-config", s.handleGetPublicTraderConfig)
// 认证相关路由（无需认证）
api.POST("/register", s.handleRegister)
api.POST("/login", s.handleLogin)
api.POST("/verify-otp", s.handleVerifyOTP)
api.POST("/complete-registration", s.handleCompleteRegistration)
// 需要认证的路由
protected := api.Group("/", s.authMiddleware())
{
// 注销（加入黑名单）
protected.POST("/logout", s.handleLogout)
// 服务器IP查询（需要认证，用于白名单配置）
protected.GET("/server-ip", s.handleGetServerIP)
@@ -132,7 +140,6 @@ func (s *Server) setupRoutes() {
// 交易所配置
protected.GET("/exchanges", s.handleGetExchangeConfigs)
protected.PUT("/exchanges", s.handleUpdateExchangeConfigs)
protected.PUT("/exchanges/encrypted", s.handleUpdateExchangeConfigsEncrypted)
// 用户信号源配置
protected.GET("/user/signal-sources", s.handleGetUserSignalSource)
@@ -189,24 +196,27 @@ func (s *Server) handleGetSystemConfig(c *gin.Context) {
betaModeStr, _ := s.database.GetSystemConfig("beta_mode")
betaMode := betaModeStr == "true"
// 获取RSA公钥
var rsaPublicKey string
if s.cryptoService != nil {
rsaPublicKey = s.cryptoService.GetPublicKeyPEM()
}
c.JSON(http.StatusOK, gin.H{
"beta_mode": betaMode,
"default_coins": defaultCoins,
"btc_eth_leverage": btcEthLeverage,
"altcoin_leverage": altcoinLeverage,
"rsa_public_key": rsaPublicKey,
"rsa_key_id": "rsa-key-2025-11-05",
})
}
// handleGetServerIP 获取服务器IP地址（用于白名单配置）
func (s *Server) handleGetServerIP(c *gin.Context) {
// 首先尝试从Hook获取用户专用IP
userIP := hook.HookExec[hook.IpResult](hook.GETIP, c.GetString("user_id"))
if userIP != nil && userIP.Error() == nil {
c.JSON(http.StatusOK, gin.H{
"public_ip": userIP.GetResult(),
"message": "请将此IP地址添加到白名单中",
})
return
}
// 尝试通过第三方API获取公网IP
publicIP := getPublicIPFromAPI()
@@ -389,6 +399,16 @@ type ModelConfig struct {
CustomAPIURL string `json:"customApiUrl,omitempty"`
}
// SafeModelConfig 安全的模型配置结构（不包含敏感信息）
type SafeModelConfig struct {
ID string `json:"id"`
Name string `json:"name"`
Provider string `json:"provider"`
Enabled bool `json:"enabled"`
CustomAPIURL string `json:"customApiUrl"` // 自定义API URL（通常不敏感）
CustomModelName string `json:"customModelName"` // 自定义模型名（不敏感）
}
type ExchangeConfig struct {
ID string `json:"id"`
Name string `json:"name"`
@@ -399,19 +419,16 @@ type ExchangeConfig struct {
Testnet bool `json:"testnet,omitempty"`
}
// SafeExchangeConfig 安全的交易所配置响应结构（不包含敏感信息）
// SafeExchangeConfig 安全的交易所配置结构（不包含敏感信息）
type SafeExchangeConfig struct {
ID string `json:"id"`
UserID string `json:"user_id"`
Name string `json:"name"`
Type string `json:"type"`
Enabled bool `json:"enabled"`
Testnet bool `json:"testnet"`
HyperliquidWalletAddr string `json:"hyperliquidWalletAddr"` // 钱包地址，非敏感信息
AsterUser string `json:"asterUser"` // Aster用户名，非敏感信息
Deleted bool `json:"deleted"`
CreatedAt time.Time `json:"created_at"`
UpdatedAt time.Time `json:"updated_at"`
ID string `json:"id"`
Name string `json:"name"`
Type string `json:"type"` // "cex" or "dex"
Enabled bool `json:"enabled"`
Testnet bool `json:"testnet,omitempty"`
HyperliquidWalletAddr string `json:"hyperliquidWalletAddr"` // Hyperliquid钱包地址（不敏感）
AsterUser string `json:"asterUser"` // Aster用户名（不敏感）
AsterSigner string `json:"asterSigner"` // Aster签名者（不敏感）
}
type UpdateModelConfigRequest struct {
@@ -539,7 +556,7 @@ func (s *Server) handleCreateTrader(c *gin.Context) {
switch req.ExchangeID {
case "binance":
tempTrader = trader.NewFuturesTrader(exchangeCfg.APIKey, exchangeCfg.SecretKey)
tempTrader = trader.NewFuturesTrader(exchangeCfg.APIKey, exchangeCfg.SecretKey, userID)
case "hyperliquid":
tempTrader, createErr = trader.NewHyperliquidTrader(
exchangeCfg.APIKey, // private key
@@ -608,9 +625,9 @@ func (s *Server) handleCreateTrader(c *gin.Context) {
}
// 立即将新交易员加载到TraderManager中
err = s.traderManager.LoadUserTraders(s.database, userID)
err = s.traderManager.LoadTraderByID(s.database, userID, traderID)
if err != nil {
log.Printf("⚠️ 加载用户交易员到内存失败: %v", err)
log.Printf("⚠️ 加载交易员到内存失败: %v", err)
// 这里不返回错误，因为交易员已经成功创建到数据库
}
@@ -626,17 +643,18 @@ func (s *Server) handleCreateTrader(c *gin.Context) {
// UpdateTraderRequest 更新交易员请求
type UpdateTraderRequest struct {
Name string `json:"name" binding:"required"`
AIModelID string `json:"ai_model_id" binding:"required"`
ExchangeID string `json:"exchange_id" binding:"required"`
InitialBalance float64 `json:"initial_balance"`
ScanIntervalMinutes int `json:"scan_interval_minutes"`
BTCETHLeverage int `json:"btc_eth_leverage"`
AltcoinLeverage int `json:"altcoin_leverage"`
TradingSymbols string `json:"trading_symbols"`
CustomPrompt string `json:"custom_prompt"`
OverrideBasePrompt bool `json:"override_base_prompt"`
IsCrossMargin *bool `json:"is_cross_margin"`
Name string `json:"name" binding:"required"`
AIModelID string `json:"ai_model_id" binding:"required"`
ExchangeID string `json:"exchange_id" binding:"required"`
InitialBalance float64 `json:"initial_balance"`
ScanIntervalMinutes int `json:"scan_interval_minutes"`
BTCETHLeverage int `json:"btc_eth_leverage"`
AltcoinLeverage int `json:"altcoin_leverage"`
TradingSymbols string `json:"trading_symbols"`
CustomPrompt string `json:"custom_prompt"`
OverrideBasePrompt bool `json:"override_base_prompt"`
SystemPromptTemplate string `json:"system_prompt_template"`
IsCrossMargin *bool `json:"is_cross_margin"`
}
// handleUpdateTrader 更新交易员配置
@@ -694,6 +712,12 @@ func (s *Server) handleUpdateTrader(c *gin.Context) {
scanIntervalMinutes = 3
}
// 设置提示词模板，允许更新
systemPromptTemplate := req.SystemPromptTemplate
if systemPromptTemplate == "" {
systemPromptTemplate = existingTrader.SystemPromptTemplate // 如果请求中没有提供，保持原值
}
// 更新交易员配置
trader := &config.TraderRecord{
ID: traderID,
@@ -707,7 +731,7 @@ func (s *Server) handleUpdateTrader(c *gin.Context) {
TradingSymbols: req.TradingSymbols,
CustomPrompt: req.CustomPrompt,
OverrideBasePrompt: req.OverrideBasePrompt,
SystemPromptTemplate: existingTrader.SystemPromptTemplate, // 保持原值
SystemPromptTemplate: systemPromptTemplate,
IsCrossMargin: isCrossMargin,
ScanIntervalMinutes: scanIntervalMinutes,
IsRunning: existingTrader.IsRunning, // 保持原值
@@ -721,9 +745,9 @@ func (s *Server) handleUpdateTrader(c *gin.Context) {
}
// 重新加载交易员到内存
err = s.traderManager.LoadUserTraders(s.database, userID)
err = s.traderManager.LoadTraderByID(s.database, userID, traderID)
if err != nil {
log.Printf("⚠️ 重新加载用户交易员到内存失败: %v", err)
log.Printf("⚠️ 重新加载交易员到内存失败: %v", err)
}
log.Printf("✓ 更新交易员成功: %s (模型: %s, 交易所: %s)", req.Name, req.AIModelID, req.ExchangeID)
@@ -767,12 +791,15 @@ func (s *Server) handleStartTrader(c *gin.Context) {
traderID := c.Param("id")
// 校验交易员是否属于当前用户
_, _, _, err := s.database.GetTraderConfig(userID, traderID)
traderRecord, _, _, err := s.database.GetTraderConfig(userID, traderID)
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"error": "交易员不存在或无访问权限"})
return
}
// 获取模板名称
templateName := traderRecord.SystemPromptTemplate
trader, err := s.traderManager.GetTrader(traderID)
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"error": "交易员不存在"})
@@ -786,6 +813,9 @@ func (s *Server) handleStartTrader(c *gin.Context) {
return
}
// 重新加载系统提示词模板（确保使用最新的硬盘文件）
s.reloadPromptTemplatesWithLog(templateName)
// 启动交易员
go func() {
log.Printf("▶️ 启动交易员 %s (%s)", traderID, trader.GetName())
@@ -900,7 +930,7 @@ func (s *Server) handleSyncBalance(c *gin.Context) {
switch traderConfig.ExchangeID {
case "binance":
tempTrader = trader.NewFuturesTrader(exchangeCfg.APIKey, exchangeCfg.SecretKey)
tempTrader = trader.NewFuturesTrader(exchangeCfg.APIKey, exchangeCfg.SecretKey, userID)
case "hyperliquid":
tempTrader, createErr = trader.NewHyperliquidTrader(
exchangeCfg.APIKey,
@@ -966,9 +996,9 @@ func (s *Server) handleSyncBalance(c *gin.Context) {
}
// 重新加载交易员到内存
err = s.traderManager.LoadUserTraders(s.database, userID)
err = s.traderManager.LoadTraderByID(s.database, userID, traderID)
if err != nil {
log.Printf("⚠️ 重新加载用户交易员到内存失败: %v", err)
log.Printf("⚠️ 重新加载交易员到内存失败: %v", err)
}
log.Printf("✅ 已同步余额: %.2f → %.2f USDT (%s %.2f%%)", oldBalance, actualBalance, changeType, changePercent)
@@ -994,18 +1024,69 @@ func (s *Server) handleGetModelConfigs(c *gin.Context) {
}
log.Printf("✅ 找到 %d 个AI模型配置", len(models))
c.JSON(http.StatusOK, models)
// 转换为安全的响应结构，移除敏感信息
safeModels := make([]SafeModelConfig, len(models))
for i, model := range models {
safeModels[i] = SafeModelConfig{
ID: model.ID,
Name: model.Name,
Provider: model.Provider,
Enabled: model.Enabled,
CustomAPIURL: model.CustomAPIURL,
CustomModelName: model.CustomModelName,
}
}
c.JSON(http.StatusOK, safeModels)
}
// handleUpdateModelConfigs 更新AI模型配置
// handleUpdateModelConfigs 更新AI模型配置（仅支持加密数据）
func (s *Server) handleUpdateModelConfigs(c *gin.Context) {
userID := c.GetString("user_id")
var req UpdateModelConfigRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
// 读取原始请求体
bodyBytes, err := c.GetRawData()
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "读取请求体失败"})
return
}
// 解析加密的 payload
var encryptedPayload crypto.EncryptedPayload
if err := json.Unmarshal(bodyBytes, &encryptedPayload); err != nil {
log.Printf("❌ 解析加密载荷失败: %v", err)
c.JSON(http.StatusBadRequest, gin.H{"error": "请求格式错误，必须使用加密传输"})
return
}
// 验证是否为加密数据
if encryptedPayload.WrappedKey == "" {
log.Printf("❌ 检测到非加密请求 (UserID: %s)", userID)
c.JSON(http.StatusBadRequest, gin.H{
"error": "此接口仅支持加密传输，请使用加密客户端",
"code": "ENCRYPTION_REQUIRED",
"message": "Encrypted transmission is required for security reasons",
})
return
}
// 解密数据
decrypted, err := s.cryptoHandler.cryptoService.DecryptSensitiveData(&encryptedPayload)
if err != nil {
log.Printf("❌ 解密模型配置失败 (UserID: %s): %v", userID, err)
c.JSON(http.StatusBadRequest, gin.H{"error": "解密数据失败"})
return
}
// 解析解密后的数据
var req UpdateModelConfigRequest
if err := json.Unmarshal([]byte(decrypted), &req); err != nil {
log.Printf("❌ 解析解密数据失败: %v", err)
c.JSON(http.StatusBadRequest, gin.H{"error": "解析解密数据失败"})
return
}
log.Printf("🔓 已解密模型配置数据 (UserID: %s)", userID)
// 更新每个模型的配置
for modelID, modelData := range req.Models {
err := s.database.UpdateAIModel(userID, modelID, modelData.Enabled, modelData.APIKey, modelData.CustomAPIURL, modelData.CustomModelName)
@@ -1016,13 +1097,13 @@ func (s *Server) handleUpdateModelConfigs(c *gin.Context) {
}
// 重新加载该用户的所有交易员，使新配置立即生效
err := s.traderManager.LoadUserTraders(s.database, userID)
err = s.traderManager.LoadUserTraders(s.database, userID)
if err != nil {
log.Printf("⚠️ 重新加载用户交易员到内存失败: %v", err)
// 这里不返回错误，因为模型配置已经成功更新到数据库
}
log.Printf("✓ AI模型配置已更新: %+v", req.Models)
log.Printf("✓ AI模型配置已更新: %+v", SanitizeModelConfigForLog(req.Models))
c.JSON(http.StatusOK, gin.H{"message": "模型配置已更新"})
}
@@ -1038,36 +1119,71 @@ func (s *Server) handleGetExchangeConfigs(c *gin.Context) {
}
log.Printf("✅ 找到 %d 个交易所配置", len(exchanges))
// 转换为安全的响应结构，过滤敏感信息
// 转换为安全的响应结构，移除敏感信息
safeExchanges := make([]SafeExchangeConfig, len(exchanges))
for i, exchange := range exchanges {
safeExchanges[i] = SafeExchangeConfig{
ID: exchange.ID,
UserID: exchange.UserID,
Name: exchange.Name,
Type: exchange.Type,
Enabled: exchange.Enabled,
Testnet: exchange.Testnet,
HyperliquidWalletAddr: exchange.HyperliquidWalletAddr, // 钱包地址，非敏感信息
AsterUser: exchange.AsterUser, // Aster用户名，非敏感信息
Deleted: exchange.Deleted,
CreatedAt: exchange.CreatedAt,
UpdatedAt: exchange.UpdatedAt,
HyperliquidWalletAddr: exchange.HyperliquidWalletAddr,
AsterUser: exchange.AsterUser,
AsterSigner: exchange.AsterSigner,
}
}
c.JSON(http.StatusOK, safeExchanges)
}
// handleUpdateExchangeConfigs 更新交易所配置
// handleUpdateExchangeConfigs 更新交易所配置（仅支持加密数据）
func (s *Server) handleUpdateExchangeConfigs(c *gin.Context) {
userID := c.GetString("user_id")
var req UpdateExchangeConfigRequest
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
// 读取原始请求体
bodyBytes, err := c.GetRawData()
if err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "读取请求体失败"})
return
}
// 解析加密的 payload
var encryptedPayload crypto.EncryptedPayload
if err := json.Unmarshal(bodyBytes, &encryptedPayload); err != nil {
log.Printf("❌ 解析加密载荷失败: %v", err)
c.JSON(http.StatusBadRequest, gin.H{"error": "请求格式错误，必须使用加密传输"})
return
}
// 验证是否为加密数据
if encryptedPayload.WrappedKey == "" {
log.Printf("❌ 检测到非加密请求 (UserID: %s)", userID)
c.JSON(http.StatusBadRequest, gin.H{
"error": "此接口仅支持加密传输，请使用加密客户端",
"code": "ENCRYPTION_REQUIRED",
"message": "Encrypted transmission is required for security reasons",
})
return
}
// 解密数据
decrypted, err := s.cryptoHandler.cryptoService.DecryptSensitiveData(&encryptedPayload)
if err != nil {
log.Printf("❌ 解密交易所配置失败 (UserID: %s): %v", userID, err)
c.JSON(http.StatusBadRequest, gin.H{"error": "解密数据失败"})
return
}
// 解析解密后的数据
var req UpdateExchangeConfigRequest
if err := json.Unmarshal([]byte(decrypted), &req); err != nil {
log.Printf("❌ 解析解密数据失败: %v", err)
c.JSON(http.StatusBadRequest, gin.H{"error": "解析解密数据失败"})
return
}
log.Printf("🔓 已解密交易所配置数据 (UserID: %s)", userID)
// 更新每个交易所的配置
for exchangeID, exchangeData := range req.Exchanges {
err := s.database.UpdateExchange(userID, exchangeID, exchangeData.Enabled, exchangeData.APIKey, exchangeData.SecretKey, exchangeData.Testnet, exchangeData.HyperliquidWalletAddr, exchangeData.AsterUser, exchangeData.AsterSigner, exchangeData.AsterPrivateKey)
@@ -1078,13 +1194,13 @@ func (s *Server) handleUpdateExchangeConfigs(c *gin.Context) {
}
// 重新加载该用户的所有交易员，使新配置立即生效
err := s.traderManager.LoadUserTraders(s.database, userID)
err = s.traderManager.LoadUserTraders(s.database, userID)
if err != nil {
log.Printf("⚠️ 重新加载用户交易员到内存失败: %v", err)
// 这里不返回错误，因为交易所配置已经成功更新到数据库
}
log.Printf("✓ 交易所配置已更新: %+v", req.Exchanges)
log.Printf("✓ 交易所配置已更新: %+v", SanitizeExchangeConfigForLog(req.Exchanges))
c.JSON(http.StatusOK, gin.H{"message": "交易所配置已更新"})
}
@@ -1194,21 +1310,22 @@ func (s *Server) handleGetTraderConfig(c *gin.Context) {
aiModelID := traderConfig.AIModelID
result := map[string]interface{}{
"trader_id": traderConfig.ID,
"trader_name": traderConfig.Name,
"ai_model": aiModelID,
"exchange_id": traderConfig.ExchangeID,
"initial_balance": traderConfig.InitialBalance,
"scan_interval_minutes": traderConfig.ScanIntervalMinutes,
"btc_eth_leverage": traderConfig.BTCETHLeverage,
"altcoin_leverage": traderConfig.AltcoinLeverage,
"trading_symbols": traderConfig.TradingSymbols,
"custom_prompt": traderConfig.CustomPrompt,
"override_base_prompt": traderConfig.OverrideBasePrompt,
"is_cross_margin": traderConfig.IsCrossMargin,
"use_coin_pool": traderConfig.UseCoinPool,
"use_oi_top": traderConfig.UseOITop,
"is_running": isRunning,
"trader_id": traderConfig.ID,
"trader_name": traderConfig.Name,
"ai_model": aiModelID,
"exchange_id": traderConfig.ExchangeID,
"initial_balance": traderConfig.InitialBalance,
"scan_interval_minutes": traderConfig.ScanIntervalMinutes,
"btc_eth_leverage": traderConfig.BTCETHLeverage,
"altcoin_leverage": traderConfig.AltcoinLeverage,
"trading_symbols": traderConfig.TradingSymbols,
"custom_prompt": traderConfig.CustomPrompt,
"override_base_prompt": traderConfig.OverrideBasePrompt,
"system_prompt_template": traderConfig.SystemPromptTemplate,
"is_cross_margin": traderConfig.IsCrossMargin,
"use_coin_pool": traderConfig.UseCoinPool,
"use_oi_top": traderConfig.UseOITop,
"is_running": isRunning,
}
c.JSON(http.StatusOK, result)
@@ -1330,7 +1447,15 @@ func (s *Server) handleLatestDecisions(c *gin.Context) {
return
}
records, err := trader.GetDecisionLogger().GetLatestRecords(5)
// 从 query 参数读取 limit，默认 5，最大 50
limit := 5
if limitStr := c.Query("limit"); limitStr != "" {
if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 50 {
limit = l
}
}
records, err := trader.GetDecisionLogger().GetLatestRecords(limit)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{
"error": fmt.Sprintf("获取决策日志失败: %v", err),
@@ -1524,8 +1649,17 @@ func (s *Server) authMiddleware() gin.HandlerFunc {
return
}
tokenString := tokenParts[1]
// 黑名单检查
if auth.IsTokenBlacklisted(tokenString) {
c.JSON(http.StatusUnauthorized, gin.H{"error": "token已失效，请重新登录"})
c.Abort()
return
}
// 验证JWT token
claims, err := auth.ValidateJWT(tokenParts[1])
claims, err := auth.ValidateJWT(tokenString)
if err != nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": "无效的token: " + err.Error()})
c.Abort()
@@ -1539,8 +1673,37 @@ func (s *Server) authMiddleware() gin.HandlerFunc {
}
}
// handleLogout 将当前token加入黑名单
func (s *Server) handleLogout(c *gin.Context) {
authHeader := c.GetHeader("Authorization")
if authHeader == "" {
c.JSON(http.StatusUnauthorized, gin.H{"error": "缺少Authorization头"})
return
}
parts := strings.Split(authHeader, " ")
if len(parts) != 2 || parts[0] != "Bearer" {
c.JSON(http.StatusUnauthorized, gin.H{"error": "无效的Authorization格式"})
return
}
tokenString := parts[1]
claims, err := auth.ValidateJWT(tokenString)
if err != nil {
c.JSON(http.StatusUnauthorized, gin.H{"error": "无效的token"})
return
}
var exp time.Time
if claims.ExpiresAt != nil {
exp = claims.ExpiresAt.Time
} else {
exp = time.Now().Add(24 * time.Hour)
}
auth.BlacklistToken(tokenString, exp)
c.JSON(http.StatusOK, gin.H{"message": "已登出"})
}
// handleRegister 处理用户注册请求
func (s *Server) handleRegister(c *gin.Context) {
var req struct {
Email string `json:"email" binding:"required,email"`
Password string `json:"password" binding:"required,min=6"`
@@ -1574,8 +1737,21 @@ func (s *Server) handleRegister(c *gin.Context) {
}
// 检查邮箱是否已存在
_, err := s.database.GetUserByEmail(req.Email)
existingUser, err := s.database.GetUserByEmail(req.Email)
if err == nil {
// 如果用户未完成OTP验证，允许重新获取OTP（支持中断后恢复注册）
if !existingUser.OTPVerified {
qrCodeURL := auth.GetOTPQRCodeURL(existingUser.OTPSecret, req.Email)
c.JSON(http.StatusOK, gin.H{
"user_id": existingUser.ID,
"email": req.Email,
"otp_secret": existingUser.OTPSecret,
"qr_code_url": qrCodeURL,
"message": "检测到未完成的注册，请继续完成OTP设置",
})
return
}
// 用户已完成验证，拒绝重复注册
c.JSON(http.StatusConflict, gin.H{"error": "邮箱已被注册"})
return
}
@@ -1689,10 +1865,8 @@ func (s *Server) handleCompleteRegistration(c *gin.Context) {
// handleLogin 处理用户登录请求
func (s *Server) handleLogin(c *gin.Context) {
var req struct {
Email string `json:"email"`
EmailEncrypted *crypto.EncryptedPayload `json:"email_encrypted"`
Password string `json:"password"`
PasswordEncrypted *crypto.EncryptedPayload `json:"password_encrypted"`
Email string `json:"email" binding:"required,email"`
Password string `json:"password" binding:"required"`
}
if err := c.ShouldBindJSON(&req); err != nil {
@@ -1700,51 +1874,6 @@ func (s *Server) handleLogin(c *gin.Context) {
return
}
if req.EmailEncrypted != nil {
if s.cryptoService == nil {
c.JSON(http.StatusServiceUnavailable, gin.H{"error": "加密服务不可用"})
return
}
decryptedEmail, err := s.cryptoService.DecryptSensitiveData(req.EmailEncrypted)
if err != nil {
log.Printf("❌ 登录邮箱解密失败: %v", err)
c.JSON(http.StatusBadRequest, gin.H{"error": "邮箱解密失败"})
return
}
req.Email = decryptedEmail
}
if req.PasswordEncrypted != nil {
if s.cryptoService == nil {
c.JSON(http.StatusServiceUnavailable, gin.H{"error": "加密服务不可用"})
return
}
decryptedPassword, err := s.cryptoService.DecryptSensitiveData(req.PasswordEncrypted)
if err != nil {
log.Printf("❌ 登录密码解密失败: %v", err)
c.JSON(http.StatusBadRequest, gin.H{"error": "密码解密失败"})
return
}
req.Password = decryptedPassword
}
req.Email = strings.TrimSpace(req.Email)
if req.Email == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "邮箱不能为空"})
return
}
if !strings.Contains(req.Email, "@") {
c.JSON(http.StatusBadRequest, gin.H{"error": "邮箱格式错误"})
return
}
if strings.TrimSpace(req.Password) == "" {
c.JSON(http.StatusBadRequest, gin.H{"error": "密码不能为空"})
return
}
// 获取用户信息
user, err := s.database.GetUserByEmail(req.Email)
if err != nil {
@@ -1817,6 +1946,50 @@ func (s *Server) handleVerifyOTP(c *gin.Context) {
})
}
// handleResetPassword 重置密码（通过邮箱 + OTP 验证）
func (s *Server) handleResetPassword(c *gin.Context) {
var req struct {
Email string `json:"email" binding:"required,email"`
NewPassword string `json:"new_password" binding:"required,min=6"`
OTPCode string `json:"otp_code" binding:"required"`
}
if err := c.ShouldBindJSON(&req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
}
// 查询用户
user, err := s.database.GetUserByEmail(req.Email)
if err != nil {
c.JSON(http.StatusNotFound, gin.H{"error": "邮箱不存在"})
return
}
// 验证 OTP
if !auth.VerifyOTP(user.OTPSecret, req.OTPCode) {
c.JSON(http.StatusBadRequest, gin.H{"error": "Google Authenticator 验证码错误"})
return
}
// 生成新密码哈希
newPasswordHash, err := auth.HashPassword(req.NewPassword)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "密码处理失败"})
return
}
// 更新密码
err = s.database.UpdateUserPassword(user.ID, newPasswordHash)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": "密码更新失败"})
return
}
log.Printf("✓ 用户 %s 密码已重置", user.Email)
c.JSON(http.StatusOK, gin.H{"message": "密码重置成功，请使用新密码登录"})
}
// initUserDefaultConfigs 为新用户初始化默认的模型和交易所配置
func (s *Server) initUserDefaultConfigs(userID string) error {
// 注释掉自动创建默认配置，让用户手动添加
@@ -1848,7 +2021,22 @@ func (s *Server) handleGetSupportedExchanges(c *gin.Context) {
return
}
c.JSON(http.StatusOK, exchanges)
// 转换为安全的响应结构，移除敏感信息
safeExchanges := make([]SafeExchangeConfig, len(exchanges))
for i, exchange := range exchanges {
safeExchanges[i] = SafeExchangeConfig{
ID: exchange.ID,
Name: exchange.Name,
Type: exchange.Type,
Enabled: exchange.Enabled,
Testnet: exchange.Testnet,
HyperliquidWalletAddr: "", // 默认配置不包含钱包地址
AsterUser: "", // 默认配置不包含用户信息
AsterSigner: "",
}
}
c.JSON(http.StatusOK, safeExchanges)
}
// Start 启动服务器
@@ -1880,7 +2068,26 @@ func (s *Server) Start() error {
log.Printf(" • GET /api/performance?trader_id=xxx - 指定trader的AI学习表现分析")
log.Println()
return s.router.Run(addr)
// 创建 http.Server 以支持 graceful shutdown
s.httpServer = &http.Server{
Addr: addr,
Handler: s.router,
}
return s.httpServer.ListenAndServe()
}
// Shutdown 优雅关闭 API 服务器
func (s *Server) Shutdown() error {
if s.httpServer == nil {
return nil
}
// 设置 5 秒超时
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
return s.httpServer.Shutdown(ctx)
}
// handleGetPromptTemplates 获取所有系统提示词模板列表
@@ -2125,63 +2332,16 @@ func (s *Server) handleGetPublicTraderConfig(c *gin.Context) {
c.JSON(http.StatusOK, result)
}
// handleUpdateExchangeConfigsEncrypted 更新交易所配置（加密传输）
func (s *Server) handleUpdateExchangeConfigsEncrypted(c *gin.Context) {
if s.cryptoService == nil {
c.JSON(http.StatusServiceUnavailable, gin.H{"error": "加密服务不可用"})
// reloadPromptTemplatesWithLog 重新加载提示词模板并记录日志
func (s *Server) reloadPromptTemplatesWithLog(templateName string) {
if err := decision.ReloadPromptTemplates(); err != nil {
log.Printf("⚠️ 重新加载提示词模板失败: %v", err)
return
}
userID := c.GetString("user_id")
// 接收加密载荷
var payload crypto.EncryptedPayload
if err := c.ShouldBindJSON(&payload); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
return
if templateName == "" {
log.Printf("✓ 已重新加载系统提示词模板 [当前使用: default (未指定，使用默认)]")
} else {
log.Printf("✓ 已重新加载系统提示词模板 [当前使用: %s]", templateName)
}
// 解密数据
decryptedData, err := s.cryptoService.DecryptSensitiveData(&payload)
if err != nil {
log.Printf("❌ 解密失败: %v", err)
c.JSON(http.StatusBadRequest, gin.H{"error": "解密失败"})
return
}
// 解析解密后的数据
var req UpdateExchangeConfigRequest
if err := json.Unmarshal([]byte(decryptedData), &req); err != nil {
c.JSON(http.StatusBadRequest, gin.H{"error": "数据格式错误"})
return
}
// 更新每个交易所的配置
for exchangeID, exchangeData := range req.Exchanges {
err := s.database.UpdateExchange(
userID,
exchangeID,
exchangeData.Enabled,
exchangeData.APIKey,
exchangeData.SecretKey,
exchangeData.Testnet,
exchangeData.HyperliquidWalletAddr,
exchangeData.AsterUser,
exchangeData.AsterSigner,
exchangeData.AsterPrivateKey,
)
if err != nil {
c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("更新交易所 %s 失败: %v", exchangeID, err)})
return
}
}
// 重新加载该用户的所有交易员，使新配置立即生效
err = s.traderManager.LoadUserTraders(s.database, userID)
if err != nil {
log.Printf("⚠️ 重新加载用户交易员到内存失败: %v", err)
}
log.Printf("✓ 交易所配置已通过加密方式更新")
c.JSON(http.StatusOK, gin.H{"message": "交易所配置已更新"})
}

227
api/server_test.go Normal file
View File

@@ -0,0 +1,227 @@
package api
import (
"encoding/json"
"testing"
"nofx/config"
)
// TestUpdateTraderRequest_SystemPromptTemplate 测试更新交易员时 SystemPromptTemplate 字段是否存在
func TestUpdateTraderRequest_SystemPromptTemplate(t *testing.T) {
tests := []struct {
name string
requestJSON string
expectedPromptTemplate string
}{
{
name: "更新时应该能接收 system_prompt_template=nof1",
requestJSON: `{
"name": "Test Trader",
"ai_model_id": "gpt-4",
"exchange_id": "binance",
"initial_balance": 1000,
"scan_interval_minutes": 5,
"btc_eth_leverage": 5,
"altcoin_leverage": 3,
"trading_symbols": "BTC,ETH",
"custom_prompt": "test",
"override_base_prompt": false,
"is_cross_margin": true,
"system_prompt_template": "nof1"
}`,
expectedPromptTemplate: "nof1",
},
{
name: "更新时应该能接收 system_prompt_template=default",
requestJSON: `{
"name": "Test Trader",
"ai_model_id": "gpt-4",
"exchange_id": "binance",
"initial_balance": 1000,
"scan_interval_minutes": 5,
"btc_eth_leverage": 5,
"altcoin_leverage": 3,
"trading_symbols": "BTC,ETH",
"custom_prompt": "test",
"override_base_prompt": false,
"is_cross_margin": true,
"system_prompt_template": "default"
}`,
expectedPromptTemplate: "default",
},
{
name: "更新时应该能接收 system_prompt_template=custom",
requestJSON: `{
"name": "Test Trader",
"ai_model_id": "gpt-4",
"exchange_id": "binance",
"initial_balance": 1000,
"scan_interval_minutes": 5,
"btc_eth_leverage": 5,
"altcoin_leverage": 3,
"trading_symbols": "BTC,ETH",
"custom_prompt": "test",
"override_base_prompt": false,
"is_cross_margin": true,
"system_prompt_template": "custom"
}`,
expectedPromptTemplate: "custom",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// 测试 UpdateTraderRequest 结构体是否能正确解析 system_prompt_template 字段
var req UpdateTraderRequest
err := json.Unmarshal([]byte(tt.requestJSON), &req)
if err != nil {
t.Fatalf("Failed to unmarshal JSON: %v", err)
}
// ✅ 验证 SystemPromptTemplate 字段是否被正确读取
if req.SystemPromptTemplate != tt.expectedPromptTemplate {
t.Errorf("Expected SystemPromptTemplate=%q, got %q",
tt.expectedPromptTemplate, req.SystemPromptTemplate)
}
// 验证其他字段也被正确解析
if req.Name != "Test Trader" {
t.Errorf("Name not parsed correctly")
}
if req.AIModelID != "gpt-4" {
t.Errorf("AIModelID not parsed correctly")
}
})
}
}
// TestGetTraderConfigResponse_SystemPromptTemplate 测试获取交易员配置时返回值是否包含 system_prompt_template
func TestGetTraderConfigResponse_SystemPromptTemplate(t *testing.T) {
tests := []struct {
name string
traderConfig *config.TraderRecord
expectedTemplate string
}{
{
name: "获取配置应该返回 system_prompt_template=nof1",
traderConfig: &config.TraderRecord{
ID: "trader-123",
UserID: "user-1",
Name: "Test Trader",
AIModelID: "gpt-4",
ExchangeID: "binance",
InitialBalance: 1000,
ScanIntervalMinutes: 5,
BTCETHLeverage: 5,
AltcoinLeverage: 3,
TradingSymbols: "BTC,ETH",
CustomPrompt: "test",
OverrideBasePrompt: false,
SystemPromptTemplate: "nof1",
IsCrossMargin: true,
IsRunning: false,
},
expectedTemplate: "nof1",
},
{
name: "获取配置应该返回 system_prompt_template=default",
traderConfig: &config.TraderRecord{
ID: "trader-456",
UserID: "user-1",
Name: "Test Trader 2",
AIModelID: "gpt-4",
ExchangeID: "binance",
InitialBalance: 2000,
ScanIntervalMinutes: 10,
BTCETHLeverage: 10,
AltcoinLeverage: 5,
TradingSymbols: "BTC",
CustomPrompt: "",
OverrideBasePrompt: false,
SystemPromptTemplate: "default",
IsCrossMargin: false,
IsRunning: false,
},
expectedTemplate: "default",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// 模拟 handleGetTraderConfig 的返回值构造逻辑（修复后的实现）
result := map[string]interface{}{
"trader_id": tt.traderConfig.ID,
"trader_name": tt.traderConfig.Name,
"ai_model": tt.traderConfig.AIModelID,
"exchange_id": tt.traderConfig.ExchangeID,
"initial_balance": tt.traderConfig.InitialBalance,
"scan_interval_minutes": tt.traderConfig.ScanIntervalMinutes,
"btc_eth_leverage": tt.traderConfig.BTCETHLeverage,
"altcoin_leverage": tt.traderConfig.AltcoinLeverage,
"trading_symbols": tt.traderConfig.TradingSymbols,
"custom_prompt": tt.traderConfig.CustomPrompt,
"override_base_prompt": tt.traderConfig.OverrideBasePrompt,
"system_prompt_template": tt.traderConfig.SystemPromptTemplate,
"is_cross_margin": tt.traderConfig.IsCrossMargin,
"is_running": tt.traderConfig.IsRunning,
}
// ✅ 检查响应中是否包含 system_prompt_template
if _, exists := result["system_prompt_template"]; !exists {
t.Errorf("Response is missing 'system_prompt_template' field")
} else {
actualTemplate := result["system_prompt_template"].(string)
if actualTemplate != tt.expectedTemplate {
t.Errorf("Expected system_prompt_template=%q, got %q",
tt.expectedTemplate, actualTemplate)
}
}
// 验证其他字段是否正确
if result["trader_id"] != tt.traderConfig.ID {
t.Errorf("trader_id mismatch")
}
if result["trader_name"] != tt.traderConfig.Name {
t.Errorf("trader_name mismatch")
}
})
}
}
// TestUpdateTraderRequest_CompleteFields 验证 UpdateTraderRequest 结构体定义完整性
func TestUpdateTraderRequest_CompleteFields(t *testing.T) {
jsonData := `{
"name": "Test Trader",
"ai_model_id": "gpt-4",
"exchange_id": "binance",
"initial_balance": 1000,
"scan_interval_minutes": 5,
"btc_eth_leverage": 5,
"altcoin_leverage": 3,
"trading_symbols": "BTC,ETH",
"custom_prompt": "test",
"override_base_prompt": false,
"is_cross_margin": true,
"system_prompt_template": "nof1"
}`
var req UpdateTraderRequest
err := json.Unmarshal([]byte(jsonData), &req)
if err != nil {
t.Fatalf("Failed to unmarshal JSON: %v", err)
}
// 验证基本字段是否正确解析
if req.Name != "Test Trader" {
t.Errorf("Name mismatch: got %q", req.Name)
}
if req.AIModelID != "gpt-4" {
t.Errorf("AIModelID mismatch: got %q", req.AIModelID)
}
// ✅ 验证 SystemPromptTemplate 字段已正确添加到结构体
if req.SystemPromptTemplate != "nof1" {
t.Errorf("SystemPromptTemplate mismatch: expected %q, got %q", "nof1", req.SystemPromptTemplate)
}
}

97
api/utils.go Normal file
View File

@@ -0,0 +1,97 @@
package api
import "strings"
// MaskSensitiveString 脱敏敏感字符串，只显示前4位和后4位
// 用于脱敏 API Key、Secret Key、Private Key 等敏感信息
func MaskSensitiveString(s string) string {
if s == "" {
return ""
}
length := len(s)
if length <= 8 {
return "****" // 字符串太短，全部隐藏
}
return s[:4] + "****" + s[length-4:]
}
// SanitizeModelConfigForLog 脱敏模型配置用于日志输出
func SanitizeModelConfigForLog(models map[string]struct {
Enabled bool `json:"enabled"`
APIKey string `json:"api_key"`
CustomAPIURL string `json:"custom_api_url"`
CustomModelName string `json:"custom_model_name"`
}) map[string]interface{} {
safe := make(map[string]interface{})
for modelID, cfg := range models {
safe[modelID] = map[string]interface{}{
"enabled": cfg.Enabled,
"api_key": MaskSensitiveString(cfg.APIKey),
"custom_api_url": cfg.CustomAPIURL,
"custom_model_name": cfg.CustomModelName,
}
}
return safe
}
// SanitizeExchangeConfigForLog 脱敏交易所配置用于日志输出
func SanitizeExchangeConfigForLog(exchanges map[string]struct {
Enabled bool `json:"enabled"`
APIKey string `json:"api_key"`
SecretKey string `json:"secret_key"`
Testnet bool `json:"testnet"`
HyperliquidWalletAddr string `json:"hyperliquid_wallet_addr"`
AsterUser string `json:"aster_user"`
AsterSigner string `json:"aster_signer"`
AsterPrivateKey string `json:"aster_private_key"`
}) map[string]interface{} {
safe := make(map[string]interface{})
for exchangeID, cfg := range exchanges {
safeExchange := map[string]interface{}{
"enabled": cfg.Enabled,
"testnet": cfg.Testnet,
}
// 只在有值时才添加脱敏后的敏感字段
if cfg.APIKey != "" {
safeExchange["api_key"] = MaskSensitiveString(cfg.APIKey)
}
if cfg.SecretKey != "" {
safeExchange["secret_key"] = MaskSensitiveString(cfg.SecretKey)
}
if cfg.AsterPrivateKey != "" {
safeExchange["aster_private_key"] = MaskSensitiveString(cfg.AsterPrivateKey)
}
// 非敏感字段直接添加
if cfg.HyperliquidWalletAddr != "" {
safeExchange["hyperliquid_wallet_addr"] = cfg.HyperliquidWalletAddr
}
if cfg.AsterUser != "" {
safeExchange["aster_user"] = cfg.AsterUser
}
if cfg.AsterSigner != "" {
safeExchange["aster_signer"] = cfg.AsterSigner
}
safe[exchangeID] = safeExchange
}
return safe
}
// MaskEmail 脱敏邮箱地址，保留前2位和@后部分
func MaskEmail(email string) string {
if email == "" {
return ""
}
parts := strings.Split(email, "@")
if len(parts) != 2 {
return "****" // 格式不正确
}
username := parts[0]
domain := parts[1]
if len(username) <= 2 {
return "**@" + domain
}
return username[:2] + "****@" + domain
}

193
api/utils_test.go Normal file
View File

@@ -0,0 +1,193 @@
package api
import (
"testing"
)
func TestMaskSensitiveString(t *testing.T) {
tests := []struct {
name string
input string
expected string
}{
{
name: "空字符串",
input: "",
expected: "",
},
{
name: "短字符串（小于等于8位）",
input: "short",
expected: "****",
},
{
name: "正常API key",
input: "sk-1234567890abcdefghijklmnopqrstuvwxyz",
expected: "sk-1****wxyz",
},
{
name: "正常私钥",
input: "0x1234567890abcdef1234567890abcdef12345678",
expected: "0x12****5678",
},
{
name: "刚好9位",
input: "123456789",
expected: "1234****6789",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := MaskSensitiveString(tt.input)
if result != tt.expected {
t.Errorf("MaskSensitiveString(%q) = %q, want %q", tt.input, result, tt.expected)
}
})
}
}
func TestSanitizeModelConfigForLog(t *testing.T) {
models := map[string]struct {
Enabled bool `json:"enabled"`
APIKey string `json:"api_key"`
CustomAPIURL string `json:"custom_api_url"`
CustomModelName string `json:"custom_model_name"`
}{
"deepseek": {
Enabled: true,
APIKey: "sk-1234567890abcdefghijklmnopqrstuvwxyz",
CustomAPIURL: "https://api.deepseek.com",
CustomModelName: "deepseek-chat",
},
}
result := SanitizeModelConfigForLog(models)
deepseekConfig, ok := result["deepseek"].(map[string]interface{})
if !ok {
t.Fatal("deepseek config not found or wrong type")
}
if deepseekConfig["enabled"] != true {
t.Errorf("expected enabled=true, got %v", deepseekConfig["enabled"])
}
maskedKey, ok := deepseekConfig["api_key"].(string)
if !ok {
t.Fatal("api_key not found or wrong type")
}
if maskedKey != "sk-1****wxyz" {
t.Errorf("expected masked api_key='sk-1****wxyz', got %q", maskedKey)
}
if deepseekConfig["custom_api_url"] != "https://api.deepseek.com" {
t.Errorf("custom_api_url should not be masked")
}
}
func TestSanitizeExchangeConfigForLog(t *testing.T) {
exchanges := map[string]struct {
Enabled bool `json:"enabled"`
APIKey string `json:"api_key"`
SecretKey string `json:"secret_key"`
Testnet bool `json:"testnet"`
HyperliquidWalletAddr string `json:"hyperliquid_wallet_addr"`
AsterUser string `json:"aster_user"`
AsterSigner string `json:"aster_signer"`
AsterPrivateKey string `json:"aster_private_key"`
}{
"binance": {
Enabled: true,
APIKey: "binance_api_key_1234567890abcdef",
SecretKey: "binance_secret_key_1234567890abcdef",
Testnet: false,
},
"hyperliquid": {
Enabled: true,
HyperliquidWalletAddr: "0x1234567890abcdef1234567890abcdef12345678",
Testnet: false,
},
}
result := SanitizeExchangeConfigForLog(exchanges)
// 检查币安配置
binanceConfig, ok := result["binance"].(map[string]interface{})
if !ok {
t.Fatal("binance config not found or wrong type")
}
maskedAPIKey, ok := binanceConfig["api_key"].(string)
if !ok {
t.Fatal("binance api_key not found or wrong type")
}
if maskedAPIKey != "bina****cdef" {
t.Errorf("expected masked api_key='bina****cdef', got %q", maskedAPIKey)
}
maskedSecretKey, ok := binanceConfig["secret_key"].(string)
if !ok {
t.Fatal("binance secret_key not found or wrong type")
}
if maskedSecretKey != "bina****cdef" {
t.Errorf("expected masked secret_key='bina****cdef', got %q", maskedSecretKey)
}
// 检查 Hyperliquid 配置
hlConfig, ok := result["hyperliquid"].(map[string]interface{})
if !ok {
t.Fatal("hyperliquid config not found or wrong type")
}
walletAddr, ok := hlConfig["hyperliquid_wallet_addr"].(string)
if !ok {
t.Fatal("hyperliquid_wallet_addr not found or wrong type")
}
// 钱包地址不应该被脱敏
if walletAddr != "0x1234567890abcdef1234567890abcdef12345678" {
t.Errorf("wallet address should not be masked, got %q", walletAddr)
}
}
func TestMaskEmail(t *testing.T) {
tests := []struct {
name string
input string
expected string
}{
{
name: "空邮箱",
input: "",
expected: "",
},
{
name: "格式错误",
input: "notanemail",
expected: "****",
},
{
name: "正常邮箱",
input: "user@example.com",
expected: "us****@example.com",
},
{
name: "短用户名",
input: "a@example.com",
expected: "**@example.com",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := MaskEmail(tt.input)
if result != tt.expected {
t.Errorf("MaskEmail(%q) = %q, want %q", tt.input, result, tt.expected)
}
})
}
}

46
auth/auth.go
View File

@@ -3,6 +3,8 @@ package auth
import (
"crypto/rand"
"fmt"
"log"
"sync"
"time"
"github.com/golang-jwt/jwt/v5"
@@ -14,6 +16,15 @@ import (
// JWTSecret JWT密钥，将从配置中动态设置
var JWTSecret []byte
// tokenBlacklist 用于登出后的token黑名单（仅内存，按过期时间清理）
var tokenBlacklist = struct {
sync.RWMutex
items map[string]time.Time
}{items: make(map[string]time.Time)}
// maxBlacklistEntries 黑名单最大容量阈值
const maxBlacklistEntries = 100_000
// OTPIssuer OTP发行者名称
const OTPIssuer = "nofxAI"
@@ -22,6 +33,41 @@ func SetJWTSecret(secret string) {
JWTSecret = []byte(secret)
}
// BlacklistToken 将token加入黑名单直到过期
func BlacklistToken(token string, exp time.Time) {
tokenBlacklist.Lock()
defer tokenBlacklist.Unlock()
tokenBlacklist.items[token] = exp
// 如果超过容量阈值，则进行一次过期清理；若仍超限，记录警告日志
if len(tokenBlacklist.items) > maxBlacklistEntries {
now := time.Now()
for t, e := range tokenBlacklist.items {
if now.After(e) {
delete(tokenBlacklist.items, t)
}
}
if len(tokenBlacklist.items) > maxBlacklistEntries {
log.Printf("auth: token blacklist size (%d) exceeds limit (%d) after sweep; consider reducing JWT TTL or using a shared persistent store",
len(tokenBlacklist.items), maxBlacklistEntries)
}
}
}
// IsTokenBlacklisted 检查token是否在黑名单中（过期自动清理）
func IsTokenBlacklisted(token string) bool {
tokenBlacklist.Lock()
defer tokenBlacklist.Unlock()
if exp, ok := tokenBlacklist.items[token]; ok {
if time.Now().After(exp) {
delete(tokenBlacklist.items, token)
return false
}
return true
}
return false
}
// Claims JWT声明
type Claims struct {
UserID string `json:"user_id"`

455
bootstrap/README.md Normal file
View File

@@ -0,0 +1,455 @@
# Bootstrap 模块初始化框架
## 概述
Bootstrap 是一个模块化的初始化框架，允许各个模块通过注册钩子的方式自动完成初始化，支持优先级控制、条件初始化、错误策略等高级特性。
## 核心特性
- ✅ **优先级排序** - 保证模块按正确的顺序初始化
- ✅ **钩子命名** - 每个钩子都有清晰的名称，便于日志追踪和错误定位
- ✅ **上下文传递** - 模块之间可以共享数据（如数据库实例）
- ✅ **条件初始化** - 根据配置动态决定是否初始化某个模块
- ✅ **灵活的错误处理** - 支持快速失败、继续执行、警告三种策略
- ✅ **详细日志** - 显示初始化进度、耗时统计
- ✅ **线程安全** - 使用互斥锁保护全局状态
- ✅ **测试友好** - 提供 Clear() 方法清除钩子
## 快速开始
### 1. 在模块中注册初始化钩子
在你的模块包中创建 `init.go` 文件：
```go
// proxy/init.go
package proxy
import (
"nofx/bootstrap"
"nofx/config"
)
func init() {
// 注册初始化钩子
bootstrap.Register("Proxy模块", bootstrap.PriorityCore, initProxyModule)
}
func initProxyModule(ctx *bootstrap.Context) error {
// 从配置中读取 proxy 配置
proxyConfig := ctx.Config.Proxy
// 初始化代理管理器
if err := InitGlobalProxyManager(proxyConfig); err != nil {
return err
}
// 将实例存储到上下文，供其他模块使用
ctx.Set("proxy_manager", GetGlobalProxyManager())
return nil
}
```
### 2. 在 main.go 中运行初始化
```go
package main
import (
"log"
"nofx/bootstrap"
"nofx/config"
// 导入需要初始化的模块（触发 init() 注册）
_ "nofx/proxy"
_ "nofx/market"
_ "nofx/trader"
)
func main() {
// 加载配置
cfg, err := config.LoadConfig("config.json")
if err != nil {
log.Fatalf("加载配置失败: %v", err)
}
// 创建初始化上下文
ctx := bootstrap.NewContext(cfg)
// 执行所有初始化钩子
if err := bootstrap.Run(ctx); err != nil {
log.Fatalf("初始化失败: %v", err)
}
// 启动业务逻辑...
}
```
### 3. 运行效果
```
🔄 开始初始化 3 个模块...
[1/3] 初始化: Database模块 (优先级: 20)
✓ 完成: Database模块 (耗时: 120ms)
[2/3] 初始化: Proxy模块 (优先级: 50)
↳ 代理自动刷新已启动 (间隔: 30m0s)
↳ 代理池状态: 总计=5, 黑名单=0, 可用=5
✓ 完成: Proxy模块 (耗时: 35ms)
[3/3] 初始化: Market模块 (优先级: 100)
✓ 完成: Market模块 (耗时: 200ms)
✅ 所有模块初始化完成 (总耗时: 355ms)
📊 统计: 成功=3, 跳过=0
```
## 优先级常量
系统预定义了以下优先级常量（数值越小越先执行）：
| 常量 | 值 | 用途 | 示例 |
|------|-----|------|------|
| `PriorityInfrastructure` | 10 | 基础设施 | 日志系统、配置加载 |
| `PriorityDatabase` | 20 | 数据库连接 | SQLite、Redis |
| `PriorityCore` | 50 | 核心模块 | Proxy、Market Monitor |
| `PriorityBusiness` | 100 | 业务模块 | Trader、API Server |
| `PriorityBackground` | 200 | 后台任务 | 定时任务、监控 |
### 使用示例
```go
// 数据库模块（最先初始化）
bootstrap.Register("Database", bootstrap.PriorityDatabase, initDatabase)
// 代理模块（核心模块）
bootstrap.Register("Proxy", bootstrap.PriorityCore, initProxy)
// Trader模块（依赖数据库和代理）
bootstrap.Register("Trader", bootstrap.PriorityBusiness, initTrader)
```
## 高级特性
### 1. 条件初始化
某些模块只在特定条件下才需要初始化：
```go
bootstrap.Register("Proxy模块", bootstrap.PriorityCore, initProxy).
EnabledIf(func(ctx *bootstrap.Context) bool {
// 只在配置中启用 proxy 时才初始化
return ctx.Config.Proxy != nil && ctx.Config.Proxy.Enabled
})
```
**输出**：
```
[2/5] 跳过: Proxy模块 (条件未满足)
```
### 2. 错误处理策略
支持三种错误处理策略：
#### FailFast（默认）- 遇到错误立即停止
```go
bootstrap.Register("Database", bootstrap.PriorityDatabase, initDatabase)
// 默认就是 FailFast，无需显式设置
```
**效果**：Database 初始化失败，整个系统停止启动
#### ContinueOnError - 继续执行，收集所有错误
```go
bootstrap.Register("Proxy", bootstrap.PriorityCore, initProxy).
OnError(bootstrap.ContinueOnError)
```
**效果**：Proxy 失败不影响其他模块，最后汇总所有错误
#### WarnOnError - 继续执行，只打印警告
```go
bootstrap.Register("Proxy", bootstrap.PriorityCore, initProxy).
OnError(bootstrap.WarnOnError)
```
**效果**：Proxy 失败只打印警告，不影响系统运行
**输出**：
```
[2/5] 初始化: Proxy模块 (优先级: 50)
⚠️ 警告: Proxy模块 (耗时: 15ms) - 连接代理服务器超时
```
### 3. 上下文数据共享
模块之间可以通过 Context 共享数据：
```go
// database/init.go - 存储数据库实例
func initDatabase(ctx *bootstrap.Context) error {
db, err := sql.Open("sqlite", "config.db")
if err != nil {
return err
}
// 存储到上下文
ctx.Set("database", db)
return nil
}
// trader/init.go - 获取数据库实例
func initTrader(ctx *bootstrap.Context) error {
// 从上下文获取数据库实例
db, ok := ctx.Get("database")
if !ok {
return fmt.Errorf("database 未初始化")
}
database := db.(*sql.DB)
// 使用 database 初始化 trader...
return nil
}
```
**安全获取**：
```go
// 使用 MustGet，不存在会 panic（适合必需的依赖）
db := ctx.MustGet("database").(*sql.DB)
```
### 4. 链式调用
支持流畅的链式调用：
```go
bootstrap.Register("Proxy", bootstrap.PriorityCore, initProxy).
EnabledIf(func(ctx *bootstrap.Context) bool {
return ctx.Config.Proxy != nil && ctx.Config.Proxy.Enabled
}).
OnError(bootstrap.WarnOnError)
```
### 5. 自定义错误策略
在 Run 时可以指定全局默认错误策略：
```go
// 所有钩子默认使用 ContinueOnError，除非钩子自己指定了 FailFast
err := bootstrap.RunWithPolicy(ctx, bootstrap.ContinueOnError)
```
## 完整示例
### 示例1：Database 模块
```go
// database/init.go
package database
import (
"database/sql"
"nofx/bootstrap"
)
func init() {
bootstrap.Register("Database", bootstrap.PriorityDatabase, initDatabase)
}
func initDatabase(ctx *bootstrap.Context) error {
db, err := sql.Open("sqlite", "config.db")
if err != nil {
return err
}
// 测试连接
if err := db.Ping(); err != nil {
return err
}
// 存储到上下文
ctx.Set("database", db)
return nil
}
```
### 示例2：Proxy 模块（条件初始化 + 警告策略）
```go
// proxy/init.go
package proxy
import (
"nofx/bootstrap"
"nofx/config"
)
func init() {
bootstrap.Register("Proxy", bootstrap.PriorityCore, initProxy).
EnabledIf(func(ctx *bootstrap.Context) bool {
return ctx.Config.Proxy != nil && ctx.Config.Proxy.Enabled
}).
OnError(bootstrap.WarnOnError) // Proxy 失败不影响系统
}
func initProxy(ctx *bootstrap.Context) error {
proxyConfig := convertConfig(ctx.Config.Proxy)
if err := InitGlobalProxyManager(proxyConfig); err != nil {
return err
}
ctx.Set("proxy_manager", GetGlobalProxyManager())
return nil
}
```
### 示例3：Trader 模块（依赖其他模块）
```go
// trader/init.go
package trader
import (
"nofx/bootstrap"
)
func init() {
bootstrap.Register("Trader", bootstrap.PriorityBusiness, initTrader)
}
func initTrader(ctx *bootstrap.Context) error {
// 获取依赖
db := ctx.MustGet("database").(*sql.DB)
// 可选依赖
var proxyMgr *proxy.ProxyManager
if pm, ok := ctx.Get("proxy_manager"); ok {
proxyMgr = pm.(*proxy.ProxyManager)
}
// 使用依赖初始化 trader...
return nil
}
```
## 调试和测试
### 查看已注册的钩子
```go
hooks := bootstrap.GetRegistered()
for _, hook := range hooks {
fmt.Printf("钩子: %s, 优先级: %d\n", hook.Name, hook.Priority)
}
```
### 清除钩子（用于测试）
```go
func TestMyModule(t *testing.T) {
// 清除之前注册的钩子
bootstrap.Clear()
// 注册测试钩子
bootstrap.Register("Test", 10, func(ctx *bootstrap.Context) error {
return nil
})
// 运行测试...
}
```
### 统计钩子数量
```go
count := bootstrap.Count()
fmt.Printf("已注册 %d 个初始化钩子\n", count)
```
## 错误处理最佳实践
### 1. 关键模块使用 FailFast
```go
// 数据库是关键依赖，失败必须停止
bootstrap.Register("Database", bootstrap.PriorityDatabase, initDatabase)
// 默认是 FailFast，无需显式设置
```
### 2. 可选模块使用 WarnOnError
```go
// Proxy 是可选的，失败可以使用直连
bootstrap.Register("Proxy", bootstrap.PriorityCore, initProxy).
OnError(bootstrap.WarnOnError)
```
### 3. 批量初始化使用 ContinueOnError
```go
// 批量加载插件，希望看到所有失败的插件
for _, plugin := range plugins {
bootstrap.Register(plugin.Name, 150, plugin.Init).
OnError(bootstrap.ContinueOnError)
}
```
## 常见问题
### Q1: 如何保证模块A在模块B之前初始化？
使用优先级控制：
```go
bootstrap.Register("ModuleA", 50, initA) // 先执行
bootstrap.Register("ModuleB", 100, initB) // 后执行
```
### Q2: 如何在初始化失败时获取详细信息？
钩子名称会自动包含在错误信息中：
```
Error: [Proxy模块] 初始化失败: 连接代理服务器超时
```
### Q3: 可以动态注册钩子吗？
可以，但建议在 `init()` 函数中注册：
```go
// 推荐：在 init() 中注册（包加载时自动执行）
func init() {
bootstrap.Register("MyModule", 100, initModule)
}
// 不推荐：在运行时注册（可能导致顺序问题）
func main() {
bootstrap.Register("MyModule", 100, initModule)
}
```
### Q4: 如何在钩子中访问命令行参数？
通过 Context 的 Data 字段传递：
```go
// main.go
ctx := bootstrap.NewContext(cfg)
ctx.Set("args", os.Args)
// module/init.go
func initModule(ctx *bootstrap.Context) error {
args := ctx.MustGet("args").([]string)
// 使用 args...
}
```
## 性能考虑
- 钩子注册是线程安全的，但注册本身有轻微的锁开销
- 建议在 `init()` 函数中注册，避免运行时动态注册
- 钩子执行是顺序的，不会并发执行
- 每个钩子的耗时会被记录并显示
## 许可证
本模块为 NOFX 项目内部模块，遵循项目整体许可证。

169
bootstrap/bootstrap.go Normal file
View File

@@ -0,0 +1,169 @@
package bootstrap
import (
"fmt"
"log"
"nofx/logger"
"sort"
"sync"
"time"
)
// Priority 初始化优先级常量
const (
PriorityInfrastructure = 10 // 基础设施（日志、配置等）
PriorityDatabase = 20 // 数据库连接
PriorityCore = 50 // 核心模块（Proxy、Market等）
PriorityBusiness = 100 // 业务模块（Trader、API等）
PriorityBackground = 200 // 后台任务
)
// ErrorPolicy 错误处理策略
type ErrorPolicy int
const (
// FailFast 遇到错误立即停止（默认）
FailFast ErrorPolicy = iota
// ContinueOnError 继续执行，收集所有错误
ContinueOnError
// WarnOnError 继续执行，只打印警告
WarnOnError
)
var (
hooks []Hook
hooksMu sync.Mutex
)
// Register 注册初始化钩子
// name: 模块名称（如 "Proxy", "Database"）
// priority: 优先级（建议使用常量：PriorityCore、PriorityBusiness等）
// fn: 初始化函数
func Register(name string, priority int, fn func(*Context) error) *HookBuilder {
hooksMu.Lock()
defer hooksMu.Unlock()
hook := Hook{
Name: name,
Priority: priority,
Func: fn,
Enabled: nil, // 默认启用
ErrorPolicy: FailFast,
}
hooks = append(hooks, hook)
return &HookBuilder{hook: &hooks[len(hooks)-1]}
}
// Run 执行所有已注册的钩子
func Run(ctx *Context) error {
return RunWithPolicy(ctx, FailFast)
}
// RunWithPolicy 使用指定的默认错误策略执行所有钩子
func RunWithPolicy(ctx *Context, defaultPolicy ErrorPolicy) error {
hooksMu.Lock()
hooksCopy := make([]Hook, len(hooks))
copy(hooksCopy, hooks)
hooksMu.Unlock()
if len(hooksCopy) == 0 {
log.Printf("⚠️ 没有注册任何初始化钩子")
return nil
}
// 按优先级排序
sort.Slice(hooksCopy, func(i, j int) bool {
return hooksCopy[i].Priority < hooksCopy[j].Priority
})
log.Printf("🔄 开始初始化 %d 个模块...", len(hooksCopy))
startTime := time.Now()
var errors []error
successCount := 0
skippedCount := 0
for i, hook := range hooksCopy {
// 检查是否启用
if hook.Enabled != nil && !hook.Enabled(ctx) {
log.Printf(" [%d/%d] 跳过: %s (条件未满足)",
i+1, len(hooksCopy), hook.Name)
skippedCount++
continue
}
log.Printf(" [%d/%d] 初始化: %s (优先级: %d)",
i+1, len(hooksCopy), hook.Name, hook.Priority)
hookStart := time.Now()
err := hook.Func(ctx)
elapsed := time.Since(hookStart)
if err != nil {
errMsg := fmt.Errorf("[%s] 初始化失败: %w", hook.Name, err)
// 根据错误策略处理
policy := hook.ErrorPolicy
if policy == FailFast && defaultPolicy != FailFast {
policy = defaultPolicy
}
switch policy {
case FailFast:
log.Printf(" ❌ 失败: %s (耗时: %v)", hook.Name, elapsed)
return errMsg
case ContinueOnError:
log.Printf(" ❌ 失败: %s (耗时: %v) - 继续执行", hook.Name, elapsed)
errors = append(errors, errMsg)
case WarnOnError:
log.Printf(" ⚠️ 警告: %s (耗时: %v) - %v", hook.Name, elapsed, err)
}
} else {
log.Printf(" ✓ 完成: %s (耗时: %v)", hook.Name, elapsed)
successCount++
}
}
totalElapsed := time.Since(startTime)
// 汇总结果
if len(errors) > 0 {
logger.Log.Warnf("⚠️ 初始化完成，但有 %d 个模块失败 (总耗时: %v)",
len(errors), totalElapsed)
log.Printf("📊 统计: 成功=%d, 失败=%d, 跳过=%d",
successCount, len(errors), skippedCount)
// 返回合并的错误
return fmt.Errorf("以下模块初始化失败: %v", errors)
}
log.Printf("✅ 所有模块初始化完成 (总耗时: %v)", totalElapsed)
log.Printf("📊 统计: 成功=%d, 跳过=%d", successCount, skippedCount)
return nil
}
// GetRegistered 获取已注册的钩子列表（用于调试）
func GetRegistered() []Hook {
hooksMu.Lock()
defer hooksMu.Unlock()
hooksCopy := make([]Hook, len(hooks))
copy(hooksCopy, hooks)
return hooksCopy
}
// Clear 清除所有钩子（用于测试）
func Clear() {
hooksMu.Lock()
defer hooksMu.Unlock()
hooks = nil
}
// Count 返回已注册的钩子数量
func Count() int {
hooksMu.Lock()
defer hooksMu.Unlock()
return len(hooks)
}

49
bootstrap/context.go Normal file
View File

@@ -0,0 +1,49 @@
package bootstrap
import (
"context"
"fmt"
"nofx/config"
"sync"
)
// Context 初始化上下文，用于在钩子之间传递数据
type Context struct {
Config *config.Config
Data map[string]interface{} // 存储模块之间共享的数据（如数据库实例）
ctx context.Context
mu sync.RWMutex
}
// NewContext 创建新的初始化上下文
func NewContext(cfg *config.Config) *Context {
return &Context{
Config: cfg,
Data: make(map[string]interface{}),
ctx: context.Background(),
}
}
// Set 存储数据到上下文
func (c *Context) Set(key string, value interface{}) {
c.mu.Lock()
defer c.mu.Unlock()
c.Data[key] = value
}
// Get 从上下文获取数据
func (c *Context) Get(key string) (interface{}, bool) {
c.mu.RLock()
defer c.mu.RUnlock()
val, ok := c.Data[key]
return val, ok
}
// MustGet 从上下文获取数据，不存在则 panic
func (c *Context) MustGet(key string) interface{} {
val, ok := c.Get(key)
if !ok {
panic(fmt.Sprintf("context key '%s' not found", key))
}
return val
}

27
bootstrap/hook_builder.go Normal file
View File

@@ -0,0 +1,27 @@
package bootstrap
// Hook 初始化钩子
type Hook struct {
Name string // 钩子名称（模块名）
Priority int // 优先级（越小越先执行）
Func func(*Context) error // 初始化函数
Enabled func(*Context) bool // 条件函数，返回 false 则跳过
ErrorPolicy ErrorPolicy // 错误处理策略
}
// HookBuilder 钩子构建器（用于链式调用）
type HookBuilder struct {
hook *Hook
}
// EnabledIf 设置条件函数（链式调用）
func (b *HookBuilder) EnabledIf(fn func(*Context) bool) *HookBuilder {
b.hook.Enabled = fn
return b
}
// OnError 设置错误处理策略（链式调用）
func (b *HookBuilder) OnError(policy ErrorPolicy) *HookBuilder {
b.hook.ErrorPolicy = policy
return b
}

22
bootstrap/init_hook.go Normal file
View File

@@ -0,0 +1,22 @@
package bootstrap
import "nofx/config"
type InitHook func(config *config.Config) error
var InitHooks []InitHook
// RegisterInitHook 注册初始化钩子
func RegisterInitHook(hook InitHook) {
InitHooks = append(InitHooks, hook)
}
// RunInitHooks 运行所有注册的初始化钩子
func RunInitHooks(c *config.Config) error {
for _, hookF := range InitHooks {
if err := hookF(c); err != nil {
return err
}
}
return nil
}

209
config/config.go
View File

@@ -3,47 +3,10 @@ package config
import (
"encoding/json"
"fmt"
"log"
"os"
"time"
)
// TraderConfig 单个trader的配置
type TraderConfig struct {
ID string `json:"id"`
Name string `json:"name"`
Enabled bool `json:"enabled"` // 是否启用该trader
AIModel string `json:"ai_model"` // "qwen" or "deepseek"
// 交易平台选择（二选一）
Exchange string `json:"exchange"` // "binance" or "hyperliquid"
// 币安配置
BinanceAPIKey string `json:"binance_api_key,omitempty"`
BinanceSecretKey string `json:"binance_secret_key,omitempty"`
// Hyperliquid配置
HyperliquidPrivateKey string `json:"hyperliquid_private_key,omitempty"`
HyperliquidWalletAddr string `json:"hyperliquid_wallet_addr,omitempty"`
HyperliquidTestnet bool `json:"hyperliquid_testnet,omitempty"`
// Aster配置
AsterUser string `json:"aster_user,omitempty"` // Aster主钱包地址
AsterSigner string `json:"aster_signer,omitempty"` // Aster API钱包地址
AsterPrivateKey string `json:"aster_private_key,omitempty"` // Aster API钱包私钥
// AI配置
QwenKey string `json:"qwen_key,omitempty"`
DeepSeekKey string `json:"deepseek_key,omitempty"`
// 自定义AI API配置（支持任何OpenAI格式的API）
CustomAPIURL string `json:"custom_api_url,omitempty"`
CustomAPIKey string `json:"custom_api_key,omitempty"`
CustomModelName string `json:"custom_model_name,omitempty"`
InitialBalance float64 `json:"initial_balance"`
ScanIntervalMinutes int `json:"scan_interval_minutes"`
}
// LeverageConfig 杠杆配置
type LeverageConfig struct {
BTCETHLeverage int `json:"btc_eth_leverage"` // BTC和ETH的杠杆倍数（主账户建议5-50，子账户≤5）
@@ -66,166 +29,40 @@ type TelegramConfig struct {
// Config 总配置
type Config struct {
Traders []TraderConfig `json:"traders"`
UseDefaultCoins bool `json:"use_default_coins"` // 是否使用默认主流币种列表
DefaultCoins []string `json:"default_coins"` // 默认主流币种池
BetaMode bool `json:"beta_mode"`
APIServerPort int `json:"api_server_port"`
UseDefaultCoins bool `json:"use_default_coins"`
DefaultCoins []string `json:"default_coins"`
CoinPoolAPIURL string `json:"coin_pool_api_url"`
OITopAPIURL string `json:"oi_top_api_url"`
MaxDailyLoss float64 `json:"max_daily_loss"`
MaxDrawdown float64 `json:"max_drawdown"`
StopTradingMinutes int `json:"stop_trading_minutes"`
Leverage LeverageConfig `json:"leverage"` // 杠杆配置
Log *LogConfig `json:"log"` // 日志配置（可选）
Proxy *ProxyConfig `json:"proxy"` // HTTP 代理配置（可选）
Leverage LeverageConfig `json:"leverage"`
JWTSecret string `json:"jwt_secret"`
DataKLineTime string `json:"data_k_line_time"`
Log *LogConfig `json:"log"` // 日志配置
}
// ProxyConfig HTTP 代理配置
type ProxyConfig struct {
Enabled bool `json:"enabled"` // 是否启用代理
Mode string `json:"mode"` // 模式: "single", "pool", "brightdata"
Timeout int `json:"timeout"` // 超时时间（秒）
ProxyURL string `json:"proxy_url"` // 单个代理地址
ProxyList []string `json:"proxy_list"` // 代理列表
BrightDataEndpoint string `json:"brightdata_endpoint"` // Bright Data接口地址
BrightDataToken string `json:"brightdata_token"` // Bright Data访问令牌
BrightDataZone string `json:"brightdata_zone"` // Bright Data区域
ProxyHost string `json:"proxy_host"` // 代理主机
ProxyUser string `json:"proxy_user"` // 代理用户名模板
ProxyPassword string `json:"proxy_password"` // 代理密码
RefreshInterval int `json:"refresh_interval"` // 刷新间隔（秒）
BlacklistTTL int `json:"blacklist_ttl"` // 黑名单TTL
}
// LoadConfig 从文件加载配置
func LoadConfig(filename string) (*Config, error) {
// 检查filename是否存在
if _, err := os.Stat(filename); os.IsNotExist(err) {
log.Printf("📄 %s不存在，使用默认配置", filename)
return &Config{}, nil
}
// 读取 filename
data, err := os.ReadFile(filename)
if err != nil {
return nil, fmt.Errorf("读取配置文件失败: %w", err)
return nil, fmt.Errorf("读取%s失败: %w", filename, err)
}
var config Config
if err := json.Unmarshal(data, &config); err != nil {
return nil, fmt.Errorf("解析配置文件失败: %w", err)
// 解析JSON
var configFile Config
if err := json.Unmarshal(data, &configFile); err != nil {
return nil, fmt.Errorf("解析%s失败: %w", filename, err)
}
// 设置默认值：确保使用默认币种列表
if !config.UseDefaultCoins {
config.UseDefaultCoins = true
}
// 设置默认币种池
if len(config.DefaultCoins) == 0 {
config.DefaultCoins = []string{
"BTCUSDT",
"ETHUSDT",
"SOLUSDT",
"BNBUSDT",
"XRPUSDT",
"DOGEUSDT",
"ADAUSDT",
"HYPEUSDT",
}
}
// 验证配置
if err := config.Validate(); err != nil {
return nil, fmt.Errorf("配置验证失败: %w", err)
}
return &config, nil
}
// Validate 验证配置有效性
func (c *Config) Validate() error {
if len(c.Traders) == 0 {
return fmt.Errorf("至少需要配置一个trader")
}
traderIDs := make(map[string]bool)
for i, trader := range c.Traders {
if trader.ID == "" {
return fmt.Errorf("trader[%d]: ID不能为空", i)
}
if traderIDs[trader.ID] {
return fmt.Errorf("trader[%d]: ID '%s' 重复", i, trader.ID)
}
traderIDs[trader.ID] = true
if trader.Name == "" {
return fmt.Errorf("trader[%d]: Name不能为空", i)
}
if trader.AIModel != "qwen" && trader.AIModel != "deepseek" && trader.AIModel != "custom" {
return fmt.Errorf("trader[%d]: ai_model必须是 'qwen', 'deepseek' 或 'custom'", i)
}
// 验证交易平台配置
if trader.Exchange == "" {
trader.Exchange = "binance" // 默认使用币安
}
if trader.Exchange != "binance" && trader.Exchange != "hyperliquid" && trader.Exchange != "aster" {
return fmt.Errorf("trader[%d]: exchange必须是 'binance', 'hyperliquid' 或 'aster'", i)
}
// 根据平台验证对应的密钥
if trader.Exchange == "binance" {
if trader.BinanceAPIKey == "" || trader.BinanceSecretKey == "" {
return fmt.Errorf("trader[%d]: 使用币安时必须配置binance_api_key和binance_secret_key", i)
}
} else if trader.Exchange == "hyperliquid" {
if trader.HyperliquidPrivateKey == "" {
return fmt.Errorf("trader[%d]: 使用Hyperliquid时必须配置hyperliquid_private_key", i)
}
} else if trader.Exchange == "aster" {
if trader.AsterUser == "" || trader.AsterSigner == "" || trader.AsterPrivateKey == "" {
return fmt.Errorf("trader[%d]: 使用Aster时必须配置aster_user, aster_signer和aster_private_key", i)
}
}
if trader.AIModel == "qwen" && trader.QwenKey == "" {
return fmt.Errorf("trader[%d]: 使用Qwen时必须配置qwen_key", i)
}
if trader.AIModel == "deepseek" && trader.DeepSeekKey == "" {
return fmt.Errorf("trader[%d]: 使用DeepSeek时必须配置deepseek_key", i)
}
if trader.AIModel == "custom" {
if trader.CustomAPIURL == "" {
return fmt.Errorf("trader[%d]: 使用自定义API时必须配置custom_api_url", i)
}
if trader.CustomAPIKey == "" {
return fmt.Errorf("trader[%d]: 使用自定义API时必须配置custom_api_key", i)
}
if trader.CustomModelName == "" {
return fmt.Errorf("trader[%d]: 使用自定义API时必须配置custom_model_name", i)
}
}
if trader.InitialBalance <= 0 {
return fmt.Errorf("trader[%d]: initial_balance必须大于0", i)
}
if trader.ScanIntervalMinutes <= 0 {
trader.ScanIntervalMinutes = 3 // 默认3分钟
}
}
if c.APIServerPort <= 0 {
c.APIServerPort = 8080 // 默认8080端口
}
// 设置杠杆默认值（适配币安子账户限制，最大5倍）
if c.Leverage.BTCETHLeverage <= 0 {
c.Leverage.BTCETHLeverage = 5 // 默认5倍（安全值，适配子账户）
}
if c.Leverage.BTCETHLeverage > 5 {
fmt.Printf("⚠️ 警告: BTC/ETH杠杆设置为%dx，如果使用子账户可能会失败（子账户限制≤5x）\n", c.Leverage.BTCETHLeverage)
}
if c.Leverage.AltcoinLeverage <= 0 {
c.Leverage.AltcoinLeverage = 5 // 默认5倍（安全值，适配子账户）
}
if c.Leverage.AltcoinLeverage > 5 {
fmt.Printf("⚠️ 警告: 山寨币杠杆设置为%dx，如果使用子账户可能会失败（子账户限制≤5x）\n", c.Leverage.AltcoinLeverage)
}
return nil
}
// GetScanInterval 获取扫描间隔
func (tc *TraderConfig) GetScanInterval() time.Duration {
return time.Duration(tc.ScanIntervalMinutes) * time.Minute
return &configFile, nil
}

1343
config/database.go
View File

File diff suppressed because it is too large Load Diff

799
config/database_test.go Normal file
View File

@@ -0,0 +1,799 @@
package config
import (
"nofx/crypto"
"os"
"testing"
"time"
)
// TestUpdateExchange_EmptyValuesShouldNotOverwrite 测试空值不应覆盖现有数据
// 这是 Bug 的核心：当前实现会用空字符串覆盖现有的私钥
func TestUpdateExchange_EmptyValuesShouldNotOverwrite(t *testing.T) {
// 准备测试数据库
db, cleanup := setupTestDB(t)
defer cleanup()
userID := "test-user-001"
// 步骤 1: 创建初始配置（包含私钥）
initialAPIKey := "initial-api-key-12345"
initialSecretKey := "initial-secret-key-67890"
err := db.UpdateExchange(
userID,
"hyperliquid",
true, // enabled
initialAPIKey,
initialSecretKey,
false, // testnet
"0xWalletAddress",
"",
"",
"",
)
if err != nil {
t.Fatalf("初始化失败: %v", err)
}
// 步骤 2: 验证初始数据已保存
exchanges, err := db.GetExchanges(userID)
if err != nil {
t.Fatalf("获取配置失败: %v", err)
}
if len(exchanges) == 0 {
t.Fatal("未找到配置")
}
// 解密后应该能看到原始值
if exchanges[0].APIKey != initialAPIKey {
t.Errorf("初始 APIKey 不正确，期望 %s，实际 %s", initialAPIKey, exchanges[0].APIKey)
}
// 步骤 3: 用空值更新（模拟前端发送空值的场景）
// 🐛 Bug 重现：这应该 NOT 覆盖现有的私钥，但当前实现会覆盖
err = db.UpdateExchange(
userID,
"hyperliquid",
false, // 只改变 enabled 状态
"", // 空 apiKey - 不应该覆盖
"", // 空 secretKey - 不应该覆盖
true, // 改变 testnet 状态
"0xWalletAddress",
"",
"",
"", // 空 aster_private_key - 不应该覆盖
)
if err != nil {
t.Fatalf("更新失败: %v", err)
}
// 步骤 4: 验证私钥没有被空值覆盖
exchanges, err = db.GetExchanges(userID)
if err != nil {
t.Fatalf("获取更新后配置失败: %v", err)
}
// 🎯 关键断言：私钥应该保持不变
if exchanges[0].APIKey != initialAPIKey {
t.Errorf("❌ Bug 确认：APIKey 被空值覆盖了！期望 %s，实际 %s", initialAPIKey, exchanges[0].APIKey)
}
if exchanges[0].SecretKey != initialSecretKey {
t.Errorf("❌ Bug 确认：SecretKey 被空值覆盖了！期望 %s，实际 %s", initialSecretKey, exchanges[0].SecretKey)
}
// 验证非敏感字段正常更新
if exchanges[0].Enabled {
t.Error("enabled 应该被更新为 false")
}
if !exchanges[0].Testnet {
t.Error("testnet 应该被更新为 true")
}
}
// TestUpdateExchange_AsterEmptyValuesShouldNotOverwrite 测试 Aster 私钥不被空值覆盖
func TestUpdateExchange_AsterEmptyValuesShouldNotOverwrite(t *testing.T) {
db, cleanup := setupTestDB(t)
defer cleanup()
userID := "test-user-002"
// 步骤 1: 创建 Aster 配置
initialAsterKey := "aster-private-key-xyz123"
err := db.UpdateExchange(
userID,
"aster",
true,
"",
"",
false,
"",
"0xAsterUser",
"0xAsterSigner",
initialAsterKey,
)
if err != nil {
t.Fatalf("初始化 Aster 失败: %v", err)
}
// 步骤 2: 用空值更新
err = db.UpdateExchange(
userID,
"aster",
false, // 只改 enabled
"",
"",
false,
"",
"0xAsterUser",
"0xAsterSigner",
"", // 空 aster_private_key
)
if err != nil {
t.Fatalf("更新失败: %v", err)
}
// 步骤 3: 验证 aster_private_key 没有被覆盖
exchanges, err := db.GetExchanges(userID)
if err != nil {
t.Fatalf("获取配置失败: %v", err)
}
if exchanges[0].AsterPrivateKey != initialAsterKey {
t.Errorf("❌ Bug 确认：AsterPrivateKey 被空值覆盖了！期望 %s，实际 %s", initialAsterKey, exchanges[0].AsterPrivateKey)
}
}
// TestUpdateExchange_NonEmptyValuesShouldUpdate 测试非空值应该正常更新
func TestUpdateExchange_NonEmptyValuesShouldUpdate(t *testing.T) {
db, cleanup := setupTestDB(t)
defer cleanup()
userID := "test-user-003"
// 步骤 1: 创建初始配置
err := db.UpdateExchange(
userID,
"hyperliquid",
true,
"old-api-key",
"old-secret-key",
false,
"0xOldWallet",
"",
"",
"",
)
if err != nil {
t.Fatalf("初始化失败: %v", err)
}
// 步骤 2: 用非空值更新
newAPIKey := "new-api-key-456"
newSecretKey := "new-secret-key-789"
err = db.UpdateExchange(
userID,
"hyperliquid",
true,
newAPIKey,
newSecretKey,
false,
"0xNewWallet",
"",
"",
"",
)
if err != nil {
t.Fatalf("更新失败: %v", err)
}
// 步骤 3: 验证新值已更新
exchanges, err := db.GetExchanges(userID)
if err != nil {
t.Fatalf("获取配置失败: %v", err)
}
if exchanges[0].APIKey != newAPIKey {
t.Errorf("APIKey 未更新，期望 %s，实际 %s", newAPIKey, exchanges[0].APIKey)
}
if exchanges[0].SecretKey != newSecretKey {
t.Errorf("SecretKey 未更新，期望 %s，实际 %s", newSecretKey, exchanges[0].SecretKey)
}
if exchanges[0].HyperliquidWalletAddr != "0xNewWallet" {
t.Errorf("WalletAddr 未更新")
}
}
// TestUpdateExchange_PartialUpdateShouldWork 测试部分字段更新
func TestUpdateExchange_PartialUpdateShouldWork(t *testing.T) {
db, cleanup := setupTestDB(t)
defer cleanup()
userID := "test-user-005"
// 创建初始配置
err := db.UpdateExchange(
userID,
"hyperliquid",
true,
"api-key-123",
"secret-key-456",
false,
"0xWallet1",
"",
"",
"",
)
if err != nil {
t.Fatalf("初始化失败: %v", err)
}
// 只更新 enabled 和 testnet，私钥留空
err = db.UpdateExchange(
userID,
"hyperliquid",
false,
"", // 留空
"", // 留空
true,
"0xWallet2",
"",
"",
"",
)
if err != nil {
t.Fatalf("部分更新失败: %v", err)
}
// 验证
exchanges, err := db.GetExchanges(userID)
if err != nil {
t.Fatalf("获取配置失败: %v", err)
}
// 私钥应该保持不变
if exchanges[0].APIKey != "api-key-123" {
t.Errorf("APIKey 不应改变，期望 api-key-123，实际 %s", exchanges[0].APIKey)
}
if exchanges[0].SecretKey != "secret-key-456" {
t.Errorf("SecretKey 不应改变，期望 secret-key-456，实际 %s", exchanges[0].SecretKey)
}
// 其他字段应该更新
if exchanges[0].Enabled {
t.Error("enabled 应该更新为 false")
}
if !exchanges[0].Testnet {
t.Error("testnet 应该更新为 true")
}
if exchanges[0].HyperliquidWalletAddr != "0xWallet2" {
t.Error("wallet 地址应该更新")
}
}
// TestUpdateExchange_MultipleExchangeTypes 测试不同交易所类型
func TestUpdateExchange_MultipleExchangeTypes(t *testing.T) {
db, cleanup := setupTestDB(t)
defer cleanup()
userID := "test-user-006"
testCases := []struct {
exchangeID string
name string
typ string
}{
{"binance", "Binance Futures", "cex"},
{"hyperliquid", "Hyperliquid", "dex"},
{"aster", "Aster DEX", "dex"},
{"unknown-exchange", "unknown-exchange Exchange", "cex"},
}
for _, tc := range testCases {
t.Run(tc.exchangeID, func(t *testing.T) {
err := db.UpdateExchange(
userID,
tc.exchangeID,
true,
"api-key-"+tc.exchangeID,
"secret-key-"+tc.exchangeID,
false,
"",
"",
"",
"",
)
if err != nil {
t.Fatalf("创建 %s 失败: %v", tc.exchangeID, err)
}
// 验证创建成功
exchanges, err := db.GetExchanges(userID)
if err != nil {
t.Fatalf("获取配置失败: %v", err)
}
found := false
for _, ex := range exchanges {
if ex.ID == tc.exchangeID {
found = true
if ex.Name != tc.name {
t.Errorf("交易所名称不正确，期望 %s，实际 %s", tc.name, ex.Name)
}
if ex.Type != tc.typ {
t.Errorf("交易所类型不正确，期望 %s，实际 %s", tc.typ, ex.Type)
}
if ex.APIKey != "api-key-"+tc.exchangeID {
t.Errorf("APIKey 不正确")
}
break
}
}
if !found {
t.Errorf("未找到交易所 %s", tc.exchangeID)
}
})
}
}
// TestUpdateExchange_MixedSensitiveFields 测试混合更新敏感和非敏感字段
func TestUpdateExchange_MixedSensitiveFields(t *testing.T) {
db, cleanup := setupTestDB(t)
defer cleanup()
userID := "test-user-007"
// 创建初始配置
err := db.UpdateExchange(
userID,
"hyperliquid",
true,
"old-api-key",
"old-secret-key",
false,
"0xOldWallet",
"",
"",
"",
)
if err != nil {
t.Fatalf("初始化失败: %v", err)
}
// 场景1: 只更新 apiKey，secretKey 留空
err = db.UpdateExchange(
userID,
"hyperliquid",
false,
"new-api-key",
"", // 留空
true,
"0xNewWallet",
"",
"",
"",
)
if err != nil {
t.Fatalf("更新1失败: %v", err)
}
exchanges, _ := db.GetExchanges(userID)
if exchanges[0].APIKey != "new-api-key" {
t.Error("APIKey 应该更新")
}
if exchanges[0].SecretKey != "old-secret-key" {
t.Error("SecretKey 应该保持不变")
}
// 场景2: 只更新 secretKey，apiKey 留空
err = db.UpdateExchange(
userID,
"hyperliquid",
true,
"", // 留空
"new-secret-key",
false,
"0xFinalWallet",
"",
"",
"",
)
if err != nil {
t.Fatalf("更新2失败: %v", err)
}
exchanges, _ = db.GetExchanges(userID)
if exchanges[0].APIKey != "new-api-key" {
t.Error("APIKey 应该保持不变")
}
if exchanges[0].SecretKey != "new-secret-key" {
t.Error("SecretKey 应该更新")
}
if exchanges[0].Enabled != true {
t.Error("Enabled 应该更新为 true")
}
if exchanges[0].HyperliquidWalletAddr != "0xFinalWallet" {
t.Error("WalletAddr 应该更新")
}
}
// TestUpdateExchange_OnlyNonSensitiveFields 测试只更新非敏感字段
func TestUpdateExchange_OnlyNonSensitiveFields(t *testing.T) {
db, cleanup := setupTestDB(t)
defer cleanup()
userID := "test-user-008"
// 创建初始配置（包含所有私钥）
err := db.UpdateExchange(
userID,
"aster",
true,
"binance-api",
"binance-secret",
false,
"",
"0xUser1",
"0xSigner1",
"aster-private-key-1",
)
if err != nil {
t.Fatalf("初始化失败: %v", err)
}
// 只更新非敏感字段（所有私钥字段留空）
err = db.UpdateExchange(
userID,
"aster",
false,
"",
"",
true,
"",
"0xUser2",
"0xSigner2",
"",
)
if err != nil {
t.Fatalf("更新失败: %v", err)
}
// 验证所有私钥保持不变
exchanges, _ := db.GetExchanges(userID)
if exchanges[0].APIKey != "binance-api" {
t.Errorf("APIKey 应该保持不变，实际 %s", exchanges[0].APIKey)
}
if exchanges[0].SecretKey != "binance-secret" {
t.Errorf("SecretKey 应该保持不变，实际 %s", exchanges[0].SecretKey)
}
if exchanges[0].AsterPrivateKey != "aster-private-key-1" {
t.Errorf("AsterPrivateKey 应该保持不变，实际 %s", exchanges[0].AsterPrivateKey)
}
// 验证非敏感字段已更新
if exchanges[0].Enabled != false {
t.Error("Enabled 应该更新为 false")
}
if exchanges[0].Testnet != true {
t.Error("Testnet 应该更新为 true")
}
if exchanges[0].AsterUser != "0xUser2" {
t.Error("AsterUser 应该更新")
}
if exchanges[0].AsterSigner != "0xSigner2" {
t.Error("AsterSigner 应该更新")
}
}
// TestUpdateExchange_AllSensitiveFieldsUpdate 测试同时更新所有敏感字段
func TestUpdateExchange_AllSensitiveFieldsUpdate(t *testing.T) {
db, cleanup := setupTestDB(t)
defer cleanup()
userID := "test-user-009"
// 创建初始配置
err := db.UpdateExchange(
userID,
"binance",
true,
"old-api",
"old-secret",
false,
"",
"",
"",
"old-aster-key",
)
if err != nil {
t.Fatalf("初始化失败: %v", err)
}
// 同时更新所有敏感字段
err = db.UpdateExchange(
userID,
"binance",
false,
"new-api",
"new-secret",
true,
"0xWallet",
"0xUser",
"0xSigner",
"new-aster-key",
)
if err != nil {
t.Fatalf("更新失败: %v", err)
}
// 验证所有字段都更新了
exchanges, _ := db.GetExchanges(userID)
if exchanges[0].APIKey != "new-api" {
t.Error("APIKey 应该更新")
}
if exchanges[0].SecretKey != "new-secret" {
t.Error("SecretKey 应该更新")
}
if exchanges[0].AsterPrivateKey != "new-aster-key" {
t.Error("AsterPrivateKey 应该更新")
}
if !exchanges[0].Testnet {
t.Error("Testnet 应该更新为 true")
}
}
// setupTestDB 创建测试数据库
func setupTestDB(t *testing.T) (*Database, func()) {
// 创建临时数据库文件
tmpFile := t.TempDir() + "/test.db"
db, err := NewDatabase(tmpFile)
if err != nil {
t.Fatalf("创建测试数据库失败: %v", err)
}
// 创建测试用户
testUsers := []string{"test-user-001", "test-user-002", "test-user-003", "test-user-004", "test-user-005", "test-user-006", "test-user-007", "test-user-008", "test-user-009"}
for _, userID := range testUsers {
user := &User{
ID: userID,
Email: userID + "@test.com",
PasswordHash: "hash",
OTPSecret: "",
OTPVerified: false,
}
_ = db.CreateUser(user)
}
// 设置加密服务（用于测试加密功能）
// 创建临时 RSA 密钥
rsaKeyPath := t.TempDir() + "/test_rsa_key"
cryptoService, err := crypto.NewCryptoService(rsaKeyPath)
if err != nil {
// 如果创建失败，继续测试但不使用加密
t.Logf("警告：无法创建加密服务，将在无加密模式下测试: %v", err)
} else {
db.SetCryptoService(cryptoService)
}
cleanup := func() {
db.Close()
os.RemoveAll(tmpFile)
os.RemoveAll(rsaKeyPath)
}
return db, cleanup
}
// TestWALModeEnabled 测试 WAL 模式是否启用
// TDD: 这个测试应该失败，因为当前代码没有启用 WAL 模式
func TestWALModeEnabled(t *testing.T) {
db, cleanup := setupTestDB(t)
defer cleanup()
// 查询当前的 journal_mode
var journalMode string
err := db.db.QueryRow("PRAGMA journal_mode").Scan(&journalMode)
if err != nil {
t.Fatalf("查询 journal_mode 失败: %v", err)
}
// 期望是 WAL 模式
if journalMode != "wal" {
t.Errorf("期望 journal_mode=wal，实际是 %s", journalMode)
}
}
// TestSynchronousMode 测试 synchronous 模式设置
// TDD: 验证数据持久性设置
func TestSynchronousMode(t *testing.T) {
db, cleanup := setupTestDB(t)
defer cleanup()
// 查询 synchronous 设置
var synchronous int
err := db.db.QueryRow("PRAGMA synchronous").Scan(&synchronous)
if err != nil {
t.Fatalf("查询 synchronous 失败: %v", err)
}
// 期望是 FULL (2) 以确保数据持久性
if synchronous != 2 {
t.Errorf("期望 synchronous=2 (FULL)，实际是 %d", synchronous)
}
}
// TestDataPersistenceAcrossReopen 测试数据在数据库关闭并重新打开后是否持久化
// TDD: 模拟 Docker restart 场景
func TestDataPersistenceAcrossReopen(t *testing.T) {
// 创建临时数据库文件
tmpFile, err := os.CreateTemp("", "test_persistence_*.db")
if err != nil {
t.Fatalf("创建临时文件失败: %v", err)
}
tmpFile.Close()
dbPath := tmpFile.Name()
defer os.Remove(dbPath)
// 设置加密服务
rsaKeyPath := "test_rsa_key.pem"
cryptoService, err := crypto.NewCryptoService(rsaKeyPath)
if err != nil {
t.Fatalf("初始化加密服务失败: %v", err)
}
defer os.RemoveAll(rsaKeyPath)
userID := "test-user-persistence"
testAPIKey := "test-api-key-should-persist"
testSecretKey := "test-secret-key-should-persist"
// 第一次打开数据库并写入数据
{
db, err := NewDatabase(dbPath)
if err != nil {
t.Fatalf("第一次创建数据库失败: %v", err)
}
db.SetCryptoService(cryptoService)
// 写入交易所配置
err = db.UpdateExchange(
userID,
"binance",
true,
testAPIKey,
testSecretKey,
false,
"",
"",
"",
"",
)
if err != nil {
t.Fatalf("写入数据失败: %v", err)
}
// 模拟正常关闭
if err := db.Close(); err != nil {
t.Fatalf("关闭数据库失败: %v", err)
}
}
// 第二次打开数据库并验证数据是否还在
{
db, err := NewDatabase(dbPath)
if err != nil {
t.Fatalf("第二次打开数据库失败: %v", err)
}
db.SetCryptoService(cryptoService)
defer db.Close()
// 读取数据
exchanges, err := db.GetExchanges(userID)
if err != nil {
t.Fatalf("读取数据失败: %v", err)
}
if len(exchanges) == 0 {
t.Fatal("数据丢失：没有找到任何交易所配置")
}
// 验证数据完整性
found := false
for _, ex := range exchanges {
if ex.ID == "binance" {
found = true
if ex.APIKey != testAPIKey {
t.Errorf("API Key 丢失或损坏，期望 %s，实际 %s", testAPIKey, ex.APIKey)
}
if ex.SecretKey != testSecretKey {
t.Errorf("Secret Key 丢失或损坏，期望 %s，实际 %s", testSecretKey, ex.SecretKey)
}
}
}
if !found {
t.Error("数据丢失：找不到 binance 配置")
}
}
}
// TestConcurrentWritesWithWAL 测试 WAL 模式下的并发写入
// TDD: WAL 模式应该支持更好的并发性能
func TestConcurrentWritesWithWAL(t *testing.T) {
db, cleanup := setupTestDB(t)
defer cleanup()
// 这个测试验证多个并发写入可以成功
// WAL 模式下并发性能更好,但 SQLite 仍然可能出现短暂的锁
done := make(chan bool, 2)
errors := make(chan error, 10)
// 并发写入1
go func() {
for i := 0; i < 3; i++ {
err := db.UpdateExchange(
"user1",
"binance",
true,
"key1",
"secret1",
false,
"",
"",
"",
"",
)
if err != nil {
errors <- err
}
// 小延迟减少锁冲突
time.Sleep(10 * time.Millisecond)
}
done <- true
}()
// 并发写入2
go func() {
for i := 0; i < 3; i++ {
err := db.UpdateExchange(
"user2",
"hyperliquid",
true,
"key2",
"secret2",
false,
"0xWallet",
"",
"",
"",
)
if err != nil {
errors <- err
}
// 小延迟减少锁冲突
time.Sleep(10 * time.Millisecond)
}
done <- true
}()
// 等待两个 goroutine 完成
<-done
<-done
close(errors)
// 检查是否有错误
errorCount := 0
for err := range errors {
t.Logf("并发写入错误: %v", err)
errorCount++
}
// WAL 模式下应该能处理并发,但可能有少量锁错误
// 我们允许最多 2 个错误
if errorCount > 2 {
t.Errorf("并发写入失败次数过多: %d", errorCount)
}
}

9
config/test_rsa_key.pem.pub Normal file
View File

@@ -0,0 +1,9 @@
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4Y666RzY5LLi6PiYL+vC
7+fcr122Fd8BC7IdqUSYKQ33Nsi9J7J5fDgcMf7ZAnIBpxMV7+e1KEoiwtGmxwHj
mYo0ZV0E6JXdiK26S052+Shquri0IXkwGFraDuNKqmGrj6vZuXtq2L2gdSyZCxrI
veN9g6LxBvLBP1Rx7UEmZeyokRYvChcxAQXuS/0br44BOHGtwAElk6AGLISz55AG
oM40b3ktiza+8THKMz3GiylQQYpBltbM3yAXPlnXJ2MtUZiaHNhEQI4++PMvEErN
Izm8cIgcvUAXJ5vBfa4kD0kSgBJFuEQ2im3qcWTuEPRKztEeJDY7XAVHc1Xy6d4N
vQIDAQAB
-----END PUBLIC KEY-----

373
crypto/encryption.go Normal file
View File

@@ -0,0 +1,373 @@
package crypto
import (
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"crypto/rsa"
"crypto/sha256"
"crypto/x509"
"encoding/base64"
"encoding/binary"
"encoding/pem"
"errors"
"fmt"
"io"
"log"
"os"
"sync"
)
// EncryptionManager 加密管理器（單例模式）
type EncryptionManager struct {
privateKey *rsa.PrivateKey
publicKeyPEM string
masterKey []byte // 用於數據庫加密的主密鑰
mu sync.RWMutex
}
var (
instance *EncryptionManager
once sync.Once
)
// GetEncryptionManager 獲取加密管理器實例
func GetEncryptionManager() (*EncryptionManager, error) {
var initErr error
once.Do(func() {
instance, initErr = newEncryptionManager()
})
return instance, initErr
}
// newEncryptionManager 初始化加密管理器
func newEncryptionManager() (*EncryptionManager, error) {
em := &EncryptionManager{}
// 1. 加載或生成 RSA 密鑰對
if err := em.loadOrGenerateRSAKeyPair(); err != nil {
return nil, fmt.Errorf("初始化 RSA 密鑰失敗: %w", err)
}
// 2. 加載或生成數據庫主密鑰
if err := em.loadOrGenerateMasterKey(); err != nil {
return nil, fmt.Errorf("初始化主密鑰失敗: %w", err)
}
log.Println("🔐 加密管理器初始化成功")
return em, nil
}
// ==================== RSA 密鑰管理 ====================
const (
rsaKeySize = 4096
rsaPrivateKeyFile = ".secrets/rsa_private.pem"
rsaPublicKeyFile = ".secrets/rsa_public.pem"
masterKeyFile = ".secrets/master.key"
)
// loadOrGenerateRSAKeyPair 加載或生成 RSA 密鑰對
func (em *EncryptionManager) loadOrGenerateRSAKeyPair() error {
// 確保 .secrets 目錄存在
if err := os.MkdirAll(".secrets", 0700); err != nil {
return err
}
// 嘗試加載現有密鑰
if _, err := os.Stat(rsaPrivateKeyFile); err == nil {
return em.loadRSAKeyPair()
}
// 生成新密鑰對
log.Println("🔑 生成新的 RSA-4096 密鑰對...")
privateKey, err := rsa.GenerateKey(rand.Reader, rsaKeySize)
if err != nil {
return err
}
em.privateKey = privateKey
// 保存私鑰
privateKeyBytes := x509.MarshalPKCS1PrivateKey(privateKey)
privateKeyPEM := pem.EncodeToMemory(&pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: privateKeyBytes,
})
if err := os.WriteFile(rsaPrivateKeyFile, privateKeyPEM, 0600); err != nil {
return err
}
// 保存公鑰
publicKeyBytes, err := x509.MarshalPKIXPublicKey(&privateKey.PublicKey)
if err != nil {
return err
}
publicKeyPEM := pem.EncodeToMemory(&pem.Block{
Type: "PUBLIC KEY",
Bytes: publicKeyBytes,
})
if err := os.WriteFile(rsaPublicKeyFile, publicKeyPEM, 0644); err != nil {
return err
}
em.publicKeyPEM = string(publicKeyPEM)
log.Println("✅ RSA 密鑰對已生成並保存")
return nil
}
// loadRSAKeyPair 加載 RSA 密鑰對
func (em *EncryptionManager) loadRSAKeyPair() error {
// 加載私鑰
privateKeyPEM, err := os.ReadFile(rsaPrivateKeyFile)
if err != nil {
return err
}
block, _ := pem.Decode(privateKeyPEM)
if block == nil || block.Type != "RSA PRIVATE KEY" {
return errors.New("無效的私鑰 PEM 格式")
}
privateKey, err := x509.ParsePKCS1PrivateKey(block.Bytes)
if err != nil {
return err
}
em.privateKey = privateKey
// 加載公鑰
publicKeyPEM, err := os.ReadFile(rsaPublicKeyFile)
if err != nil {
return err
}
em.publicKeyPEM = string(publicKeyPEM)
log.Println("✅ RSA 密鑰對已加載")
return nil
}
// GetPublicKeyPEM 獲取公鑰 (PEM 格式)
func (em *EncryptionManager) GetPublicKeyPEM() string {
em.mu.RLock()
defer em.mu.RUnlock()
return em.publicKeyPEM
}
// ==================== 混合解密 (RSA + AES) ====================
// DecryptWithPrivateKey 使用私鑰解密數據
// 數據格式: [加密的 AES 密鑰長度(4字節)] + [加密的 AES 密鑰] + [IV(12字節)] + [加密數據]
func (em *EncryptionManager) DecryptWithPrivateKey(encryptedBase64 string) (string, error) {
em.mu.RLock()
defer em.mu.RUnlock()
// Base64 解碼
encryptedData, err := base64.StdEncoding.DecodeString(encryptedBase64)
if err != nil {
return "", fmt.Errorf("Base64 解碼失敗: %w", err)
}
if len(encryptedData) < 4+256+12 { // 最小長度檢查
return "", errors.New("加密數據長度不足")
}
// 1. 讀取加密的 AES 密鑰長度
aesKeyLen := binary.BigEndian.Uint32(encryptedData[:4])
if aesKeyLen > 1024 { // 防止過大的長度值
return "", errors.New("無效的 AES 密鑰長度")
}
offset := 4
// 2. 提取加密的 AES 密鑰
encryptedAESKey := encryptedData[offset : offset+int(aesKeyLen)]
offset += int(aesKeyLen)
// 3. 使用 RSA 私鑰解密 AES 密鑰
aesKey, err := rsa.DecryptOAEP(sha256.New(), rand.Reader, em.privateKey, encryptedAESKey, nil)
if err != nil {
return "", fmt.Errorf("RSA 解密失敗: %w", err)
}
// 4. 提取 IV
iv := encryptedData[offset : offset+12]
offset += 12
// 5. 提取加密數據
ciphertext := encryptedData[offset:]
// 6. 使用 AES-GCM 解密
block, err := aes.NewCipher(aesKey)
if err != nil {
return "", err
}
aesGCM, err := cipher.NewGCM(block)
if err != nil {
return "", err
}
plaintext, err := aesGCM.Open(nil, iv, ciphertext, nil)
if err != nil {
return "", fmt.Errorf("AES 解密失敗: %w", err)
}
// 清除敏感數據
for i := range aesKey {
aesKey[i] = 0
}
return string(plaintext), nil
}
// ==================== 數據庫加密 (AES-256-GCM) ====================
// loadOrGenerateMasterKey 加載或生成數據庫主密鑰
func (em *EncryptionManager) loadOrGenerateMasterKey() error {
// 優先從環境變數加載
if envKey := os.Getenv("NOFX_MASTER_KEY"); envKey != "" {
decoded, err := base64.StdEncoding.DecodeString(envKey)
if err == nil && len(decoded) == 32 {
em.masterKey = decoded
log.Println("✅ 從環境變數加載主密鑰")
return nil
}
log.Println("⚠️ 環境變數中的主密鑰無效，使用文件密鑰")
}
// 嘗試從文件加載
if _, err := os.Stat(masterKeyFile); err == nil {
keyBytes, err := os.ReadFile(masterKeyFile)
if err != nil {
return err
}
decoded, err := base64.StdEncoding.DecodeString(string(keyBytes))
if err != nil || len(decoded) != 32 {
return errors.New("主密鑰文件損壞")
}
em.masterKey = decoded
log.Println("✅ 從文件加載主密鑰")
return nil
}
// 生成新主密鑰
log.Println("🔑 生成新的數據庫主密鑰 (AES-256)...")
masterKey := make([]byte, 32)
if _, err := io.ReadFull(rand.Reader, masterKey); err != nil {
return err
}
em.masterKey = masterKey
// 保存到文件
encoded := base64.StdEncoding.EncodeToString(masterKey)
if err := os.WriteFile(masterKeyFile, []byte(encoded), 0600); err != nil {
return err
}
log.Println("✅ 主密鑰已生成並保存")
log.Printf("📁 主密鑰文件位置: %s (權限: 0600)", masterKeyFile)
log.Println("🔐 生產環境請設置環境變數: NOFX_MASTER_KEY=<從文件讀取>")
log.Println("⚠️ 請妥善保管 .secrets 目錄，切勿將密鑰提交到版本控制系統")
return nil
}
// EncryptForDatabase 使用主密鑰加密數據（用於數據庫存儲）
func (em *EncryptionManager) EncryptForDatabase(plaintext string) (string, error) {
em.mu.RLock()
defer em.mu.RUnlock()
block, err := aes.NewCipher(em.masterKey)
if err != nil {
return "", err
}
aesGCM, err := cipher.NewGCM(block)
if err != nil {
return "", err
}
nonce := make([]byte, aesGCM.NonceSize())
if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
return "", err
}
ciphertext := aesGCM.Seal(nonce, nonce, []byte(plaintext), nil)
return base64.StdEncoding.EncodeToString(ciphertext), nil
}
// DecryptFromDatabase 使用主密鑰解密數據（從數據庫讀取）
func (em *EncryptionManager) DecryptFromDatabase(encryptedBase64 string) (string, error) {
em.mu.RLock()
defer em.mu.RUnlock()
// 處理空字符串（未加密的舊數據）
if encryptedBase64 == "" {
return "", nil
}
ciphertext, err := base64.StdEncoding.DecodeString(encryptedBase64)
if err != nil {
return "", err
}
block, err := aes.NewCipher(em.masterKey)
if err != nil {
return "", err
}
aesGCM, err := cipher.NewGCM(block)
if err != nil {
return "", err
}
nonceSize := aesGCM.NonceSize()
if len(ciphertext) < nonceSize {
return "", errors.New("加密數據過短")
}
nonce, ciphertext := ciphertext[:nonceSize], ciphertext[nonceSize:]
plaintext, err := aesGCM.Open(nil, nonce, ciphertext, nil)
if err != nil {
return "", err
}
return string(plaintext), nil
}
// ==================== 密鑰輪換 ====================
// RotateMasterKey 輪換主密鑰（需要重新加密所有數據）
func (em *EncryptionManager) RotateMasterKey() error {
em.mu.Lock()
defer em.mu.Unlock()
log.Println("🔄 開始輪換主密鑰...")
// 生成新主密鑰
newMasterKey := make([]byte, 32)
if _, err := io.ReadFull(rand.Reader, newMasterKey); err != nil {
return err
}
// 備份舊密鑰
oldMasterKey := em.masterKey
// 更新密鑰
em.masterKey = newMasterKey
// 保存新密鑰
encoded := base64.StdEncoding.EncodeToString(newMasterKey)
backupFile := fmt.Sprintf("%s.backup.%d", masterKeyFile, os.Getpid())
if err := os.WriteFile(backupFile, []byte(base64.StdEncoding.EncodeToString(oldMasterKey)), 0600); err != nil {
return err
}
if err := os.WriteFile(masterKeyFile, []byte(encoded), 0600); err != nil {
return err
}
log.Println("✅ 主密鑰已輪換")
log.Printf("⚠️ 舊密鑰已備份到: %s", backupFile)
log.Printf("🔐 新主密鑰: %s", encoded)
return nil
}

159
crypto/encryption_test.go Normal file
View File

@@ -0,0 +1,159 @@
package crypto
import (
"testing"
)
// TestRSAKeyPairGeneration 測試 RSA 密鑰對生成
func TestRSAKeyPairGeneration(t *testing.T) {
em, err := GetEncryptionManager()
if err != nil {
t.Fatalf("初始化加密管理器失敗: %v", err)
}
publicKey := em.GetPublicKeyPEM()
if publicKey == "" {
t.Fatal("公鑰為空")
}
if len(publicKey) < 100 {
t.Fatal("公鑰長度異常")
}
t.Logf("✅ RSA 密鑰對生成成功，公鑰長度: %d", len(publicKey))
}
// TestDatabaseEncryption 測試數據庫加密/解密
func TestDatabaseEncryption(t *testing.T) {
em, err := GetEncryptionManager()
if err != nil {
t.Fatalf("初始化加密管理器失敗: %v", err)
}
testCases := []string{
"0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef",
"test_api_key_12345",
"very_secret_password",
"",
}
for _, plaintext := range testCases {
// 加密
encrypted, err := em.EncryptForDatabase(plaintext)
if err != nil {
t.Fatalf("加密失敗: %v (明文: %s)", err, plaintext)
}
// 驗證加密後不等於明文
if encrypted == plaintext && plaintext != "" {
t.Fatalf("加密失敗：加密後仍為明文")
}
// 解密
decrypted, err := em.DecryptFromDatabase(encrypted)
if err != nil {
t.Fatalf("解密失敗: %v (密文: %s)", err, encrypted)
}
// 驗證解密後等於明文
if decrypted != plaintext {
t.Fatalf("解密結果不匹配: 期望 %s, 得到 %s", plaintext, decrypted)
}
t.Logf("✅ 加密/解密測試通過: %s", plaintext[:min(len(plaintext), 20)])
}
}
// TestHybridEncryption 測試混合加密（前端 → 後端場景）
func TestHybridEncryption(t *testing.T) {
_, err := GetEncryptionManager()
if err != nil {
t.Fatalf("初始化加密管理器失敗: %v", err)
}
// 模擬前端加密私鑰
// plaintext := "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
// 注意：這裡需要前端的 encryptWithServerPublicKey 實現
// 為了測試，我們直接使用後端的加密函數（實際前端使用 Web Crypto API）
// 由於前端加密邏輯較複雜，這裡僅測試解密流程
// 實際測試需要端到端測試
t.Log("⚠️ 混合加密測試需要完整的前後端環境，請執行端到端測試")
}
// TestEmptyString 測試空字串處理
func TestEmptyString(t *testing.T) {
em, err := GetEncryptionManager()
if err != nil {
t.Fatalf("初始化加密管理器失敗: %v", err)
}
encrypted, err := em.EncryptForDatabase("")
if err != nil {
t.Fatalf("加密空字串失敗: %v", err)
}
decrypted, err := em.DecryptFromDatabase(encrypted)
if err != nil {
t.Fatalf("解密空字串失敗: %v", err)
}
if decrypted != "" {
t.Fatalf("空字串處理錯誤: 期望空字串, 得到 %s", decrypted)
}
t.Log("✅ 空字串處理正確")
}
// TestInvalidCiphertext 測試無效密文處理
func TestInvalidCiphertext(t *testing.T) {
em, err := GetEncryptionManager()
if err != nil {
t.Fatalf("初始化加密管理器失敗: %v", err)
}
invalidCiphertexts := []string{
"not_base64!@#$%",
"dGVzdA==", // 有效 Base64，但內容太短
"",
}
for _, ciphertext := range invalidCiphertexts {
_, err := em.DecryptFromDatabase(ciphertext)
if err == nil && ciphertext != "" {
t.Fatalf("應該拒絕無效密文: %s", ciphertext)
}
}
t.Log("✅ 無效密文處理正確")
}
// BenchmarkEncryption 性能測試：加密
func BenchmarkEncryption(b *testing.B) {
em, _ := GetEncryptionManager()
plaintext := "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
b.ResetTimer()
for i := 0; i < b.N; i++ {
_, _ = em.EncryptForDatabase(plaintext)
}
}
// BenchmarkDecryption 性能測試：解密
func BenchmarkDecryption(b *testing.B) {
em, _ := GetEncryptionManager()
plaintext := "0x1234567890abcdef1234567890abcdef1234567890abcdef1234567890abcdef"
encrypted, _ := em.EncryptForDatabase(plaintext)
b.ResetTimer()
for i := 0; i < b.N; i++ {
_, _ = em.DecryptFromDatabase(encrypted)
}
}
// min 工具函數
func min(a, b int) int {
if a < b {
return a
}
return b
}

302
crypto/secure_storage.go Normal file
View File

@@ -0,0 +1,302 @@
package crypto
import (
"database/sql"
"fmt"
"log"
"time"
)
// SecureStorage 安全存儲層（自動加密/解密數據庫中的敏感字段）
type SecureStorage struct {
db *sql.DB
em *EncryptionManager
}
// NewSecureStorage 創建安全存儲實例
func NewSecureStorage(db *sql.DB) (*SecureStorage, error) {
em, err := GetEncryptionManager()
if err != nil {
return nil, err
}
ss := &SecureStorage{
db: db,
em: em,
}
// 初始化審計日誌表
if err := ss.initAuditLog(); err != nil {
return nil, fmt.Errorf("初始化審計日誌失敗: %w", err)
}
return ss, nil
}
// ==================== 交易所配置加密存儲 ====================
// SaveEncryptedExchangeConfig 保存加密的交易所配置
func (ss *SecureStorage) SaveEncryptedExchangeConfig(userID, exchangeID, apiKey, secretKey, asterPrivateKey string) error {
// 加密敏感字段
encryptedAPIKey, err := ss.em.EncryptForDatabase(apiKey)
if err != nil {
return fmt.Errorf("加密 API Key 失敗: %w", err)
}
encryptedSecretKey, err := ss.em.EncryptForDatabase(secretKey)
if err != nil {
return fmt.Errorf("加密 Secret Key 失敗: %w", err)
}
encryptedPrivateKey := ""
if asterPrivateKey != "" {
encryptedPrivateKey, err = ss.em.EncryptForDatabase(asterPrivateKey)
if err != nil {
return fmt.Errorf("加密 Private Key 失敗: %w", err)
}
}
// 更新數據庫
_, err = ss.db.Exec(`
UPDATE exchanges
SET api_key = ?, secret_key = ?, aster_private_key = ?, updated_at = datetime('now')
WHERE user_id = ? AND id = ?
`, encryptedAPIKey, encryptedSecretKey, encryptedPrivateKey, userID, exchangeID)
if err != nil {
return err
}
// 記錄審計日誌
ss.logAudit(userID, "exchange_config_update", exchangeID, "密鑰已更新")
log.Printf("🔐 [%s] 交易所 %s 的密鑰已加密保存", userID, exchangeID)
return nil
}
// LoadDecryptedExchangeConfig 加載並解密交易所配置
func (ss *SecureStorage) LoadDecryptedExchangeConfig(userID, exchangeID string) (apiKey, secretKey, asterPrivateKey string, err error) {
var encryptedAPIKey, encryptedSecretKey, encryptedPrivateKey sql.NullString
err = ss.db.QueryRow(`
SELECT api_key, secret_key, aster_private_key
FROM exchanges
WHERE user_id = ? AND id = ?
`, userID, exchangeID).Scan(&encryptedAPIKey, &encryptedSecretKey, &encryptedPrivateKey)
if err != nil {
return "", "", "", err
}
// 解密 API Key
if encryptedAPIKey.Valid && encryptedAPIKey.String != "" {
apiKey, err = ss.em.DecryptFromDatabase(encryptedAPIKey.String)
if err != nil {
return "", "", "", fmt.Errorf("解密 API Key 失敗: %w", err)
}
}
// 解密 Secret Key
if encryptedSecretKey.Valid && encryptedSecretKey.String != "" {
secretKey, err = ss.em.DecryptFromDatabase(encryptedSecretKey.String)
if err != nil {
return "", "", "", fmt.Errorf("解密 Secret Key 失敗: %w", err)
}
}
// 解密 Private Key
if encryptedPrivateKey.Valid && encryptedPrivateKey.String != "" {
asterPrivateKey, err = ss.em.DecryptFromDatabase(encryptedPrivateKey.String)
if err != nil {
return "", "", "", fmt.Errorf("解密 Private Key 失敗: %w", err)
}
}
// 記錄審計日誌
ss.logAudit(userID, "exchange_config_read", exchangeID, "密鑰已讀取")
return apiKey, secretKey, asterPrivateKey, nil
}
// ==================== AI 模型配置加密存儲 ====================
// SaveEncryptedAIModelConfig 保存加密的 AI 模型 API Key
func (ss *SecureStorage) SaveEncryptedAIModelConfig(userID, modelID, apiKey string) error {
encryptedAPIKey, err := ss.em.EncryptForDatabase(apiKey)
if err != nil {
return fmt.Errorf("加密 API Key 失敗: %w", err)
}
_, err = ss.db.Exec(`
UPDATE ai_models
SET api_key = ?, updated_at = datetime('now')
WHERE user_id = ? AND id = ?
`, encryptedAPIKey, userID, modelID)
if err != nil {
return err
}
ss.logAudit(userID, "ai_model_config_update", modelID, "API Key 已更新")
log.Printf("🔐 [%s] AI 模型 %s 的 API Key 已加密保存", userID, modelID)
return nil
}
// LoadDecryptedAIModelConfig 加載並解密 AI 模型配置
func (ss *SecureStorage) LoadDecryptedAIModelConfig(userID, modelID string) (string, error) {
var encryptedAPIKey sql.NullString
err := ss.db.QueryRow(`
SELECT api_key FROM ai_models WHERE user_id = ? AND id = ?
`, userID, modelID).Scan(&encryptedAPIKey)
if err != nil {
return "", err
}
if !encryptedAPIKey.Valid || encryptedAPIKey.String == "" {
return "", nil
}
apiKey, err := ss.em.DecryptFromDatabase(encryptedAPIKey.String)
if err != nil {
return "", fmt.Errorf("解密 API Key 失敗: %w", err)
}
ss.logAudit(userID, "ai_model_config_read", modelID, "API Key 已讀取")
return apiKey, nil
}
// ==================== 審計日誌 ====================
// initAuditLog 初始化審計日誌表
func (ss *SecureStorage) initAuditLog() error {
_, err := ss.db.Exec(`
CREATE TABLE IF NOT EXISTS audit_logs (
id INTEGER PRIMARY KEY AUTOINCREMENT,
user_id TEXT NOT NULL,
action TEXT NOT NULL,
resource TEXT NOT NULL,
details TEXT,
ip_address TEXT,
user_agent TEXT,
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
INDEX idx_user_time (user_id, timestamp),
INDEX idx_action (action)
)
`)
return err
}
// logAudit 記錄審計日誌
func (ss *SecureStorage) logAudit(userID, action, resource, details string) {
_, err := ss.db.Exec(`
INSERT INTO audit_logs (user_id, action, resource, details)
VALUES (?, ?, ?, ?)
`, userID, action, resource, details)
if err != nil {
log.Printf("⚠️ 審計日誌記錄失敗: %v", err)
}
}
// GetAuditLogs 查詢審計日誌
func (ss *SecureStorage) GetAuditLogs(userID string, limit int) ([]AuditLog, error) {
rows, err := ss.db.Query(`
SELECT id, user_id, action, resource, details, timestamp
FROM audit_logs
WHERE user_id = ?
ORDER BY timestamp DESC
LIMIT ?
`, userID, limit)
if err != nil {
return nil, err
}
defer rows.Close()
var logs []AuditLog
for rows.Next() {
var log AuditLog
err := rows.Scan(&log.ID, &log.UserID, &log.Action, &log.Resource, &log.Details, &log.Timestamp)
if err != nil {
return nil, err
}
logs = append(logs, log)
}
return logs, nil
}
// AuditLog 審計日誌結構
type AuditLog struct {
ID int64 `json:"id"`
UserID string `json:"user_id"`
Action string `json:"action"`
Resource string `json:"resource"`
Details string `json:"details"`
Timestamp time.Time `json:"timestamp"`
}
// ==================== 數據遷移工具 ====================
// MigrateToEncrypted 將舊的明文數據遷移到加密格式
func (ss *SecureStorage) MigrateToEncrypted() error {
log.Println("🔄 開始遷移明文數據到加密格式...")
tx, err := ss.db.Begin()
if err != nil {
return err
}
defer tx.Rollback()
// 遷移交易所配置
rows, err := tx.Query(`
SELECT user_id, id, api_key, secret_key, aster_private_key
FROM exchanges
WHERE api_key != '' AND api_key NOT LIKE '%==%' -- 過濾已加密數據
`)
if err != nil {
return err
}
var count int
for rows.Next() {
var userID, exchangeID, apiKey, secretKey string
var asterPrivateKey sql.NullString
if err := rows.Scan(&userID, &exchangeID, &apiKey, &secretKey, &asterPrivateKey); err != nil {
rows.Close()
return err
}
// 加密
encAPIKey, _ := ss.em.EncryptForDatabase(apiKey)
encSecretKey, _ := ss.em.EncryptForDatabase(secretKey)
encPrivateKey := ""
if asterPrivateKey.Valid && asterPrivateKey.String != "" {
encPrivateKey, _ = ss.em.EncryptForDatabase(asterPrivateKey.String)
}
// 更新
_, err = tx.Exec(`
UPDATE exchanges
SET api_key = ?, secret_key = ?, aster_private_key = ?
WHERE user_id = ? AND id = ?
`, encAPIKey, encSecretKey, encPrivateKey, userID, exchangeID)
if err != nil {
rows.Close()
return err
}
count++
}
rows.Close()
if err := tx.Commit(); err != nil {
return err
}
log.Printf("✅ 已遷移 %d 個交易所配置到加密格式", count)
return nil
}

142
decision/engine.go
View File

@@ -4,6 +4,7 @@ import (
"encoding/json"
"fmt"
"log"
"math"
"nofx/market"
"nofx/mcp"
"nofx/pool"
@@ -21,6 +22,10 @@ var (
reArrayHead = regexp.MustCompile(`^\[\s*\{`)
reArrayOpenSpace = regexp.MustCompile(`^\[\s+\{`)
reInvisibleRunes = regexp.MustCompile("[\u200B\u200C\u200D\uFEFF]")
// 新增：XML标签提取（支持思维链中包含任何字符）
reReasoningTag = regexp.MustCompile(`(?s)<reasoning>(.*?)</reasoning>`)
reDecisionTag = regexp.MustCompile(`(?s)<decision>(.*?)</decision>`)
)
// PositionInfo 持仓信息
@@ -33,6 +38,7 @@ type PositionInfo struct {
Leverage int `json:"leverage"`
UnrealizedPnL float64 `json:"unrealized_pnl"`
UnrealizedPnLPct float64 `json:"unrealized_pnl_pct"`
PeakPnLPct float64 `json:"peak_pnl_pct"` // 历史最高收益率（百分比）
LiquidationPrice float64 `json:"liquidation_price"`
MarginUsed float64 `json:"margin_used"`
UpdateTime int64 `json:"update_time"` // 持仓更新时间戳（毫秒）
@@ -82,8 +88,8 @@ type Context struct {
// Decision AI的交易决策
type Decision struct {
Symbol string `json:"symbol"`
Action string `json:"action"` // "open_long", "open_short", "close_long", "close_short", "update_stop_loss", "update_take_profit", "partial_close", "hold", "wait"
Symbol string `json:"symbol"`
Action string `json:"action"` // "open_long", "open_short", "close_long", "close_short", "update_stop_loss", "update_take_profit", "partial_close", "hold", "wait"
// 开仓参数
Leverage int `json:"leverage,omitempty"`
@@ -92,14 +98,14 @@ type Decision struct {
TakeProfit float64 `json:"take_profit,omitempty"`
// 调整参数（新增）
NewStopLoss float64 `json:"new_stop_loss,omitempty"` // 用于 update_stop_loss
NewTakeProfit float64 `json:"new_take_profit,omitempty"` // 用于 update_take_profit
ClosePercentage float64 `json:"close_percentage,omitempty"` // 用于 partial_close (0-100)
NewStopLoss float64 `json:"new_stop_loss,omitempty"` // 用于 update_stop_loss
NewTakeProfit float64 `json:"new_take_profit,omitempty"` // 用于 update_take_profit
ClosePercentage float64 `json:"close_percentage,omitempty"` // 用于 partial_close (0-100)
// 通用参数
Confidence int `json:"confidence,omitempty"` // 信心度 (0-100)
RiskUSD float64 `json:"risk_usd,omitempty"` // 最大美元风险
Reasoning string `json:"reasoning"`
Confidence int `json:"confidence,omitempty"` // 信心度 (0-100)
RiskUSD float64 `json:"risk_usd,omitempty"` // 最大美元风险
Reasoning string `json:"reasoning"`
}
// FullDecision AI的完整决策（包含思维链）
@@ -109,6 +115,8 @@ type FullDecision struct {
CoTTrace string `json:"cot_trace"` // 思维链分析（AI输出）
Decisions []Decision `json:"decisions"` // 具体决策列表
Timestamp time.Time `json:"timestamp"`
// AIRequestDurationMs 记录 AI API 调用耗时（毫秒）方便排查延迟问题
AIRequestDurationMs int64 `json:"ai_request_duration_ms,omitempty"`
}
// GetFullDecision 获取AI的完整交易决策（批量分析所有币种和持仓）
@@ -128,13 +136,24 @@ func GetFullDecisionWithCustomPrompt(ctx *Context, mcpClient *mcp.Client, custom
userPrompt := buildUserPrompt(ctx)
// 3. 调用AI API（使用 system + user prompt）
aiCallStart := time.Now()
aiResponse, err := mcpClient.CallWithMessages(systemPrompt, userPrompt)
aiCallDuration := time.Since(aiCallStart)
if err != nil {
return nil, fmt.Errorf("调用AI API失败: %w", err)
}
// 4. 解析AI响应
decision, err := parseFullDecisionResponse(aiResponse, ctx.Account.TotalEquity, ctx.BTCETHLeverage, ctx.AltcoinLeverage)
// 无论是否有错误，都要保存 SystemPrompt 和 UserPrompt（用于调试和决策未执行后的问题定位）
if decision != nil {
decision.Timestamp = time.Now()
decision.SystemPrompt = systemPrompt // 保存系统prompt
decision.UserPrompt = userPrompt // 保存输入prompt
decision.AIRequestDurationMs = aiCallDuration.Milliseconds()
}
if err != nil {
return decision, fmt.Errorf("解析AI响应失败: %w", err)
}
@@ -316,15 +335,20 @@ func buildSystemPrompt(accountEquity float64, btcEthLeverage, altcoinLeverage in
sb.WriteString("6. 开仓金额: 建议 **≥12 USDT** (交易所最小名义价值 10 USDT + 安全边际)\n\n")
// 3. 输出格式 - 动态生成
sb.WriteString("#输出格式\n\n")
sb.WriteString("第一步: 思维链（纯文本）\n")
sb.WriteString("简洁分析你的思考过程\n\n")
sb.WriteString("第二步: JSON决策数组\n\n")
sb.WriteString("# 输出格式 (严格遵守)\n\n")
sb.WriteString("**必须使用XML标签 <reasoning> 和 <decision> 标签分隔思维链和决策JSON，避免解析错误**\n\n")
sb.WriteString("## 格式要求\n\n")
sb.WriteString("<reasoning>\n")
sb.WriteString("你的思维链分析...\n")
sb.WriteString("- 简洁分析你的思考过程 \n")
sb.WriteString("</reasoning>\n\n")
sb.WriteString("<decision>\n")
sb.WriteString("```json\n[\n")
sb.WriteString(fmt.Sprintf(" {\"symbol\": \"BTCUSDT\", \"action\": \"open_short\", \"leverage\": %d, \"position_size_usd\": %.0f, \"stop_loss\": 97000, \"take_profit\": 91000, \"confidence\": 85, \"risk_usd\": 300, \"reasoning\": \"下跌趋势+MACD死叉\"},\n", btcEthLeverage, accountEquity*5))
sb.WriteString(" {\"symbol\": \"ETHUSDT\", \"action\": \"close_long\", \"reasoning\": \"止盈离场\"}\n")
sb.WriteString("]\n```\n\n")
sb.WriteString("字段说明:\n")
sb.WriteString("]\n```\n")
sb.WriteString("</decision>\n\n")
sb.WriteString("## 字段说明\n\n")
sb.WriteString("- `action`: open_long | open_short | close_long | close_short | hold | wait\n")
sb.WriteString("- `confidence`: 0-100（开仓建议≥75）\n")
sb.WriteString("- 开仓时必填: leverage, position_size_usd, stop_loss, take_profit, confidence, risk_usd, reasoning\n\n")
@@ -374,9 +398,12 @@ func buildUserPrompt(ctx *Context) string {
}
}
sb.WriteString(fmt.Sprintf("%d. %s %s | 入场价%.4f 当前价%.4f | 盈亏%+.2f%% | 杠杆%dx | 保证金%.0f | 强平价%.4f%s\n\n",
// 计算仓位价值（用于 partial_close 检查）
positionValue := math.Abs(pos.Quantity) * pos.MarkPrice
sb.WriteString(fmt.Sprintf("%d. %s %s | 入场价%.4f 当前价%.4f | 数量%.4f | 仓位价值%.2f USDT | 盈亏%+.2f%% | 盈亏金额%+.2f USDT | 最高收益率%.2f%% | 杠杆%dx | 保证金%.0f | 强平价%.4f%s\n\n",
i+1, pos.Symbol, strings.ToUpper(pos.Side),
pos.EntryPrice, pos.MarkPrice, pos.UnrealizedPnLPct,
pos.EntryPrice, pos.MarkPrice, pos.Quantity, positionValue, pos.UnrealizedPnLPct, pos.UnrealizedPnL, pos.PeakPnLPct,
pos.Leverage, pos.MarginUsed, pos.LiquidationPrice, holdingDuration))
// 使用FormatMarketData输出完整市场数据
@@ -463,15 +490,26 @@ func parseFullDecisionResponse(aiResponse string, accountEquity float64, btcEthL
// extractCoTTrace 提取思维链分析
func extractCoTTrace(response string) string {
// 查找JSON数组的开始位置
jsonStart := strings.Index(response, "[")
// 方法1: 优先尝试提取 <reasoning> 标签内容
if match := reReasoningTag.FindStringSubmatch(response); match != nil && len(match) > 1 {
log.Printf("✓ 使用 <reasoning> 标签提取思维链")
return strings.TrimSpace(match[1])
}
// 方法2: 如果没有 <reasoning> 标签，但有 <decision> 标签，提取 <decision> 之前的内容
if decisionIdx := strings.Index(response, "<decision>"); decisionIdx > 0 {
log.Printf("✓ 提取 <decision> 标签之前的内容作为思维链")
return strings.TrimSpace(response[:decisionIdx])
}
// 方法3: 后备方案 - 查找JSON数组的开始位置
jsonStart := strings.Index(response, "[")
if jsonStart > 0 {
// 思维链是JSON数组之前的内容
log.Printf("⚠️ 使用旧版格式（[ 字符分离）提取思维链")
return strings.TrimSpace(response[:jsonStart])
}
// 如果找不到JSON，整个响应都是思维链
// 如果找不到任何标记，整个响应都是思维链
return strings.TrimSpace(response)
}
@@ -481,15 +519,29 @@ func extractDecisions(response string) ([]Decision, error) {
s := removeInvisibleRunes(response)
s = strings.TrimSpace(s)
// 🔧 關鍵修復：在正則匹配之前就先修復全角字符！
// 否則正則表達式 \[ 無法匹配全角的 ［
// 🔧 关键修复 (Critical Fix)：在正则匹配之前就先修复全角字符！
// 否则正则表达式 \[ 无法匹配全角的 ［
s = fixMissingQuotes(s)
// 方法1: 优先尝试从 <decision> 标签中提取
var jsonPart string
if match := reDecisionTag.FindStringSubmatch(s); match != nil && len(match) > 1 {
jsonPart = strings.TrimSpace(match[1])
log.Printf("✓ 使用 <decision> 标签提取JSON")
} else {
// 后备方案：使用整个响应
jsonPart = s
log.Printf("⚠️ 未找到 <decision> 标签，使用全文搜索JSON")
}
// 修复 jsonPart 中的全角字符
jsonPart = fixMissingQuotes(jsonPart)
// 1) 优先从 ```json 代码块中提取
if m := reJSONFence.FindStringSubmatch(s); m != nil && len(m) > 1 {
if m := reJSONFence.FindStringSubmatch(jsonPart); m != nil && len(m) > 1 {
jsonContent := strings.TrimSpace(m[1])
jsonContent = compactArrayOpen(jsonContent) // 把 "[ {" 规整为 "[{"
jsonContent = fixMissingQuotes(jsonContent) // 二次修復（防止 regex 提取後還有全角）
jsonContent = fixMissingQuotes(jsonContent) // 二次修复（防止 regex 提取后还有残留全角）
if err := validateJSONFormat(jsonContent); err != nil {
return nil, fmt.Errorf("JSON格式验证失败: %w\nJSON内容: %s\n完整响应:\n%s", err, jsonContent, response)
}
@@ -500,16 +552,32 @@ func extractDecisions(response string) ([]Decision, error) {
return decisions, nil
}
// 2) 退而求其次：全文寻找首个对象数组
// 注意：此時 s 已經過 fixMissingQuotes()，全角字符已轉換為半角
jsonContent := strings.TrimSpace(reJSONArray.FindString(s))
// 2) 退而求其次 (Fallback)：全文寻找首个对象数组
// 注意：此时 jsonPart 已经过 fixMissingQuotes()，全角字符已转换为半角
jsonContent := strings.TrimSpace(reJSONArray.FindString(jsonPart))
if jsonContent == "" {
return nil, fmt.Errorf("无法找到JSON数组起始（已嘗試修復全角字符）\n原始響應前200字符: %s", s[:min(200, len(s))])
// 🔧 安全回退 (Safe Fallback)：当AI只输出思维链没有JSON时，生成保底决策（避免系统崩溃）
log.Printf("⚠️ [SafeFallback] AI未输出JSON决策，进入安全等待模式 (AI response without JSON, entering safe wait mode)")
// 提取思维链摘要（最多 240 字符）
cotSummary := jsonPart
if len(cotSummary) > 240 {
cotSummary = cotSummary[:240] + "..."
}
// 生成保底决策：所有币种进入 wait 状态
fallbackDecision := Decision{
Symbol: "ALL",
Action: "wait",
Reasoning: fmt.Sprintf("模型未输出结构化JSON决策，进入安全等待；摘要：%s", cotSummary),
}
return []Decision{fallbackDecision}, nil
}
// 🔧 規整格式（此時全角字符已在前面修復過）
// 🔧 规整格式（此时全角字符已在前面修复过）
jsonContent = compactArrayOpen(jsonContent)
jsonContent = fixMissingQuotes(jsonContent) // 二次修復（防止 regex 提取後還有殘留全角）
jsonContent = fixMissingQuotes(jsonContent) // 二次修复（防止 regex 提取后还有残留全角）
// 🔧 验证 JSON 格式（检测常见错误）
if err := validateJSONFormat(jsonContent); err != nil {
@@ -666,8 +734,14 @@ func validateDecision(d *Decision, accountEquity float64, btcEthLeverage, altcoi
maxPositionValue = accountEquity * 10 // BTC/ETH最多10倍账户净值
}
if d.Leverage <= 0 || d.Leverage > maxLeverage {
return fmt.Errorf("杠杆必须在1-%d之间（%s，当前配置上限%d倍）: %d", maxLeverage, d.Symbol, maxLeverage, d.Leverage)
// ✅ Fallback 机制：杠杆超限时自动修正为上限值（而不是直接拒绝决策）
if d.Leverage <= 0 {
return fmt.Errorf("杠杆必须大于0: %d", d.Leverage)
}
if d.Leverage > maxLeverage {
log.Printf("⚠️ [Leverage Fallback] %s 杠杆超限 (%dx > %dx)，自动调整为上限值 %dx",
d.Symbol, d.Leverage, maxLeverage, maxLeverage)
d.Leverage = maxLeverage // 自动修正为上限值
}
if d.PositionSizeUSD <= 0 {
return fmt.Errorf("仓位大小必须大于0: %.2f", d.PositionSizeUSD)
@@ -675,8 +749,8 @@ func validateDecision(d *Decision, accountEquity float64, btcEthLeverage, altcoi
// ✅ 验证最小开仓金额（防止数量格式化为 0 的错误）
// Binance 最小名义价值 10 USDT + 安全边际
const minPositionSizeGeneral = 12.0 // 10 + 20% 安全边际
const minPositionSizeBTCETH = 60.0 // BTC/ETH 因价格高和精度限制需要更大金额（更灵活）
const minPositionSizeGeneral = 12.0 // 10 + 20% 安全边际
const minPositionSizeBTCETH = 60.0 // BTC/ETH 因价格高和精度限制需要更大金额（更灵活）
if d.Symbol == "BTCUSDT" || d.Symbol == "ETHUSDT" {
if d.PositionSizeUSD < minPositionSizeBTCETH {

285
decision/prompt_manager_test.go Normal file
View File

@@ -0,0 +1,285 @@
package decision
import (
"os"
"path/filepath"
"testing"
)
func TestPromptManager_LoadTemplates(t *testing.T) {
// 创建临时目录用于测试
tempDir := t.TempDir()
tests := []struct {
name string
setupFiles map[string]string // 文件名 -> 内容
expectedCount int
expectedNames []string
shouldError bool
}{
{
name: "加载单个模板文件",
setupFiles: map[string]string{
"default.txt": "你是专业的加密货币交易AI。",
},
expectedCount: 1,
expectedNames: []string{"default"},
shouldError: false,
},
{
name: "加载多个模板文件",
setupFiles: map[string]string{
"default.txt": "默认策略",
"conservative.txt": "保守策略",
"aggressive.txt": "激进策略",
},
expectedCount: 3,
expectedNames: []string{"default", "conservative", "aggressive"},
shouldError: false,
},
{
name: "空目录",
setupFiles: map[string]string{},
expectedCount: 0,
expectedNames: []string{},
shouldError: false,
},
{
name: "忽略非.txt文件",
setupFiles: map[string]string{
"default.txt": "正确的模板",
"readme.md": "应该被忽略",
"config.json": "应该被忽略",
},
expectedCount: 1,
expectedNames: []string{"default"},
shouldError: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// 为每个测试用例创建独立的子目录
testDir := filepath.Join(tempDir, tt.name)
if err := os.MkdirAll(testDir, 0755); err != nil {
t.Fatalf("创建测试目录失败: %v", err)
}
// 设置测试文件
for filename, content := range tt.setupFiles {
filePath := filepath.Join(testDir, filename)
if err := os.WriteFile(filePath, []byte(content), 0644); err != nil {
t.Fatalf("创建测试文件失败 %s: %v", filename, err)
}
}
// 创建新的 PromptManager
pm := NewPromptManager()
// 执行测试
err := pm.LoadTemplates(testDir)
// 检查错误
if (err != nil) != tt.shouldError {
t.Errorf("LoadTemplates() error = %v, shouldError %v", err, tt.shouldError)
return
}
// 检查加载的模板数量
if len(pm.templates) != tt.expectedCount {
t.Errorf("加载的模板数量 = %d, 期望 %d", len(pm.templates), tt.expectedCount)
}
// 检查模板名称
for _, expectedName := range tt.expectedNames {
if _, exists := pm.templates[expectedName]; !exists {
t.Errorf("缺少预期的模板: %s", expectedName)
}
}
// 验证模板内容
for filename, expectedContent := range tt.setupFiles {
if filepath.Ext(filename) != ".txt" {
continue
}
templateName := filename[:len(filename)-4] // 去掉 .txt
template, err := pm.GetTemplate(templateName)
if err != nil {
t.Errorf("获取模板 %s 失败: %v", templateName, err)
continue
}
if template.Content != expectedContent {
t.Errorf("模板内容不匹配\n期望: %s\n实际: %s", expectedContent, template.Content)
}
}
})
}
}
func TestPromptManager_GetTemplate(t *testing.T) {
pm := NewPromptManager()
pm.templates = map[string]*PromptTemplate{
"default": {
Name: "default",
Content: "默认策略内容",
},
"aggressive": {
Name: "aggressive",
Content: "激进策略内容",
},
}
tests := []struct {
name string
templateName string
expectError bool
expectedContent string
}{
{
name: "获取存在的模板",
templateName: "default",
expectError: false,
expectedContent: "默认策略内容",
},
{
name: "获取不存在的模板",
templateName: "nonexistent",
expectError: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
template, err := pm.GetTemplate(tt.templateName)
if (err != nil) != tt.expectError {
t.Errorf("GetTemplate() error = %v, expectError %v", err, tt.expectError)
return
}
if !tt.expectError && template.Content != tt.expectedContent {
t.Errorf("模板内容 = %s, 期望 %s", template.Content, tt.expectedContent)
}
})
}
}
func TestPromptManager_ReloadTemplates(t *testing.T) {
tempDir := t.TempDir()
// 初始文件
if err := os.WriteFile(filepath.Join(tempDir, "default.txt"), []byte("初始内容"), 0644); err != nil {
t.Fatalf("创建初始文件失败: %v", err)
}
pm := NewPromptManager()
if err := pm.LoadTemplates(tempDir); err != nil {
t.Fatalf("初始加载失败: %v", err)
}
// 验证初始内容
template, _ := pm.GetTemplate("default")
if template.Content != "初始内容" {
t.Errorf("初始内容不正确: %s", template.Content)
}
// 修改文件内容
if err := os.WriteFile(filepath.Join(tempDir, "default.txt"), []byte("更新后内容"), 0644); err != nil {
t.Fatalf("更新文件失败: %v", err)
}
// 添加新文件
if err := os.WriteFile(filepath.Join(tempDir, "new.txt"), []byte("新模板内容"), 0644); err != nil {
t.Fatalf("创建新文件失败: %v", err)
}
// 重新加载
if err := pm.ReloadTemplates(tempDir); err != nil {
t.Fatalf("重新加载失败: %v", err)
}
// 验证更新后的内容
template, err := pm.GetTemplate("default")
if err != nil {
t.Fatalf("获取 default 模板失败: %v", err)
}
if template.Content != "更新后内容" {
t.Errorf("重新加载后内容不正确: got %s, want '更新后内容'", template.Content)
}
// 验证新模板
newTemplate, err := pm.GetTemplate("new")
if err != nil {
t.Fatalf("获取 new 模板失败: %v", err)
}
if newTemplate.Content != "新模板内容" {
t.Errorf("新模板内容不正确: %s", newTemplate.Content)
}
// 验证模板数量
if len(pm.templates) != 2 {
t.Errorf("重新加载后模板数量 = %d, 期望 2", len(pm.templates))
}
}
func TestPromptManager_GetAllTemplateNames(t *testing.T) {
pm := NewPromptManager()
pm.templates = map[string]*PromptTemplate{
"default": {Name: "default", Content: "默认策略"},
"conservative": {Name: "conservative", Content: "保守策略"},
"aggressive": {Name: "aggressive", Content: "激进策略"},
}
names := pm.GetAllTemplateNames()
if len(names) != 3 {
t.Errorf("GetAllTemplateNames() 返回数量 = %d, 期望 3", len(names))
}
// 验证所有名称都存在
nameMap := make(map[string]bool)
for _, name := range names {
nameMap[name] = true
}
expectedNames := []string{"default", "conservative", "aggressive"}
for _, expectedName := range expectedNames {
if !nameMap[expectedName] {
t.Errorf("缺少预期的模板名称: %s", expectedName)
}
}
}
func TestReloadPromptTemplates_GlobalFunction(t *testing.T) {
// 保存原始的 promptsDir
originalDir := promptsDir
defer func() {
promptsDir = originalDir
// 恢复原始模板
globalPromptManager.ReloadTemplates(originalDir)
}()
// 创建临时目录
tempDir := t.TempDir()
promptsDir = tempDir
// 创建测试文件
if err := os.WriteFile(filepath.Join(tempDir, "test.txt"), []byte("测试内容"), 0644); err != nil {
t.Fatalf("创建测试文件失败: %v", err)
}
// 调用全局重新加载函数
if err := ReloadPromptTemplates(); err != nil {
t.Fatalf("ReloadPromptTemplates() 失败: %v", err)
}
// 验证全局管理器已更新
template, err := GetPromptTemplate("test")
if err != nil {
t.Fatalf("获取模板失败: %v", err)
}
if template.Content != "测试内容" {
t.Errorf("模板内容不正确: got %s, want '测试内容'", template.Content)
}
}

243
decision/prompt_reload_integration_test.go Normal file
View File

@@ -0,0 +1,243 @@
package decision
import (
"os"
"path/filepath"
"strings"
"testing"
)
// TestPromptReloadEndToEnd 端到端测试：验证从文件修改到决策引擎使用的完整流程
func TestPromptReloadEndToEnd(t *testing.T) {
// 保存原始的 promptsDir
originalDir := promptsDir
defer func() {
promptsDir = originalDir
// 恢复原始模板
globalPromptManager.ReloadTemplates(originalDir)
}()
// 创建临时目录模拟 prompts/ 目录
tempDir := t.TempDir()
promptsDir = tempDir
// 步骤1: 创建初始 prompt 文件
initialContent := "# 初始交易策略\n你是一个保守的交易AI。"
if err := os.WriteFile(filepath.Join(tempDir, "test_strategy.txt"), []byte(initialContent), 0644); err != nil {
t.Fatalf("创建初始文件失败: %v", err)
}
// 步骤2: 首次加载（模拟系统启动）
if err := ReloadPromptTemplates(); err != nil {
t.Fatalf("首次加载失败: %v", err)
}
// 步骤3: 验证初始内容
template, err := GetPromptTemplate("test_strategy")
if err != nil {
t.Fatalf("获取初始模板失败: %v", err)
}
if template.Content != initialContent {
t.Errorf("初始内容不匹配\n期望: %s\n实际: %s", initialContent, template.Content)
}
// 步骤4: 使用 buildSystemPrompt 验证模板被正确使用
systemPrompt := buildSystemPrompt(10000.0, 10, 5, "test_strategy")
if !strings.Contains(systemPrompt, initialContent) {
t.Errorf("buildSystemPrompt 未包含模板内容\n生成的 prompt:\n%s", systemPrompt)
}
// 步骤5: 模拟用户修改文件（这是用户在硬盘上修改 prompt）
updatedContent := "# 更新的交易策略\n你是一个激进的交易AI，追求高风险高收益。"
if err := os.WriteFile(filepath.Join(tempDir, "test_strategy.txt"), []byte(updatedContent), 0644); err != nil {
t.Fatalf("更新文件失败: %v", err)
}
// 步骤6: 模拟交易员启动时调用 ReloadPromptTemplates()
t.Log("模拟交易员启动，调用 ReloadPromptTemplates()...")
if err := ReloadPromptTemplates(); err != nil {
t.Fatalf("重新加载失败: %v", err)
}
// 步骤7: 验证新内容已生效
reloadedTemplate, err := GetPromptTemplate("test_strategy")
if err != nil {
t.Fatalf("获取重新加载的模板失败: %v", err)
}
if reloadedTemplate.Content != updatedContent {
t.Errorf("重新加载后内容不匹配\n期望: %s\n实际: %s", updatedContent, reloadedTemplate.Content)
}
// 步骤8: 验证 buildSystemPrompt 使用了新内容
newSystemPrompt := buildSystemPrompt(10000.0, 10, 5, "test_strategy")
if !strings.Contains(newSystemPrompt, updatedContent) {
t.Errorf("buildSystemPrompt 未包含更新后的模板内容\n生成的 prompt:\n%s", newSystemPrompt)
}
// 步骤9: 验证旧内容不再存在
if strings.Contains(newSystemPrompt, "保守的交易AI") {
t.Errorf("buildSystemPrompt 仍包含旧的模板内容")
}
t.Log("✅ 端到端测试通过：文件修改 -> 重新加载 -> 决策引擎使用新内容")
}
// TestPromptReloadWithCustomPrompt 测试自定义 prompt 与模板重新加载的交互
func TestPromptReloadWithCustomPrompt(t *testing.T) {
// 保存原始的 promptsDir
originalDir := promptsDir
defer func() {
promptsDir = originalDir
globalPromptManager.ReloadTemplates(originalDir)
}()
// 创建临时目录
tempDir := t.TempDir()
promptsDir = tempDir
// 创建基础模板
baseContent := "基础策略：稳健交易"
if err := os.WriteFile(filepath.Join(tempDir, "base.txt"), []byte(baseContent), 0644); err != nil {
t.Fatalf("创建文件失败: %v", err)
}
// 加载模板
if err := ReloadPromptTemplates(); err != nil {
t.Fatalf("加载失败: %v", err)
}
// 测试1: 基础模板 + 自定义 prompt（不覆盖）
customPrompt := "个性化规则：只交易 BTC"
result := buildSystemPromptWithCustom(10000.0, 10, 5, customPrompt, false, "base")
if !strings.Contains(result, baseContent) {
t.Errorf("未包含基础模板内容")
}
if !strings.Contains(result, customPrompt) {
t.Errorf("未包含自定义 prompt")
}
// 测试2: 覆盖基础 prompt
result = buildSystemPromptWithCustom(10000.0, 10, 5, customPrompt, true, "base")
if strings.Contains(result, baseContent) {
t.Errorf("覆盖模式下仍包含基础模板内容")
}
if !strings.Contains(result, customPrompt) {
t.Errorf("覆盖模式下未包含自定义 prompt")
}
// 测试3: 重新加载后效果
updatedBase := "更新的基础策略：激进交易"
if err := os.WriteFile(filepath.Join(tempDir, "base.txt"), []byte(updatedBase), 0644); err != nil {
t.Fatalf("更新文件失败: %v", err)
}
if err := ReloadPromptTemplates(); err != nil {
t.Fatalf("重新加载失败: %v", err)
}
result = buildSystemPromptWithCustom(10000.0, 10, 5, customPrompt, false, "base")
if !strings.Contains(result, updatedBase) {
t.Errorf("重新加载后未包含更新的基础模板内容")
}
if strings.Contains(result, baseContent) {
t.Errorf("重新加载后仍包含旧的基础模板内容")
}
}
// TestPromptReloadFallback 测试模板不存在时的降级机制
func TestPromptReloadFallback(t *testing.T) {
// 保存原始的 promptsDir
originalDir := promptsDir
defer func() {
promptsDir = originalDir
globalPromptManager.ReloadTemplates(originalDir)
}()
// 创建临时目录
tempDir := t.TempDir()
promptsDir = tempDir
// 只创建 default 模板
defaultContent := "默认策略"
if err := os.WriteFile(filepath.Join(tempDir, "default.txt"), []byte(defaultContent), 0644); err != nil {
t.Fatalf("创建文件失败: %v", err)
}
if err := ReloadPromptTemplates(); err != nil {
t.Fatalf("加载失败: %v", err)
}
// 测试1: 请求不存在的模板，应该降级到 default
result := buildSystemPrompt(10000.0, 10, 5, "nonexistent")
if !strings.Contains(result, defaultContent) {
t.Errorf("请求不存在的模板时，未降级到 default")
}
// 测试2: 空模板名，应该使用 default
result = buildSystemPrompt(10000.0, 10, 5, "")
if !strings.Contains(result, defaultContent) {
t.Errorf("空模板名时，未使用 default")
}
}
// TestConcurrentPromptReload 测试并发场景下的 prompt 重新加载
func TestConcurrentPromptReload(t *testing.T) {
// 保存原始的 promptsDir
originalDir := promptsDir
defer func() {
promptsDir = originalDir
globalPromptManager.ReloadTemplates(originalDir)
}()
// 创建临时目录
tempDir := t.TempDir()
promptsDir = tempDir
// 创建测试文件
if err := os.WriteFile(filepath.Join(tempDir, "test.txt"), []byte("测试内容"), 0644); err != nil {
t.Fatalf("创建文件失败: %v", err)
}
if err := ReloadPromptTemplates(); err != nil {
t.Fatalf("初始加载失败: %v", err)
}
// 并发测试：同时读取和重新加载
done := make(chan bool)
// 启动多个读取 goroutine
for i := 0; i < 10; i++ {
go func() {
for j := 0; j < 100; j++ {
_, _ = GetPromptTemplate("test")
}
done <- true
}()
}
// 启动多个重新加载 goroutine
for i := 0; i < 3; i++ {
go func() {
for j := 0; j < 10; j++ {
_ = ReloadPromptTemplates()
}
done <- true
}()
}
// 等待所有 goroutine 完成
for i := 0; i < 13; i++ {
<-done
}
// 验证最终状态正确
template, err := GetPromptTemplate("test")
if err != nil {
t.Errorf("并发测试后获取模板失败: %v", err)
}
if template.Content != "测试内容" {
t.Errorf("并发测试后模板内容错误: %s", template.Content)
}
t.Log("✅ 并发测试通过：多个 goroutine 同时读取和重新加载模板，无数据竞争")
}

100
decision/validate_test.go Normal file
View File

@@ -0,0 +1,100 @@
package decision
import (
"testing"
)
// TestLeverageFallback 测试杠杆超限时的自动修正功能
func TestLeverageFallback(t *testing.T) {
tests := []struct {
name string
decision Decision
accountEquity float64
btcEthLeverage int
altcoinLeverage int
wantLeverage int // 期望修正后的杠杆值
wantError bool
}{
{
name: "山寨币杠杆超限_自动修正为上限",
decision: Decision{
Symbol: "SOLUSDT",
Action: "open_long",
Leverage: 20, // 超过上限
PositionSizeUSD: 100,
StopLoss: 50,
TakeProfit: 200,
},
accountEquity: 100,
btcEthLeverage: 10,
altcoinLeverage: 5, // 上限 5x
wantLeverage: 5, // 应该修正为 5
wantError: false,
},
{
name: "BTC杠杆超限_自动修正为上限",
decision: Decision{
Symbol: "BTCUSDT",
Action: "open_long",
Leverage: 20, // 超过上限
PositionSizeUSD: 1000,
StopLoss: 90000,
TakeProfit: 110000,
},
accountEquity: 100,
btcEthLeverage: 10, // 上限 10x
altcoinLeverage: 5,
wantLeverage: 10, // 应该修正为 10
wantError: false,
},
{
name: "杠杆在上限内_不修正",
decision: Decision{
Symbol: "ETHUSDT",
Action: "open_short",
Leverage: 5, // 未超限
PositionSizeUSD: 500,
StopLoss: 4000,
TakeProfit: 3000,
},
accountEquity: 100,
btcEthLeverage: 10,
altcoinLeverage: 5,
wantLeverage: 5, // 保持不变
wantError: false,
},
{
name: "杠杆为0_应该报错",
decision: Decision{
Symbol: "SOLUSDT",
Action: "open_long",
Leverage: 0, // 无效
PositionSizeUSD: 100,
StopLoss: 50,
TakeProfit: 200,
},
accountEquity: 100,
btcEthLeverage: 10,
altcoinLeverage: 5,
wantLeverage: 0,
wantError: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := validateDecision(&tt.decision, tt.accountEquity, tt.btcEthLeverage, tt.altcoinLeverage)
// 检查错误状态
if (err != nil) != tt.wantError {
t.Errorf("validateDecision() error = %v, wantError %v", err, tt.wantError)
return
}
// 如果不应该报错，检查杠杆是否被正确修正
if !tt.wantError && tt.decision.Leverage != tt.wantLeverage {
t.Errorf("Leverage not corrected: got %d, want %d", tt.decision.Leverage, tt.wantLeverage)
}
})
}
}

286
deploy_encryption.sh Executable file
View File

@@ -0,0 +1,286 @@
#!/bin/bash
# NOFX 加密系統一鍵部署腳本
# 使用方式: chmod +x deploy_encryption.sh && ./deploy_encryption.sh
set -e # 遇到錯誤立即退出
# 顏色定義
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# 輔助函數
log_info() {
echo -e "${BLUE}ℹ️ $1${NC}"
}
log_success() {
echo -e "${GREEN}✅ $1${NC}"
}
log_warning() {
echo -e "${YELLOW}⚠️ $1${NC}"
}
log_error() {
echo -e "${RED}❌ $1${NC}"
}
# 檢查必要工具
check_dependencies() {
log_info "檢查依賴工具..."
if ! command -v go &> /dev/null; then
log_error "Go 未安裝，請先安裝 Go 1.21+"
exit 1
fi
if ! command -v npm &> /dev/null; then
log_error "npm 未安裝，請先安裝 Node.js 18+"
exit 1
fi
if ! command -v sqlite3 &> /dev/null; then
log_warning "sqlite3 未安裝，部分驗證功能不可用"
fi
log_success "依賴檢查通過"
}
# 備份數據庫
backup_database() {
log_info "備份現有數據庫..."
if [ -f "config.db" ]; then
BACKUP_FILE="config.db.pre_encryption.$(date +%Y%m%d_%H%M%S).backup"
cp config.db "$BACKUP_FILE"
log_success "數據庫已備份到: $BACKUP_FILE"
else
log_warning "未找到 config.db，跳過備份（首次安裝）"
fi
}
# 創建密鑰目錄
setup_secrets_dir() {
log_info "設置密鑰目錄..."
if [ ! -d ".secrets" ]; then
mkdir -p .secrets
chmod 700 .secrets
log_success "密鑰目錄已創建: .secrets/"
else
log_warning "密鑰目錄已存在，跳過創建"
fi
}
# 更新 .gitignore
update_gitignore() {
log_info "更新 .gitignore..."
if ! grep -q ".secrets/" .gitignore 2>/dev/null; then
echo ".secrets/" >> .gitignore
log_success "已添加 .secrets/ 到 .gitignore"
fi
if ! grep -q "config.db.backup" .gitignore 2>/dev/null; then
echo "config.db.*.backup" >> .gitignore
log_success "已添加備份檔案規則到 .gitignore"
fi
}
# 安裝依賴
install_dependencies() {
log_info "安裝 Go 依賴..."
go mod tidy
log_success "Go 依賴已更新"
log_info "安裝前端依賴..."
cd web
if [ ! -d "node_modules" ]; then
npm install
fi
npm install tweetnacl tweetnacl-util @noble/secp256k1 --save
cd ..
log_success "前端依賴已安裝"
}
# 運行測試
run_tests() {
log_info "運行加密系統測試..."
if go test ./crypto -v > /tmp/nofx_test.log 2>&1; then
log_success "加密系統測試通過"
cat /tmp/nofx_test.log | grep "✅"
else
log_error "加密系統測試失敗，詳情:"
cat /tmp/nofx_test.log
exit 1
fi
}
# 遷移數據
migrate_data() {
log_info "遷移現有數據到加密格式..."
if [ -f "config.db" ]; then
# 檢查是否已經加密過
if sqlite3 config.db "SELECT api_key FROM exchanges LIMIT 1;" 2>/dev/null | grep -q "=="; then
log_warning "數據庫似乎已經加密過，跳過遷移"
read -p "是否強制重新遷移？(y/N): " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
return
fi
fi
if go run scripts/migrate_encryption.go; then
log_success "數據遷移完成"
else
log_error "數據遷移失敗"
exit 1
fi
else
log_warning "未找到數據庫，跳過遷移"
fi
}
# 設置環境變數
setup_env_vars() {
log_info "設置環境變數..."
if [ -f ".secrets/master.key" ]; then
MASTER_KEY=$(cat .secrets/master.key)
# 添加到當前 shell 配置
SHELL_RC="$HOME/.bashrc"
if [ -f "$HOME/.zshrc" ]; then
SHELL_RC="$HOME/.zshrc"
fi
if ! grep -q "NOFX_MASTER_KEY" "$SHELL_RC" 2>/dev/null; then
echo "" >> "$SHELL_RC"
echo "# NOFX 加密系統主密鑰" >> "$SHELL_RC"
echo "export NOFX_MASTER_KEY='$MASTER_KEY'" >> "$SHELL_RC"
log_success "主密鑰已添加到 $SHELL_RC"
else
log_warning "主密鑰已存在於 $SHELL_RC"
fi
# 導出到當前 session
export NOFX_MASTER_KEY="$MASTER_KEY"
log_success "主密鑰已導出到當前 session"
else
log_warning "主密鑰文件未生成，請先運行應用初始化"
fi
}
# 驗證部署
verify_deployment() {
log_info "驗證部署結果..."
# 1. 檢查密鑰檔案
if [ -f ".secrets/rsa_private.pem" ] && [ -f ".secrets/rsa_public.pem" ] && [ -f ".secrets/master.key" ]; then
log_success "密鑰檔案完整"
else
log_error "密鑰檔案缺失，請檢查日誌"
return 1
fi
# 2. 檢查檔案權限
PERM=$(stat -f "%Lp" .secrets 2>/dev/null || stat -c "%a" .secrets 2>/dev/null)
if [ "$PERM" = "700" ]; then
log_success "密鑰目錄權限正確 (700)"
else
log_warning "密鑰目錄權限為 $PERM，建議修改為 700"
chmod 700 .secrets
fi
# 3. 檢查資料庫加密
if [ -f "config.db" ] && command -v sqlite3 &> /dev/null; then
SAMPLE=$(sqlite3 config.db "SELECT api_key FROM exchanges WHERE api_key != '' LIMIT 1;" 2>/dev/null || echo "")
if echo "$SAMPLE" | grep -q "=="; then
log_success "數據庫密鑰已加密（Base64 格式）"
else
log_warning "數據庫可能未加密或無數據"
fi
fi
log_success "部署驗證通過"
}
# 打印後續步驟
print_next_steps() {
echo ""
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo -e "${GREEN}🎉 加密系統部署成功！${NC}"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""
echo "📝 後續步驟:"
echo ""
echo " 1️⃣ 啟動後端服務:"
echo " $ go run main.go"
echo ""
echo " 2️⃣ 啟動前端服務:"
echo " $ cd web && npm run dev"
echo ""
echo " 3️⃣ 驗證加密功能:"
echo " $ curl http://localhost:8080/api/crypto/public-key"
echo ""
echo " 4️⃣ 查看審計日誌:"
echo " $ sqlite3 config.db 'SELECT * FROM audit_logs ORDER BY timestamp DESC LIMIT 10;'"
echo ""
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""
echo "⚠️ 重要提醒:"
echo ""
echo " • 請妥善保管 .secrets/ 目錄（已設置為 700 權限）"
echo " • 生產環境務必使用環境變數管理主密鑰"
echo " • 定期執行密鑰輪換（建議每季度一次）"
echo " • 數據庫備份已保存，驗證無誤後可手動刪除"
echo ""
echo "📚 詳細文檔:"
echo " - 快速開始: cat SECURITY_QUICKSTART.md"
echo " - 完整指南: cat ENCRYPTION_DEPLOYMENT.md"
echo ""
}
# 主函數
main() {
echo ""
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo -e "${BLUE}🔐 NOFX 加密系統部署腳本${NC}"
echo "━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━"
echo ""
# 確認執行
log_warning "此腳本將:"
echo " 1. 備份現有數據庫"
echo " 2. 生成 RSA-4096 密鑰對"
echo " 3. 生成 AES-256 主密鑰"
echo " 4. 遷移現有數據到加密格式"
echo " 5. 設置環境變數"
echo ""
read -p "是否繼續？(y/N): " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
log_info "已取消部署"
exit 0
fi
# 執行部署步驟
check_dependencies
backup_database
setup_secrets_dir
update_gitignore
install_dependencies
run_tests
migrate_data
setup_env_vars
verify_deployment
print_next_steps
}
# 執行主函數
main

71
docker-compose.yml
View File

@@ -1,44 +1,4 @@
services:
# PostgreSQL Database
postgres:
image: postgres:15-alpine
container_name: nofx-postgres
restart: unless-stopped
environment:
POSTGRES_DB: ${POSTGRES_DB:-nofx}
POSTGRES_USER: ${POSTGRES_USER:-nofx}
POSTGRES_PASSWORD: ${POSTGRES_PASSWORD:-nofx123456}
volumes:
- postgres_data:/var/lib/postgresql/data
- ./db/init.sql:/docker-entrypoint-initdb.d/init.sql:ro
ports:
- "${POSTGRES_PORT:-5433}:5432"
networks:
- nofx-network
healthcheck:
test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER:-nofx}"]
interval: 10s
timeout: 5s
retries: 5
# Redis Cache
redis:
image: redis:7-alpine
container_name: nofx-redis
restart: unless-stopped
command: redis-server --appendonly yes --requirepass ${REDIS_PASSWORD:-redis123456}
volumes:
- redis_data:/data
ports:
- "${REDIS_PORT:-6380}:6379"
networks:
- nofx-network
healthcheck:
test: ["CMD", "redis-cli", "--raw", "incr", "ping"]
interval: 10s
timeout: 3s
retries: 5
# Backend service (API and core logic)
nofx:
build:
@@ -46,31 +6,22 @@ services:
dockerfile: ./docker/Dockerfile.backend
container_name: nofx-trading
restart: unless-stopped
stop_grace_period: 30s # 允许应用有 30 秒时间优雅关闭
ports:
- "${NOFX_BACKEND_PORT:-8080}:8080"
volumes:
- ./config.json:/app/config.json:ro
- ./config.db:/app/config.db
- ./beta_codes.txt:/app/beta_codes.txt:ro
- ./decision_logs:/app/decision_logs
- ./prompts:/app/prompts
- ./secrets:/app/secrets:ro # RSA密钥文件
- /etc/localtime:/etc/localtime:ro # Sync host time
environment:
- TZ=${NOFX_TIMEZONE:-Asia/Shanghai} # Set timezone
- AI_MAX_TOKENS=4000 # AI响应的最大token数（默认2000，建议4000-8000）
- DATA_ENCRYPTION_KEY=${DATA_ENCRYPTION_KEY} # 数据加密密钥
- POSTGRES_HOST=postgres
- POSTGRES_PORT=5432
- POSTGRES_DB=${POSTGRES_DB:-nofx}
- POSTGRES_USER=${POSTGRES_USER:-nofx}
- POSTGRES_PASSWORD=${POSTGRES_PASSWORD:-nofx123456}
- REDIS_HOST=redis
- REDIS_PORT=6379
- REDIS_PASSWORD=${REDIS_PASSWORD:-redis123456}
depends_on:
postgres:
condition: service_healthy
redis:
condition: service_healthy
- DATA_ENCRYPTION_KEY=${DATA_ENCRYPTION_KEY} # 数据库加密密钥
- JWT_SECRET=${JWT_SECRET} # JWT认证密钥
networks:
- nofx-network
healthcheck:
@@ -88,15 +39,13 @@ services:
container_name: nofx-frontend
restart: unless-stopped
ports:
- "${NOFX_FRONTEND_PORT:-3000}:443"
volumes:
- ./certs:/etc/nginx/certs:ro # 挂载证书目录
- "${NOFX_FRONTEND_PORT:-3000}:80"
networks:
- nofx-network
depends_on:
- nofx
healthcheck:
test: ["CMD", "wget", "--no-verbose", "--tries=1", "--spider", "http://localhost/health"]
test: ["CMD", "curl", "-f", "http://127.0.0.1/health"]
interval: 30s
timeout: 10s
retries: 3
@@ -104,8 +53,4 @@ services:
networks:
nofx-network:
driver: bridge
volumes:
postgres_data:
redis_data:
driver: bridge

17
docs/getting-started/README.md
View File

@@ -68,6 +68,23 @@ After deployment:
3. **Create Traders** → Combine AI models with exchanges
4. **Start Trading** → Monitor performance in dashboard
### 🔐 Optional: Enable Admin Mode (Single-User)
For single-tenant/self-hosted usage, you can enable strict admin-only access:
1) In `config.json` set the 2 fields below:
```jsonc
{
"admin_mode": true,
...
"jwt_secret": "YOUR_JWT_SCR"
}
```
2) Set environment variables (Docker compose already wired):
- `NOFX_ADMIN_PASSWORD` — admin password (plaintext; hashed on startup)
3) Login at `/login` using the admin password. All non-essential endpoints are blocked to unauthenticated users while admin mode is enabled.
---
## ⚠️ Important Notes

111
docs/i18n/en/PRIVACY POLICY.md Normal file
View File

@@ -0,0 +1,111 @@
NOFX Privacy Policy
Last Updated: 2025.11.07
I. Introduction and Scope
A. Introduction
This Privacy Policy (hereinafter referred to as the "Policy") is designed to inform you, as a user of our website, how we handle your personal information. This Policy applies to information collected through nofxai.com and any of its subdomains (hereinafter referred to as the "Website") by NOFX (hereinafter referred to as "we" or "us") acting as the data controller.
B. Core Policy Distinction: Website Data vs. Software Data
The core of this Policy is the distinction between the "Website" and the "Software."
Website Data: This Policy governs the personal information we collect and process from visitors to our "Website."
Software Data: This Policy does NOT apply to any data you process in your self-hosted instance of the NOFX AI Trading Operating System (hereinafter referred to as the "Software") that you download, install, and run on your own.
For the "Software," you are the sole data controller of all data (including but not limited to API keys, private keys, trading data, etc.) that you input or process. We cannot access, view, collect, or process any information you enter into your local instance of the "Software."
II. Information We Collect (on the Website) and How We Use It
A. Information We Collect (Website)
Based on your user queries, we have limited our data collection practices to the bare minimum. We do not require you to create an account, fill out forms, or provide any personally identifiable information (PII) when visiting the "Website."
The only category of data we collect is "automatically collected data," which is implemented through Google Analytics (GA4).
B. Google Analytics (GA4) Disclosure
Our "Website" uses the Google Analytics 4 (GA4) service. This is the only way we collect information. According to Google's Terms of Service, we must disclose this use to you.
Types of Data Collected: GA4 automatically collects certain information about your visit, which is generally non-personally identifiable. This may include:
Number of users
Session statistics
Approximate geographic location (non-precise)
Browser and device information
Data Usage: We use this aggregated data solely to better understand how users access and use our services, thereby improving the performance and user experience of our "Website."
Your Choices and Opt-Out: We respect your privacy choices. If you do not want GA4 to collect your visit data, you can opt out by installing the Google Analytics Opt-out Browser Add-on. You can obtain this add-on by visiting this link: [Google Analytics Opt-out Add-on (by Google)](https://chromewebstore.google.com/detail/google-analytics-opt-out/fllaojicojecljbmefodhfapmkghcbnh?hl=en).
C. Cookies and Tracking Mechanisms
GA4's operation relies on first-party cookies. Specifically, it may use cookies such as _ga and _ga_<container-id> to distinguish unique users and sessions. We explicitly state that we do not use these cookies for advertising or user profiling purposes.
III. Information We Do NOT Collect (Software)
This section aims to clearly articulate our data isolation stance regarding the "Software."
A. Non-Custodial Statement
We (NOFX) are a non-custodial software provider. This means we never hold, control, or access your funds, assets, or sensitive credentials.
B. Explicit Non-Collection List
When you download, install, and use the self-hosted "Software," we absolutely do not collect, access, store, process, or transmit any of the following data in any way:
Any API keys for third-party exchanges (such as Binance)
Any API keys for third-party AI services (such as DeepSeek, Qwen)
Your API secret keys corresponding to your API keys
Your cryptocurrency private keys (e.g., Ethereum private keys for Hyperliquid or Aster DEX)
Your wallet "secret phrases" (mnemonic phrases)
Your trading history, positions, account balances, or any other financial information
Any personal data you configure in your local instance of the "Software"
C. Note on Local Encryption
We are aware that the "Software" provides functionality to encrypt user-entered API keys and private keys. We clarify here that this encryption process is performed and managed entirely on your own device (locally). This data is never transmitted to us or any third party after encryption. This encryption feature is designed to protect your data from unauthorized access to your local device, not to share it with us.
IV. Data Sharing, Retention, and Security (Website Data)
A. Third-Party Sharing
Except as disclosed in this Policy (i.e., sharing GA4-collected analytics data with our service provider Google), we do not share, sell, rent, or trade any of your personal information with any third parties.
B. Data Retention
We retain the aggregated analytics data collected by GA4 only for the period reasonably necessary to achieve the purposes described in this Policy (i.e., website analytics and improvement).
C. Data Security
We employ commercially reasonable security measures (e.g., using HTTPS) to protect the transmission of the "Website" and to safeguard the limited information we collect (through GA4).
V. Your Data Protection Rights (GDPR & CCPA)
A. Scope of Rights
Under applicable data protection laws (such as GDPR or CCPA), you may have certain rights. We clarify here that these rights apply only to the limited GA4 analytics data we hold as the data controller, collected through the "Website." We cannot fulfill any requests regarding "Software" data, as we do not hold such data.
B. List of Rights
Under the law, you have the right to:
Right of Access: You have the right to request a copy of the personal data we hold about you.
Right to Rectification: You have the right to request that we correct information you believe is inaccurate or incomplete.
Right to Erasure (Right to be Forgotten): Under certain conditions, you have the right to request that we delete your personal data.
Right to Restrict Processing: Under certain conditions, you have the right to request that we restrict the processing of your personal data.
Right to Object to Processing: Under certain conditions, you have the right to object to our processing of your personal data.
C. How to Exercise Your Rights
If you wish to exercise any of the above rights, please contact us using the contact information provided at the end of this Policy.
VI. Children's Privacy
Our "Website" and "Software" are not intended for or directed to individuals under the age of 18. We do not knowingly collect personal information from children under 18.
VII. Changes to the Privacy Policy
We reserve the right to modify this Privacy Policy at any time. Any changes will be notified by posting an updated version on the "Website" and updating the "Last Updated" date.
VIII. Contact Information
If you have any questions about this Privacy Policy or our data processing practices, please contact us:
[@nofx_ai](https://x.com/nofx_ai)

155
docs/i18n/en/TERMS OF SERVICE.md Normal file
View File

@@ -0,0 +1,155 @@
NOFX Terms of Service
Last Updated: November 7, 2025
1. Introduction and Acceptance of Terms
A. Agreement
These Terms of Service (the "Agreement" or "Terms") constitute a legally binding agreement between you (the "User" or "you") and NOFX ("we," "our," or "NOFX").
B. Scope
These Terms govern your access to and use of the website nofxai.com (the "Website"), as well as your download, installation, and use of the NOFX AI Trading Operating System (the "Software").
C. Acceptance of Terms
By accessing the Website or downloading, installing, or using the Software in any manner, you acknowledge that you have read, understood, and agree to be bound by these Terms. If you do not agree to these Terms, you must immediately cease accessing the Website and using the Software.
D. Age Requirement
You must be at least 18 years old, or have reached the age of majority in your jurisdiction, to use the Website and Software.
2. Software License and Service Model
A. Website
We grant you a limited, non-exclusive, non-transferable, revocable license to access and use the Website for informational purposes.
B. Software (Self-Hosted)
AGPL-3.0 License: We expressly inform you that the source code of the NOFX Software is provided to you under the GNU Affero General Public License v3.0 (AGPL-3.0) (the "AGPL-3.0").
Nature of Terms: This Agreement does not modify, supersede, or limit your rights under AGPL-3.0. AGPL-3.0 is your software license. This Agreement is a service agreement that governs your use of our entire service ecosystem (including the Website and Software usage) and establishes key responsibilities and disclaimers described below that are not covered by AGPL-3.0.
3. Critical Risk Acknowledgment (Financial)
This section relates to your material interests. Please read carefully. All terms in this section are presented in prominent capital letters to ensure their legal significance.
A. No Financial or Investment Advice:
THE WEBSITE AND SOFTWARE ARE PROVIDED SOLELY AS TECHNICAL TOOLS. WE ARE NOT A FINANCIAL INSTITUTION, BROKER, FINANCIAL ADVISOR, OR INVESTMENT ADVISOR. NOTHING PROVIDED BY THIS SERVICE, INCLUDING ANY CONTENT, FUNCTIONALITY, OR AI OUTPUT, CONSTITUTES FINANCIAL, INVESTMENT, LEGAL, TAX, OR TRADING ADVICE.
B. Extreme Risk of Financial Loss:
YOU ACKNOWLEDGE AND AGREE THAT TRADING CRYPTOCURRENCIES AND OTHER FINANCIAL ASSETS IS HIGHLY VOLATILE, SPECULATIVE, AND CARRIES INHERENT RISKS. THE USE OF AUTOMATED, ALGORITHMIC, AND AI-DRIVEN TRADING SYSTEMS (SUCH AS THIS SOFTWARE) INVOLVES SIGNIFICANT AND UNIQUE RISKS AND MAY RESULT IN SUBSTANTIAL OR TOTAL FINANCIAL LOSS.
C. No Guarantee of Profit or Performance:
WE MAKE NO EXPRESS OR IMPLIED WARRANTIES, REPRESENTATIONS, OR GUARANTEES REGARDING THE PERFORMANCE, PROFITABILITY, OR ACCURACY OF ANY TRADING SIGNALS GENERATED BY THE SOFTWARE. PAST PERFORMANCE OF ANY AI MODEL OR TRADING STRATEGY DOES NOT IN ANY WAY REPRESENT OR GUARANTEE FUTURE RESULTS.
D. User's Complete Responsibility:
YOU BEAR COMPLETE AND SOLE RESPONSIBILITY FOR ALL YOUR TRADING DECISIONS, ORDERS, EXECUTIONS, AND ULTIMATE RESULTS. ALL TRADES EXECUTED THROUGH THE SOFTWARE ARE DEEMED TO BE BASED ON YOUR AUTONOMOUS DECISIONS AND RISK TOLERANCE, AND ARE AT YOUR OWN RISK.
4. Critical Risk Acknowledgment (Artificial Intelligence and Software)
This section also relates to your material interests and is presented in capital letters.
A. "AS IS" and "AS AVAILABLE" Disclaimer:
THE WEBSITE AND SOFTWARE ARE PROVIDED "AS IS" AND "AS AVAILABLE" WITHOUT WARRANTIES OF ANY KIND, EITHER EXPRESS OR IMPLIED. WE DO NOT GUARANTEE THAT THE SERVICE WILL BE UNINTERRUPTED, ACCURATE, ERROR-FREE, SECURE, OR FREE FROM VIRUSES OR OTHER HARMFUL COMPONENTS.
B. AI Output and "Hallucination" Disclaimer:
GIVEN THAT THE CORE FUNCTIONALITY OF THIS SOFTWARE RELIES ON THIRD-PARTY AI MODELS, YOU MUST UNDERSTAND AND ACCEPT THE INHERENT LIMITATIONS OF AI TECHNOLOGY. AI OUTPUTS (INCLUDING AI AGENT DECISIONS) ARE EMERGING TECHNOLOGY, AND THEIR LEGAL LIABILITY REMAINS UNCLEAR.
YOU HEREBY ACKNOWLEDGE AND AGREE THAT:
AI Output May Be Defective: AI MODELS AND OUTPUTS INTEGRATED OR GENERATED BY THE SOFTWARE MAY CONTAIN ERRORS, INACCURACIES, OMISSIONS, BIASES, OR PRODUCE WHAT IS KNOWN AS "HALLUCINATIONS" - COMPLETELY FALSE OR FABRICATED INFORMATION.
You Bear All Risk: YOU AGREE THAT ANY USE OR RELIANCE ON AI-GENERATED OUTPUT (INCLUDING ANY TRADING DECISIONS) IS AT YOUR SOLE RISK.
Not a Substitute for Professional Advice: YOU MUST NOT TREAT AI OUTPUT AS THE SOLE SOURCE OF TRUTH, FACTUAL INFORMATION, OR AS A SUBSTITUTE FOR PROFESSIONAL FINANCIAL ADVICE.
C. User's Ultimate Responsibility:
YOU AGREE TO BEAR ULTIMATE RESPONSIBILITY FOR ALL ACTIONS TAKEN BASED ON AI OUTPUT. YOU MUST CONDUCT YOUR OWN DUE DILIGENCE AND VERIFY THE ACCURACY OF INFORMATION BEFORE EXECUTING ANY TRADES SUGGESTED BY AI.
5. User Obligations and Security Responsibilities
A. Complete Responsibility for API Keys and Private Keys
This is one of the most critical terms of this Agreement, relating to the core functionality of the Software.
YOU ACKNOWLEDGE AND AGREE THAT YOU BEAR EXCLUSIVE, SOLE, AND COMPLETE RESPONSIBILITY FOR PROTECTING, PRESERVING, SECURING, AND BACKING UP ALL API KEYS, SECRET KEYS, WALLET ADDRESSES, PRIVATE KEYS, AND ANY SEED PHRASES ("SECRET PHRASE") USED WITH THE SOFTWARE. YOU MUST MAINTAIN ADEQUATE SECURITY AND CONTROL OVER THESE CREDENTIALS.
B. Non-Custodial Acknowledgment
YOU ACKNOWLEDGE AND AGREE THAT WE (NOFX) ARE A NON-CUSTODIAL SOFTWARE PROVIDER. WE NEVER COLLECT, STORE, RECEIVE, OR IN ANY WAY ACCESS YOUR API KEYS, PRIVATE KEYS, OR SEED PHRASES. WE WILL NEVER REQUEST THAT YOU SHARE THESE CREDENTIALS.
CONSEQUENTLY, WE HAVE NO ABILITY TO ACCESS YOUR FUNDS, RECOVER YOUR LOST KEYS, OR CANCEL OR REVERSE ANY TRANSACTIONS. YOU BEAR COMPLETE RESPONSIBILITY FOR ANY AND ALL LOSSES RESULTING FROM THE LOSS, THEFT, OR COMPROMISE OF YOUR KEYS (WHETHER API KEYS OR PRIVATE KEYS).
C. User-Managed Encryption
YOU ACKNOWLEDGE THAT IN YOUR SELF-HOSTED INSTANCE, YOU ARE RESPONSIBLE FOR ENCRYPTING YOUR KEYS AND CREDENTIALS IN ALL STORAGE AND COMMUNICATIONS. ANY ENCRYPTION FUNCTIONALITY PROVIDED IN THE SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY SECURITY GUARANTEES.
D. Third-Party Terms
WHEN USING THE SOFTWARE TO CONNECT TO ANY THIRD-PARTY SERVICES (SUCH AS BINANCE, HYPERLIQUID, DEEPSEEK, QWEN, ETC.), YOU ARE RESPONSIBLE FOR COMPLYING WITH ALL TERMS OF SERVICE, FEE POLICIES, AND USAGE RULES OF SUCH THIRD-PARTY SERVICES.
6. Acceptable Use Policy (AUP)
YOU AGREE NOT TO USE THE WEBSITE OR SOFTWARE FOR ANY ILLEGAL PURPOSES OR PURPOSES PROHIBITED BY THESE TERMS. PROHIBITED ACTIVITIES INCLUDE (BUT ARE NOT LIMITED TO):
Illegal Activities: Engaging in any activities that violate local, state, national, or international laws or regulations.
System Abuse: Engaging in any "hacking," "spamming," "mail bombing," or "denial of service attacks."
Security: Attempting to probe, scan, or test the vulnerability of the Website or related networks, or breaching security or authentication measures.
Data Scraping: Using any automated systems (including "data scraping," "web scraping," or "bots") to extract data from the Website for commercial purposes.
Malware: Introducing any viruses, trojans, worms, or other malicious code.
7. Intellectual Property (IP)
A. Website Content
We and our licensors reserve all intellectual property rights in the Website and all its content (including text, graphics, logos, and visual design elements).
B. Software Intellectual Property
The Software is an open-source project. Its intellectual property rights are governed by the AGPL-3.0 license.
C. User Content/Feedback
If you provide us with any feedback, strategies, suggestions, or contributions ("User-Generated Content"), you grant us a perpetual, irrevocable, worldwide, royalty-free license to use, host, reproduce, modify, and display such content.
8. Limitation of Liability and Indemnification
This section limits our legal liability and requires you to assume responsibility for damages caused by you. Please read carefully. All terms in this section are presented in prominent capital letters.
A. Limitation of Liability:
THIS TERM IS FORMULATED BASED ON AN ANALYSIS OF LEGAL ACTIONS FACED BY CUSTODIAL SERVICE PROVIDERS AND LEVERAGES OUR LEGAL POSITION AS A NON-CUSTODIAL, SELF-HOSTED SOFTWARE PROVIDER.
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, NOFX (AND ITS AFFILIATES, DIRECTORS, EMPLOYEES, OR LICENSORS) SHALL NOT BE LIABLE TO YOU UNDER ANY CIRCUMSTANCES FOR ANY INDIRECT, PUNITIVE, INCIDENTAL, SPECIAL, CONSEQUENTIAL, OR EXEMPLARY DAMAGES, INCLUDING BUT NOT LIMITED TO LOSS OF PROFITS, FUNDS, OR DATA, OR DAMAGES RESULTING FROM THEFT OR LOSS OF YOUR API KEYS OR PRIVATE KEYS, ARISING FROM:
YOUR USE OR INABILITY TO USE THE WEBSITE OR SOFTWARE;
ANY DEFECTS, ERRORS, VIRUSES, INACCURACIES, OR DELAYS IN THE SOFTWARE;
ANY AI-GENERATED OUTPUT, "HALLUCINATIONS," ERRONEOUS TRADING SIGNALS, OR FAILED STRATEGIES;
ANY UNAUTHORIZED ACCESS TO OR USE OF YOUR SELF-HOSTED INSTANCE OR ANY DEVICE WHERE YOU STORE YOUR KEYS;
ANY AND ALL FINANCIAL LOSSES RESULTING FROM ANY TRADES EXECUTED AUTOMATICALLY OR SUGGESTED BY THE SOFTWARE.
IF NOFX IS FOUND TO HAVE DIRECT LIABILITY TO YOU, OUR MAXIMUM AGGREGATE LIABILITY SHALL BE LIMITED TO THE GREATER OF THE FEES YOU PAID TO US IN THE TWELVE (12) MONTHS PRECEDING THE CLAIM (IF ANY) OR ONE HUNDRED DOLLARS ($100.00).
B. Indemnification:
YOU AGREE TO DEFEND, INDEMNIFY, AND HOLD HARMLESS NOFX AND ITS AFFILIATES FROM ANY CLAIMS, DEMANDS, ACTIONS, LOSSES, DAMAGES, LIABILITIES, COSTS, AND EXPENSES (INCLUDING REASONABLE ATTORNEYS' FEES) ARISING FROM OR IN ANY WAY RELATED TO: (A) YOUR ACCESS OR USE OF THE SOFTWARE; (B) YOUR VIOLATION OF THESE TERMS; (C) YOUR VIOLATION OF ANY THIRD-PARTY RIGHTS, INCLUDING BUT NOT LIMITED TO THE TERMS OF SERVICE OF ANY EXCHANGE OR AI PROVIDER TO WHICH YOU CONNECT; OR (D) ANY THIRD-PARTY INTELLECTUAL PROPERTY INFRINGEMENT CLAIMS ARISING FROM YOUR USE OF AI OUTPUT.
9. Termination
A. Termination by Us
WE RESERVE THE RIGHT, AT OUR SOLE DISCRETION, TO IMMEDIATELY OR UPON NOTICE SUSPEND OR TERMINATE YOUR ACCESS TO THE WEBSITE (AND ANY FUTURE HOSTED SERVICES WE MAY OFFER) IN THE EVENT YOU VIOLATE THESE TERMS OR THE ACCEPTABLE USE POLICY.
B. Effect of Termination
UPON TERMINATION, YOUR LICENSE TO THE SOFTWARE UNDER AGPL-3.0 (IF YOU HAVE DOWNLOADED IT) REMAINS VALID, BUT YOUR RIGHT TO USE OUR WEBSITE WILL BE REVOKED. ALL TERMS RELATED TO DISCLAIMERS, LIMITATION OF LIABILITY, INDEMNIFICATION, INTELLECTUAL PROPERTY, AND GOVERNING LAW SHALL SURVIVE TERMINATION.
10. Modification of Terms
WE RESERVE THE RIGHT TO MODIFY OR REPLACE THESE TERMS AT ANY TIME AT OUR SOLE DISCRETION. UNLIKE CERTAIN "UNILATERAL MODIFICATION" CLAUSES IN THE INDUSTRY THAT MAY BE DEEMED UNENFORCEABLE, WE WILL PROVIDE NOTICE OF MATERIAL CHANGES BY POSTING THE UPDATED TERMS ON THE WEBSITE AND UPDATING THE "LAST UPDATED" DATE. YOUR CONTINUED ACCESS TO THE WEBSITE OR USE OF THE SOFTWARE AFTER SUCH CHANGES TAKE EFFECT CONSTITUTES YOUR ACCEPTANCE OF THE NEW TERMS.
11. General Terms
A. Governing Law
THIS AGREEMENT SHALL BE GOVERNED BY AND CONSTRUED IN ACCORDANCE WITH THE LAWS OF [SPECIFIED JURISDICTION], WITHOUT REGARD TO ITS CONFLICT OF LAW PRINCIPLES.
B. Dispute Resolution
EXCEPT WHERE PROHIBITED BY APPLICABLE LAW, YOU AGREE THAT ALL DISPUTES ARISING FROM OR RELATED TO THIS AGREEMENT SHALL BE FINALLY RESOLVED THROUGH BINDING ARBITRATION CONDUCTED IN [SPECIFIED LOCATION].
C. Severability and Waiver
IF ANY PROVISION OF THIS AGREEMENT IS FOUND TO BE ILLEGAL OR UNENFORCEABLE, THE REMAINING PROVISIONS SHALL CONTINUE IN FULL FORCE AND EFFECT. FAILURE BY A PARTY TO ENFORCE ANY RIGHT OR PROVISION OF THIS AGREEMENT SHALL NOT BE DEEMED A WAIVER OF SUCH RIGHT OR PROVISION.
D. Entire Agreement
THIS AGREEMENT (TOGETHER WITH THE AGPL-3.0 SOFTWARE LICENSE) CONSTITUTES THE ENTIRE AGREEMENT BETWEEN YOU AND NOFX REGARDING THE SUBJECT MATTER.

111
docs/i18n/ja/PRIVACY POLICY.md Normal file
View File

@@ -0,0 +1,111 @@
NOFXプライバシーポリシー
最終更新日: 2025.11.07
I. はじめに及び適用範囲
A. 導入
本プライバシーポリシー(以下「本ポリシー」といいます)は、当社のウェブサイトのユーザーである皆様に対して、個人情報をどのように取り扱うかをお知らせするものです。本ポリシーは、NOFX(以下「当社」といいます)がデータ管理者として、nofxai.comおよびそのすべてのサブドメイン(以下「ウェブサイト」といいます)を通じて収集する情報に適用されます。
B. 核心的な方針の区別:ウェブサイトデータとソフトウェアデータ
本ポリシーの核心は、「ウェブサイト」と「ソフトウェア」の区別です。
ウェブサイトデータ:本ポリシーは、「ウェブサイト」の訪問者から収集し処理する個人情報を管理します。
ソフトウェアデータ:本ポリシーは、お客様がダウンロード、インストール、および実行するNOFX AIトレーディングオペレーティングシステム(以下「ソフトウェア」といいます)のセルフホスティングインスタンスで処理するいかなるデータにも適用されません。
「ソフトウェア」に関しては、お客様が入力または処理するすべてのデータ(APIキー、秘密鍵、取引データなどを含むがこれらに限定されません)の唯一のデータ管理者はお客様です。当社は、お客様が「ソフトウェア」のローカルインスタンスに入力した情報にアクセス、表示、収集、または処理することはできません。
II. 当社が収集する情報(ウェブサイト上)とその使用方法
A. 当社が収集する情報(ウェブサイト)
ユーザーのご要望に基づき、データ収集の実施を最小限に制限しています。「ウェブサイト」にアクセスする際、アカウントの作成、フォームへの入力、または個人を特定できる情報(PII)の提供を求めることはありません。
当社が収集するデータの唯一のカテゴリーは、Google Analytics(GA4)を通じて実装される「自動収集データ」です。
B. Google Analytics(GA4)の開示
当社の「ウェブサイト」はGoogle Analytics 4(GA4)サービスを使用しています。これが当社が情報を収集する唯一の方法です。Googleのサービス規約に従い、この使用をお客様に開示する必要があります。
収集されるデータの種類:GA4は、訪問に関する特定の情報を自動的に収集します。これらは通常、個人を特定できない情報です。これには以下が含まれる場合があります:
ユーザー数
セッション統計情報
おおよその地理的位置(精確ではない)
ブラウザとデバイス情報
データの使用目的:当社は、この集約データを、ユーザーがどのように当社のサービスにアクセスし使用するかをより良く理解し、「ウェブサイト」のパフォーマンスとユーザーエクスペリエンスを向上させる目的でのみ使用します。
お客様の選択とオプトアウト:当社はお客様のプライバシーに関する選択を尊重します。GA4による訪問データの収集を希望されない場合は、Google Analyticsオプトアウトブラウザアドオンをインストールすることでオプトアウトできます。このアドオンは次のリンクから入手できます:[Google Analytics Opt-out Add-on (by Google)](https://chromewebstore.google.com/detail/google-analytics-opt-out/fllaojicojecljbmefodhfapmkghcbnh?hl=en)。
C. Cookieとトラッキングメカニズム
GA4の運用はファーストパーティCookieに依存しています。具体的には、_gaおよび_ga_<container-id>などのCookieを使用して、ユニークユーザーとセッションを区別する場合があります。当社は、これらのCookieを広告またはユーザープロファイリングの目的で使用しないことを明示します。
III. 当社が収集しない情報(ソフトウェア)
本セクションは、「ソフトウェア」に関する当社のデータ分離の立場を明確に説明することを目的としています。
A. 非カストディアル宣言
当社(NOFX)は非カストディアル型のソフトウェアプロバイダーです。これは、お客様の資金、資産、または機密資格情報を保持、管理、またはアクセスすることは決してないことを意味します。
B. 明確な非収集リスト
セルフホスティング型「ソフトウェア」をダウンロード、インストール、および使用する際、当社は以下のいかなるデータも決して収集、アクセス、保存、処理、または送信しません:
サードパーティの取引所(Binanceなど)のAPIキー
サードパーティのAIサービス(DeepSeek、Qwenなど)のAPIキー
APIキーに対応する秘密鍵(Secret Keys)
暗号通貨の秘密鍵(例:HyperliquidまたはAster DEX用のイーサリアム秘密鍵)
ウォレットの「シークレットフレーズ」(ニーモニックフレーズ)
取引履歴、ポジション状況、アカウント残高、またはその他の財務情報
「ソフトウェア」のローカルインスタンスで設定する個人データ
C. ローカル暗号化に関する注記
当社は、「ソフトウェア」がユーザーが入力したAPIキーと秘密鍵を暗号化する機能を提供していることを認識しています。ここで明確にします。この暗号化プロセスは完全にお客様自身のデバイス上で(ローカルで)実行および管理されます。これらのデータは、暗号化後に当社またはサードパーティに送信されることは決してありません。この暗号化機能は、お客様のローカルデバイスへの不正アクセスからデータを保護するためであり、当社と共有するためではありません。
IV. データの共有、保持、およびセキュリティ(ウェブサイトデータ)
A. サードパーティとの共有
本ポリシーで既に開示されている場合(すなわち、サービスプロバイダーであるGoogleとGA4収集分析データを共有する)を除き、当社はお客様の個人情報をサードパーティと共有、販売、レンタル、または取引することはありません。
B. データの保持
当社は、本ポリシーで説明されている目的(すなわち、ウェブサイト分析および改善)を達成するために合理的に必要な期間のみ、GA4が収集した集約分析データを保持します。
C. データセキュリティ
当社は、「ウェブサイト」の送信を保護し、(GA4を通じて)限定的に収集した情報を保護するために、商業的に合理的なセキュリティ対策(例:HTTPSの使用)を採用しています。
V. お客様のデータ保護権(GDPR & CCPA)
A. 権利の範囲
適用されるデータ保護法(GDPRまたはCCPAなど)に基づき、お客様は特定の権利を有する場合があります。ここで明確にします。これらの権利は、当社がデータ管理者として保持する、「ウェブサイト」を通じて収集した限定的なGA4分析データにのみ適用されます。当社は「ソフトウェア」データに関するいかなる要求も満たすことができません。当社はそのようなデータを保持していないためです。
B. 権利のリスト
法律の規定により、お客様は以下の権利を有します:
アクセス権:当社が保持するお客様の個人データのコピーを要求する権利があります。
訂正権:正確でないまたは不完全であると思われる情報の訂正を要求する権利があります。
削除権(忘れられる権利):特定の条件下で、お客様の個人データの削除を要求する権利があります。
処理制限権:特定の条件下で、お客様の個人データの処理を制限することを要求する権利があります。
処理への異議権:特定の条件下で、お客様の個人データの処理に異議を唱える権利があります。
C. お客様の権利の行使方法
上記のいずれかの権利を行使したい場合は、本ポリシーの末尾に記載されている連絡先情報を使用してご連絡ください。
VI. 児童のプライバシー
当社の「ウェブサイト」および「ソフトウェア」は、18歳未満の個人を対象としておらず、向けられてもいません。当社は18歳未満の児童から故意に個人情報を収集することはありません。
VII. プライバシーポリシーの変更
当社は、本プライバシーポリシーをいつでも修正する権利を留保します。変更があった場合は、「ウェブサイト」に更新版を掲載し、「最終更新日」の日付を変更することで通知します。
VIII. 連絡先情報
本プライバシーポリシーまたは当社のデータ処理の実施についてご質問がある場合は、以下までお問い合わせください:
[@nofx_ai](https://x.com/nofx_ai)

1446
docs/i18n/ja/README.md Normal file
View File

File diff suppressed because it is too large Load Diff

156
docs/i18n/ja/TERMS OF SERVICE.md Normal file
View File

@@ -0,0 +1,156 @@
NOFX 利用規約(サービス利用規約)
最終更新日:2025年11月7日
1. はじめにと規約の承諾
A. 本契約
本利用規約(以下「本契約」または「本規約」)は、お客様(以下「お客様」または「ユーザー」)とNOFX(以下「当社」または「NOFX」)との間で法的拘束力を有する契約です。
B. 適用範囲
本規約は、お客様によるnofxai.comウェブサイト(以下「本ウェブサイト」)へのアクセスおよび利用、ならびにNOFX AI取引オペレーティングシステム(以下「本ソフトウェア」)のダウンロード、インストール、および使用を管理します。
C. 規約の承諾
本ウェブサイトへのアクセス、または本ソフトウェアのダウンロード、インストール、もしくはいかなる方法による使用によって、お客様は本規約を読み、理解し、本規約に拘束されることに同意したものとみなされます。本規約に同意されない場合は、直ちに本ウェブサイトへのアクセスおよび本ソフトウェアの使用を中止しなければなりません。
D. 年齢要件
本ウェブサイトおよび本ソフトウェアを使用するには、18歳以上、またはお客様の管轄区域における法定成年年齢に達している必要があります。
2. ソフトウェアライセンスおよびサービスモデル
A. ウェブサイト
当社は、情報目的で本ウェブサイトにアクセスし使用するための、限定的、非独占的、譲渡不可、取消可能なライセンスをお客様に付与します。
B. ソフトウェア(セルフホスト型)
AGPL-3.0ライセンス:当社は、NOFXソフトウェアのソースコードが、GNU Affero General Public License v3.0(AGPL-3.0)(以下「AGPL-3.0」)に基づいてお客様に提供されることを明示的にお知らせします。
規約の性質:本契約は、AGPL-3.0に基づくお客様の権利を変更、置換、または制限するものではありません。AGPL-3.0はお客様のソフトウェアライセンスです。本契約はサービス契約であり、当社のサービスエコシステム全体(本ウェブサイトおよび本ソフトウェアの使用を含む)の使用を管理し、AGPL-3.0でカバーされていない、以下に記載される重要な責任と免責事項を確立するものです。
3. 重要なリスクの確認(財務)
本セクションはお客様の重大な利益に関わります。注意深くお読みください。本セクションのすべての条項は、その法的重要性を確保するために、目立つ大文字で表示されています。
A. 財務または投資アドバイスの不提供:
本ウェブサイトおよび本ソフトウェアは、技術的ツールとしてのみ提供されます。当社は金融機関、ブローカー、財務アドバイザー、または投資アドバイザーではありません。本サービスによって提供されるコンテンツ、機能、またはAI出力は、財務、投資、法律、税務、または取引に関するアドバイスを構成するものではありません。
B. 極度の財務損失リスク:
お客様は、暗号通貨およびその他の金融資産の取引が非常に変動性が高く、投機的であり、固有のリスクを伴うことを認識し同意します。自動化、アルゴリズム、およびAI駆動の取引システム(本ソフトウェアなど)の使用には、重大かつ固有のリスクが伴い、実質的または全体的な財務損失を招く可能性があります。
C. 利益または性能の保証なし:
当社は、本ソフトウェアの性能、収益性、または生成される取引シグナルの精度について、明示または黙示の保証、表明、または担保を一切行いません。AIモデルまたは取引戦略の過去のパフォーマンスは、将来の結果を表すものでも保証するものでもありません。
D. ユーザーの完全な責任:
お客様は、すべての取引決定、注文、実行、および最終結果について、完全かつ単独の責任を負います。本ソフトウェアを通じて実行されるすべての取引は、お客様の自律的な決定とリスク許容度に基づいており、お客様自身のリスクで行われるものとみなされます。
4. 重要なリスクの確認(人工知能とソフトウェア)
本セクションも同様にお客様の重大な利益に関わり、大文字で表示されています。
A. 「現状有姿」および「提供可能な状態で」の免責事項:
本ウェブサイトおよび本ソフトウェアは、明示または黙示を問わず、いかなる種類の保証もなく「現状有姿」(AS IS)および「提供可能な状態で」(AS AVAILABLE)提供されます。当社は、サービスが中断されない、正確である、エラーがない、安全である、またはウイルスやその他の有害なコンポーネントがないことを保証しません。
B. AI出力および「幻覚」の免責事項:
本ソフトウェアのコア機能がサードパーティのAIモデルに依存していることから、お客様はAI技術の固有の制限を理解し受け入れる必要があります。AI出力(AIエージェントの決定を含む)は新興技術であり、その法的責任はまだ明確ではありません。
お客様は以下を認識し同意します:
AI出力に欠陥がある可能性:本ソフトウェアによって統合または生成されるAIモデルおよび出力には、エラー、不正確さ、欠落、バイアス、または「幻覚」(HALLUCINATIONS)と呼ばれる完全に誤った、または虚構の情報が含まれる可能性があります。
お客様がすべてのリスクを負う:お客様は、AI生成出力(取引決定を含む)の使用または依拠は、お客様自身のリスクで行われることに同意します。
専門的アドバイスの代替にならない:お客様は、AI出力を唯一の真実の情報源、事実情報、または専門的な財務アドバイスの代替として扱ってはなりません。
C. ユーザーの最終責任:
お客様は、AI出力に基づいて取られたすべての行動について最終的な責任を負うことに同意します。お客様は、AIが推奨する取引を実行する前に、独自のデューディリジェンスを実施し、情報の正確性を検証する必要があります。
5. ユーザーの義務およびセキュリティ責任
A. APIキーおよび秘密鍵に対する完全な責任
これは本契約の最も重要な条項の一つであり、本ソフトウェアのコア機能に関わります。
お客様は、本ソフトウェアで使用するすべてのAPIキー、シークレットキー、ウォレットアドレス、秘密鍵、およびシードフレーズ(「シークレットフレーズ」)の保護、保存、セキュリティ確保、およびバックアップについて、排他的かつ単独の完全な責任を負うことを認識し同意します。お客様は、これらの認証情報に対して十分なセキュリティと管理を維持する必要があります。
B. 非カストディアルの確認
お客様は、当社(NOFX)が非カストディアルのソフトウェアプロバイダーであることを認識し同意します。当社は、お客様のAPIキー、秘密鍵、またはシードフレーズを収集、保存、受信、またはいかなる方法でもアクセスすることは一切ありません。当社は、お客様にこれらの認証情報を共有するよう要求することは一切ありません。
したがって、当社には、お客様の資金にアクセスする、紛失したキーを回復する、または取引をキャンセルまたは取り消す能力はありません。お客様のキー(APIキーまたは秘密鍵)の紛失、盗難、または漏洩に起因するすべての損失について、お客様が完全な責任を負います。
C. ユーザー管理の暗号化
お客様は、セルフホストインスタンスにおいて、すべてのストレージおよび通信でキーと認証情報を暗号化する責任があることを認識します。本ソフトウェアで提供される暗号化機能は、セキュリティ保証なしに「現状有姿」で提供されます。
D. サードパーティの規約
お客様が本ソフトウェアを使用してサードパーティのサービス(Binance、Hyperliquid、DeepSeek、Qwenなど)に接続する場合、お客様はそれらのサードパーティサービスのすべての利用規約、手数料ポリシー、および使用ルールを遵守する責任があります。
6. 利用規定(AUP)
お客様は、本ウェブサイトまたは本ソフトウェアを、違法な目的または本規約で禁止されている目的で使用しないことに同意します。禁止される活動には以下が含まれます(ただしこれらに限定されません):
違法行為:地方、州、国家、または国際的な法律または規制に違反する活動に従事すること。
システムの悪用:「ハッキング」、「スパミング」、「メール爆撃」、または「サービス拒否攻撃」(DoS)に従事すること。
セキュリティ:本ウェブサイトまたは関連ネットワークの脆弱性を調査、スキャン、またはテストしようとすること、またはセキュリティや認証措置を破ること。
データスクレイピング:商業目的で、本ウェブサイトからデータを抽出するために自動化システム(「データスクレイピング」、「ウェブスクレイピング」、または「ボット」を含む)を使用すること。
マルウェア:ウイルス、トロイの木馬、ワーム、またはその他の悪意のあるコードを導入すること。
7. 知的財産(IP)
A. ウェブサイトコンテンツ
当社および当社のライセンサーは、本ウェブサイトおよびそのすべてのコンテンツ(テキスト、グラフィック、ロゴ、ビジュアルデザイン要素を含む)に対するすべての知的財産権を保持します。
B. ソフトウェアの知的財産
本ソフトウェアはオープンソースプロジェクトです。その知的財産権はAGPL-3.0ライセンスによって管理されます。
C. ユーザーコンテンツ/フィードバック
お客様が当社にフィードバック、戦略、提案、または貢献(「ユーザー生成コンテンツ」)を提供する場合、お客様は当社に、そのコンテンツを使用、ホスト、複製、変更、および表示するための、永久的、取消不能、世界的、ロイヤリティフリーのライセンスを付与します。
8. 責任の制限および補償
本セクションは、当社の法的責任を制限し、お客様に起因する損害について責任を負うことをお客様に要求します。注意深くお読みください。本セクションのすべての条項は、目立つ大文字で表示されています。
A. 責任の制限:
本規約は、カストディアルサービスプロバイダーが直面する法的訴訟の分析に基づいて策定され、非カストディアル、セルフホストソフトウェアプロバイダーとしての当社の法的地位を活用しています。
適用法で許可される最大限の範囲において、NOFX(およびその関連会社、取締役、従業員、またはライセンサー)は、いかなる場合においても、以下に起因する間接的、懲罰的、付随的、特別、結果的、または懲戒的損害(利益、資金、データの損失、またはお客様のAPIキーまたは秘密鍵の盗難または紛失に起因する損害を含むがこれらに限定されない)について、お客様に対して責任を負いません:
本ウェブサイトまたは本ソフトウェアの使用または使用不能;
本ソフトウェアの欠陥、エラー、ウイルス、不正確さ、または遅延;
AI生成出力、「幻覚」、誤った取引シグナル、または失敗した戦略;
お客様のセルフホストインスタンスまたはお客様がキーを保存するデバイスへの不正アクセスまたは使用;
本ソフトウェアによって自動的に実行または推奨された取引に起因するすべての財務損失。
NOFXがお客様に対して直接的な責任を負うと判断された場合、当社の最大累積責任は、請求前の12か月間にお客様が当社に支払った手数料(ある場合)または100ドル($100.00)のいずれか大きい方に制限されるものとします。
B. 補償:
お客様は、以下に起因するまたは何らかの形で関連するすべての請求、要求、訴訟、損失、損害、責任、費用、および経費(合理的な弁護士費用を含む)から、NOFXおよびその関連会社を防御し、補償し、免責することに同意します:(A)本ソフトウェアへのお客様のアクセスまたは使用;(B)お客様による本規約の違反;(C)お客様が接続する取引所またはAIプロバイダーの利用規約を含むがこれに限定されない、サードパーティの権利の侵害;または(D)AI出力の使用に起因するサードパーティの知的財産侵害請求。
9. 終了
A. 当社による終了
当社は、お客様が本規約または利用規定に違反した場合、独自の裁量により、直ちにまたは通知後に、本ウェブサイト(および当社が将来提供する可能性のあるホスティングサービス)へのお客様のアクセスを一時停止または終了する権利を留保します。
B. 終了の効力
終了後、お客様がAGPL-3.0に基づく本ソフトウェアのライセンス(ダウンロード済みの場合)は引き続き有効ですが、本ウェブサイトを使用する権利は取り消されます。免責事項、責任の制限、補償、知的財産、および準拠法に関するすべての条項は、終了後も存続します。
10. 規約の変更
当社は、独自の裁量により、いつでも本規約を変更または置換する権利を留保します。業界における一部の「一方的な変更」条項が執行不能とみなされる可能性があるのとは異なり、当社は、本ウェブサイトに更新された規約を掲載し、「最終更新日」を更新することにより、重要な変更について通知を提供します。そのような変更が有効になった後の本ウェブサイトへの継続的なアクセスまたは本ソフトウェアの使用は、新しい規約の承諾を構成します。
11. 一般条項
A. 準拠法
本契約は、法の抵触原則を考慮することなく、[指定された管轄区域]の法律に準拠し、それに従って解釈されるものとします。
B. 紛争解決
適用法で禁止されている場合を除き、お客様は、本契約から生じるまたは本契約に関連するすべての紛争が、[指定された場所]で行われる拘束力のある仲裁によって最終的に解決されることに同意します。
C. 分離可能性および権利放棄
本契約のいずれかの条項が違法または執行不能と判断された場合、残りの条項は完全に有効であり続けます。当事者が本契約のいずれかの権利または条項を執行しないことは、その権利または条項の放棄とはみなされません。
D. 完全合意
本契約(AGPL-3.0ソフトウェアライセンスとともに)は、対象事項に関するお客様とNOFXとの間の完全な合意を構成します。

111
docs/i18n/ru/PRIVACY POLICY.md Normal file
View File

@@ -0,0 +1,111 @@
Политика конфиденциальности NOFX
Последнее обновление: 2025.11.07
I. Введение и область применения
A. Введение
Настоящая Политика конфиденциальности (далее — «Политика») предназначена для информирования вас, как пользователя нашего веб-сайта, о том, как мы обрабатываем вашу персональную информацию. Настоящая Политика применяется к информации, собираемой через nofxai.com и любые его поддомены (далее — «Веб-сайт») компанией NOFX (далее — «мы» или «наша компания»), выступающей в качестве контролера данных.
B. Ключевое различие в Политике: Данные веб-сайта и данные программного обеспечения
Основой настоящей Политики является разграничение между «Веб-сайтом» и «Программным обеспечением».
Данные веб-сайта: Настоящая Политика регулирует персональную информацию, которую мы собираем и обрабатываем от посетителей нашего «Веб-сайта».
Данные программного обеспечения: Настоящая Политика НЕ применяется к любым данным, которые вы обрабатываете в своем самостоятельно размещенном экземпляре операционной системы для торговли NOFX AI (далее — «Программное обеспечение»), которое вы загружаете, устанавливаете и запускаете самостоятельно.
В отношении «Программного обеспечения» вы являетесь единственным контролером всех данных (включая, помимо прочего, API-ключи, приватные ключи, торговые данные и т.д.), которые вы вводите или обрабатываете. Мы не можем получить доступ, просматривать, собирать или обрабатывать любую информацию, которую вы вводите в локальный экземпляр «Программного обеспечения».
II. Информация, которую мы собираем (на Веб-сайте), и как мы ее используем
A. Информация, которую мы собираем (Веб-сайт)
Основываясь на запросах пользователей, мы ограничили практику сбора данных до минимума. Мы не требуем от вас создания учетной записи, заполнения форм или предоставления какой-либо персонально идентифицируемой информации (PII) при посещении «Веб-сайта».
Единственная категория данных, которую мы собираем, — это «автоматически собираемые данные», которые реализуются через Google Analytics (GA4).
B. Раскрытие информации о Google Analytics (GA4)
Наш «Веб-сайт» использует сервис Google Analytics 4 (GA4). Это единственный способ, которым мы собираем информацию. В соответствии с Условиями обслуживания Google мы должны раскрыть вам это использование.
Типы собираемых данных: GA4 автоматически собирает определенную информацию о вашем визите, которая обычно не является персонально идентифицируемой. Это может включать:
Количество пользователей
Статистику сеансов
Приблизительное географическое местоположение (неточное)
Информацию о браузере и устройстве
Использование данных: Мы используем эти агрегированные данные исключительно для того, чтобы лучше понимать, как пользователи получают доступ к нашим сервисам и используют их, тем самым улучшая производительность и пользовательский опыт нашего «Веб-сайта».
Ваш выбор и отказ: Мы уважаем ваше право на конфиденциальность. Если вы не хотите, чтобы GA4 собирал данные о ваших посещениях, вы можете отказаться, установив дополнение для браузера Google Analytics Opt-out. Вы можете получить это дополнение, перейдя по этой ссылке: [Google Analytics Opt-out Add-on (by Google)](https://chromewebstore.google.com/detail/google-analytics-opt-out/fllaojicojecljbmefodhfapmkghcbnh?hl=en).
C. Файлы cookie и механизмы отслеживания
Работа GA4 зависит от файлов cookie первой стороны. В частности, могут использоваться такие файлы cookie, как _ga и _ga_<container-id>, для различения уникальных пользователей и сеансов. Мы явно заявляем, что не используем эти файлы cookie в рекламных целях или для профилирования пользователей.
III. Информация, которую мы НЕ собираем (Программное обеспечение)
Этот раздел направлен на четкое изложение нашей позиции в отношении изоляции данных, связанной с «Программным обеспечением».
A. Заявление о некастодиальности
Мы (NOFX) являемся поставщиком некастодиального программного обеспечения. Это означает, что мы никогда не храним, не контролируем и не получаем доступ к вашим средствам, активам или конфиденциальным учетным данным.
B. Явный список несобираемых данных
Когда вы загружаете, устанавливаете и используете самостоятельно размещенное «Программное обеспечение», мы абсолютно никаким образом не собираем, не получаем доступ, не храним, не обрабатываем и не передаем следующие данные:
Любые API-ключи для сторонних бирж (таких как Binance)
Любые API-ключи для сторонних сервисов ИИ (таких как DeepSeek, Qwen)
Ваши секретные ключи (Secret Keys), соответствующие вашим API-ключам
Ваши приватные ключи криптовалют (например, приватные ключи Ethereum для Hyperliquid или Aster DEX)
Ваши «секретные фразы» кошелька (мнемонические фразы)
Вашу торговую историю, позиции, балансы счетов или любую другую финансовую информацию
Любые персональные данные, которые вы настраиваете в локальном экземпляре «Программного обеспечения»
C. Примечание о локальном шифровании
Мы знаем, что «Программное обеспечение» предоставляет функцию шифрования введенных пользователем API-ключей и приватных ключей. Мы уточняем здесь, что этот процесс шифрования полностью выполняется и управляется на вашем собственном устройстве (локально). Эти данные никогда не передаются нам или любой третьей стороне после шифрования. Эта функция шифрования предназначена для защиты ваших данных от несанкционированного доступа к вашему локальному устройству, а не для обмена ими с нами.
IV. Обмен данными, хранение и безопасность (Данные веб-сайта)
A. Обмен с третьими сторонами
За исключением случаев, раскрытых в настоящей Политике (т.е. обмена аналитическими данными, собранными GA4, с нашим поставщиком услуг Google), мы не передаем, не продаем, не сдаем в аренду и не обмениваем вашу персональную информацию с какими-либо третьими сторонами.
B. Хранение данных
Мы храним агрегированные аналитические данные, собранные GA4, только в течение периода, разумно необходимого для достижения целей, описанных в настоящей Политике (т.е. аналитика и улучшение веб-сайта).
C. Безопасность данных
Мы применяем коммерчески разумные меры безопасности (например, использование HTTPS) для защиты передачи данных «Веб-сайта» и для защиты ограниченной информации, которую мы собираем (через GA4).
V. Ваши права на защиту данных (GDPR и CCPA)
A. Объем прав
В соответствии с применимыми законами о защите данных (такими как GDPR или CCPA) вы можете иметь определенные права. Мы уточняем здесь, что эти права применяются только к ограниченным аналитическим данным GA4, которые мы храним в качестве контролера данных, собранных через «Веб-сайт». Мы не можем выполнить какие-либо запросы относительно данных «Программного обеспечения», поскольку мы не храним такие данные.
B. Список прав
В соответствии с законом вы имеете право на:
Право доступа: Вы имеете право запросить копию персональных данных, которые мы храним о вас.
Право на исправление: Вы имеете право запросить исправление информации, которую считаете неточной или неполной.
Право на удаление (право быть забытым): При определенных условиях вы имеете право запросить удаление ваших персональных данных.
Право на ограничение обработки: При определенных условиях вы имеете право запросить ограничение обработки ваших персональных данных.
Право на возражение против обработки: При определенных условиях вы имеете право возражать против нашей обработки ваших персональных данных.
C. Как реализовать свои права
Если вы хотите реализовать любое из вышеуказанных прав, пожалуйста, свяжитесь с нами, используя контактную информацию, предоставленную в конце настоящей Политики.
VI. Конфиденциальность детей
Наш «Веб-сайт» и «Программное обеспечение» не предназначены и не направлены на лиц младше 18 лет. Мы сознательно не собираем персональную информацию от детей младше 18 лет.
VII. Изменения в Политике конфиденциальности
Мы оставляем за собой право изменять настоящую Политику конфиденциальности в любое время. О любых изменениях будет сообщено путем публикации обновленной версии на «Веб-сайте» и изменения даты «Последнего обновления».
VIII. Контактная информация
Если у вас есть какие-либо вопросы о настоящей Политике конфиденциальности или о наших методах обработки данных, пожалуйста, свяжитесь с нами:
[@nofx_ai](https://x.com/nofx_ai)

100
docs/i18n/ru/README.md
View File

@@ -6,7 +6,7 @@
[![License](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](LICENSE)
[![Backed by Amber.ac](https://img.shields.io/badge/Backed%20by-Amber.ac-orange.svg)](https://amber.ac)
**Языки / Languages:** [English](../../../README.md) | [中文](../zh-CN/README.md) | [Українська](../uk/README.md) | [Русский](../ru/README.md)
**Языки / Languages:** [English](../../../README.md) | [中文](../zh-CN/README.md) | [Українська](../uk/README.md) | [Русский](../ru/README.md) | [日本語](../ja/README.md)
**Официальный Twitter:** [@nofx_ai](https://x.com/nofx_ai)
@@ -23,6 +23,9 @@
- [✨ Текущая Реализация - Криптовалютные Рынки](#-текущая-реализация---криптовалютные-рынки)
- [🔮 Дорожная Карта](#-дорожная-карта---расширение-на-универсальные-рынки)
- [🏗️ Техническая Архитектура](#️-техническая-архитектура)
- [💰 Регистрация аккаунта Binance](#-регистрация-аккаунта-binance-экономьте-на-комиссиях)
- [🔷 Регистрация аккаунта Hyperliquid](#-использование-биржи-hyperliquid)
- [🔶 Регистрация аккаунта Aster DEX](#-использование-биржи-aster-dex)
- [🚀 Быстрый Старт](#-быстрый-старт)
- [📊 Функции Web-интерфейса](#-функции-web-интерфейса)
- [⚠️ Важные Предупреждения о Рисках](#️-важные-предупреждения-о-рисках)
@@ -481,18 +484,93 @@ cp config.json.example config.json
---
#### 🔷 Альтернатива: Использование биржи Hyperliquid
#### 🔷 Использование биржи Hyperliquid
**NOFX также поддерживает Hyperliquid** - децентрализованную биржу бессрочных фьючерсов. Чтобы использовать Hyperliquid вместо Binance:
**NOFX поддерживает Hyperliquid** - высокопроизводительную децентрализованную биржу бессрочных фьючерсов!
**Шаг 1**: Получите приватный ключ Ethereum (для аутентификации Hyperliquid)
**Почему выбрать Hyperliquid?**
- 🚀 **Высокая производительность**: Молниеносное исполнение на L1 блокчейне
- 💰 **Низкие комиссии**: Конкурентные комиссии мейкер/тейкер
- 🔐 **Без хранения**: Ваши ключи, ваши монеты
- 🌐 **Без KYC**: Анонимная торговля
- 💎 **Глубокая ликвидность**: Книга ордеров институционального уровня
1. Откройте **MetaMask** (или любой Ethereum кошелек)
2. Экспортируйте приватный ключ
3. **Удалите префикс `0x`** из ключа
4. Пополните кошелек на [Hyperliquid](https://hyperliquid.xyz)
---
**Шаг 2**: Настройте `config.json` для Hyperliquid
### 📝 Руководство по регистрации и настройке
**Шаг 1: Регистрация аккаунта Hyperliquid**
1. **Посетите Hyperliquid по реферальной ссылке** (получите преимущества!):
**🎁 [Зарегистрироваться на Hyperliquid - Присоединиться AITRADING](https://app.hyperliquid.xyz/join/AITRADING)**
2. **Подключите кошелек**:
- Нажмите "Connect Wallet" в правом верхнем углу
- Выберите MetaMask, WalletConnect или другие Web3 кошельки
- Подтвердите подключение
3. **Включите торговлю**:
- При первом подключении появится запрос на подпись сообщения
- Это авторизует ваш кошелек для торговли (без комиссий за газ)
- Вы увидите отображенный адрес кошелька
**Шаг 2: Пополнение кошелька**
1. **Мост активов в Arbitrum**:
- Hyperliquid работает на Arbitrum L2
- Переведите USDC с Ethereum mainnet или других сетей
- Или напрямую выведите USDC с бирж на Arbitrum
2. **Депозит в Hyperliquid**:
- Нажмите "Deposit" в интерфейсе Hyperliquid
- Выберите сумму USDC для депозита
- Подтвердите транзакцию (небольшая комиссия за газ на Arbitrum)
- Средства появятся на вашем аккаунте Hyperliquid в течение секунд
**Шаг 3: Настройка Agent Wallet (Рекомендуется)**
Hyperliquid поддерживает **Agent Wallets** - безопасные подкошельки специально для торговой автоматизации!
⚠️ **Зачем использовать Agent Wallet:**
- ✅ **Более безопасно**: Никогда не раскрывайте приватный ключ основного кошелька
- ✅ **Ограниченный доступ**: У агента есть только торговые разрешения
- ✅ **Отзывается**: Может быть отключен в любое время из интерфейса Hyperliquid
- ✅ **Отдельные средства**: Держите основные активы в безопасности
**Как создать Agent Wallet:**
1. **Войдите в Hyperliquid** используя основной кошелек
- Посетите [https://app.hyperliquid.xyz](https://app.hyperliquid.xyz)
- Подключитесь с кошельком, который вы зарегистрировали (по реферальной ссылке)
2. **Перейдите в настройки агента**:
- Нажмите на адрес кошелька (правый верхний угол)
- Перейдите в "Settings" → "API & Agents"
- Или посетите: [https://app.hyperliquid.xyz/agents](https://app.hyperliquid.xyz/agents)
3. **Создайте нового агента**:
- Нажмите "Create Agent" или "Add Agent"
- Система автоматически сгенерирует новый кошелек агента
- **Сохраните адрес кошелька агента** (начинается с `0x`)
- **Сохраните приватный ключ агента** (показывается только один раз!)
4. **Детали Agent Wallet**:
- Основной кошелек: Ваш подключенный кошелек (хранит средства)
- Кошелек агента: Подкошелек для торговли (NOFX будет использовать его)
- Приватный ключ: Нужен только для конфигурации NOFX
5. **Пополните агента** (Опционально):
- Переведите USDC с основного кошелька на кошелек агента
- Или оставьте средства в основном кошельке (агент может торговать с него)
6. **Сохраните учетные данные для NOFX**:
- Адрес основного кошелька: `0xYourMainWalletAddress` (с `0x`)
- Приватный ключ агента: `YourAgentPrivateKeyWithout0x` (удалите префикс `0x`)
---
~~Настройте `config.json` для Hyperliquid~~ *Настройте через веб-интерфейс*
```json
{
@@ -525,9 +603,9 @@ cp config.json.example config.json
---
#### 🔶 Альтернатива: Использование биржи Aster DEX
#### 🔶 Использование биржи Aster DEX
**NOFX также поддерживает Aster DEX** - децентрализованную биржу бессрочных фьючерсов, совместимую с Binance!
**NOFX поддерживает Aster DEX** - децентрализованную биржу бессрочных фьючерсов, совместимую с Binance!
**Почему выбрать Aster?**
- 🎯 API совместимый с Binance (легкая миграция)

155
docs/i18n/ru/TERMS OF SERVICE.md Normal file
View File

@@ -0,0 +1,155 @@
Пользовательское соглашение NOFX (Условия предоставления услуг)
Последнее обновление: 07.11.2025
1. Введение и принятие условий
A. Соглашение
Настоящее Пользовательское соглашение (далее «Соглашение» или «Условия») является юридически обязывающим договором между вами (далее «вы» или «Пользователь») и NOFX (далее «мы» или «NOFX»).
B. Сфера применения
Настоящее Соглашение регулирует ваш доступ к веб-сайту nofxai.com (далее «Веб-сайт») и его использование, а также загрузку, установку и использование операционной системы NOFX AI для торговли (далее «Программное обеспечение»).
C. Принятие условий
Осуществляя доступ к Веб-сайту или загружая, устанавливая или используя Программное обеспечение любым способом, вы подтверждаете, что прочитали, поняли и согласились соблюдать настоящие Условия. Если вы не согласны с настоящими Условиями, вы должны немедленно прекратить доступ к Веб-сайту и использование Программного обеспечения.
D. Возрастное требование
Для использования Веб-сайта и Программного обеспечения вам должно быть не менее 18 лет или вы должны достичь совершеннолетия в вашей юрисдикции.
2. Лицензия на программное обеспечение и модель услуг
A. Веб-сайт
Мы предоставляем вам ограниченную, неисключительную, непередаваемую, отзывную лицензию на доступ к Веб-сайту и его использование в информационных целях.
B. Программное обеспечение (самостоятельное размещение)
Лицензия AGPL-3.0: Мы явно информируем вас о том, что исходный код Программного обеспечения NOFX предоставляется вам на условиях лицензии GNU Affero General Public License v3.0 (AGPL-3.0) (далее «AGPL-3.0»).
Характер условий: Настоящее Соглашение не изменяет, не заменяет и не ограничивает ваши права по AGPL-3.0. AGPL-3.0 является вашей лицензией на программное обеспечение. Настоящее Соглашение является соглашением об оказании услуг, которое регулирует использование вами нашей полной экосистемы услуг (включая использование Веб-сайта и Программного обеспечения) и устанавливает ключевые обязанности и отказы от ответственности, описанные ниже, которые не охватываются AGPL-3.0.
3. Подтверждение критических рисков (финансовые)
Данный раздел касается ваших существенных интересов. Внимательно прочитайте. Все условия в данном разделе представлены заметными заглавными буквами для обеспечения их юридической значимости.
A. Отсутствие финансовых или инвестиционных консультаций:
ВЕБ-САЙТ И ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЮТСЯ ИСКЛЮЧИТЕЛЬНО КАК ТЕХНИЧЕСКИЕ ИНСТРУМЕНТЫ. МЫ НЕ ЯВЛЯЕМСЯ ФИНАНСОВЫМ УЧРЕЖДЕНИЕМ, БРОКЕРОМ, ФИНАНСОВЫМ КОНСУЛЬТАНТОМ ИЛИ ИНВЕСТИЦИОННЫМ КОНСУЛЬТАНТОМ. ЛЮБОЕ СОДЕРЖИМОЕ, ФУНКЦИОНАЛЬНОСТЬ ИЛИ РЕЗУЛЬТАТЫ РАБОТЫ ИИ, ПРЕДОСТАВЛЯЕМЫЕ ДАННЫМ СЕРВИСОМ, НЕ ЯВЛЯЮТСЯ ФИНАНСОВЫМИ, ИНВЕСТИЦИОННЫМИ, ЮРИДИЧЕСКИМИ, НАЛОГОВЫМИ ИЛИ ТОРГОВЫМИ КОНСУЛЬТАЦИЯМИ.
B. Экстремальный риск финансовых потерь:
ВЫ ПРИЗНАЕТЕ И СОГЛАШАЕТЕСЬ С ТЕМ, ЧТО ТОРГОВЛЯ КРИПТОВАЛЮТАМИ И ДРУГИМИ ФИНАНСОВЫМИ АКТИВАМИ ЯВЛЯЕТСЯ ВЫСОКОВОЛАТИЛЬНОЙ, СПЕКУЛЯТИВНОЙ И СОПРЯЖЕНА С ПРИСУЩИМИ РИСКАМИ. ИСПОЛЬЗОВАНИЕ АВТОМАТИЗИРОВАННЫХ, АЛГОРИТМИЧЕСКИХ И ИИ-УПРАВЛЯЕМЫХ ТОРГОВЫХ СИСТЕМ (ТАКИХ КАК ДАННОЕ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ) СОПРЯЖЕНО СО ЗНАЧИТЕЛЬНЫМИ И УНИКАЛЬНЫМИ РИСКАМИ И МОЖЕТ ПРИВЕСТИ К СУЩЕСТВЕННЫМ ИЛИ ПОЛНЫМ ФИНАНСОВЫМ ПОТЕРЯМ.
C. Отсутствие гарантии прибыли или производительности:
МЫ НЕ ДАЕМ НИКАКИХ ЯВНЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ ГАРАНТИЙ, ЗАЯВЛЕНИЙ ИЛИ ОБЕЩАНИЙ ОТНОСИТЕЛЬНО ПРОИЗВОДИТЕЛЬНОСТИ, ПРИБЫЛЬНОСТИ ИЛИ ТОЧНОСТИ ЛЮБЫХ ТОРГОВЫХ СИГНАЛОВ, ГЕНЕРИРУЕМЫХ ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ. ПРОШЛЫЕ РЕЗУЛЬТАТЫ ЛЮБОЙ МОДЕЛИ ИИ ИЛИ ТОРГОВОЙ СТРАТЕГИИ НИ В КОЕЙ МЕРЕ НЕ ПРЕДСТАВЛЯЮТ И НЕ ГАРАНТИРУЮТ БУДУЩИХ РЕЗУЛЬТАТОВ.
D. Полная ответственность пользователя:
ВЫ НЕСЕТЕ ПОЛНУЮ И ЕДИНОЛИЧНУЮ ОТВЕТСТВЕННОСТЬ ЗА ВСЕ СВОИ ТОРГОВЫЕ РЕШЕНИЯ, ЗАКАЗЫ, ИСПОЛНЕНИЕ И ОКОНЧАТЕЛЬНЫЕ РЕЗУЛЬТАТЫ. ВСЕ СДЕЛКИ, СОВЕРШАЕМЫЕ ЧЕРЕЗ ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ, СЧИТАЮТСЯ ОСНОВАННЫМИ НА ВАШЕМ САМОСТОЯТЕЛЬНОМ РЕШЕНИИ И ДОПУСТИМОСТИ РИСКА И ОСУЩЕСТВЛЯЮТСЯ НА ВАШ СОБСТВЕННЫЙ РИСК.
4. Подтверждение критических рисков (искусственный интеллект и программное обеспечение)
Данный раздел также касается ваших существенных интересов и представлен заглавными буквами.
A. Отказ от ответственности «КАК ЕСТЬ» и «ПО МЕРЕ ДОСТУПНОСТИ»:
ВЕБ-САЙТ И ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПРЕДОСТАВЛЯЮТСЯ «КАК ЕСТЬ» (AS IS) И «ПО МЕРЕ ДОСТУПНОСТИ» (AS AVAILABLE) БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ, ЯВНЫХ ИЛИ ПОДРАЗУМЕВАЕМЫХ. МЫ НЕ ГАРАНТИРУЕМ, ЧТО СЕРВИС БУДЕТ БЕСПЕРЕБОЙНЫМ, ТОЧНЫМ, БЕЗОШИБОЧНЫМ, БЕЗОПАСНЫМ ИЛИ СВОБОДНЫМ ОТ ВИРУСОВ ИЛИ ДРУГИХ ВРЕДОНОСНЫХ КОМПОНЕНТОВ.
B. Отказ от ответственности за результаты работы ИИ и «галлюцинации»:
УЧИТЫВАЯ, ЧТО ОСНОВНАЯ ФУНКЦИОНАЛЬНОСТЬ ДАННОГО ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ ЗАВИСИТ ОТ МОДЕЛЕЙ ИИ ТРЕТЬИХ СТОРОН, ВЫ ДОЛЖНЫ ПОНИМАТЬ И ПРИНИМАТЬ ПРИСУЩИЕ ОГРАНИЧЕНИЯ ТЕХНОЛОГИИ ИИ. РЕЗУЛЬТАТЫ РАБОТЫ ИИ (ВКЛЮЧАЯ РЕШЕНИЯ АГЕНТОВ ИИ) ЯВЛЯЮТСЯ НОВОЙ ТЕХНОЛОГИЕЙ, И ИХ ЮРИДИЧЕСКАЯ ОТВЕТСТВЕННОСТЬ ПОКА НЕ ЯСНА.
ВЫ НАСТОЯЩИМ ПРИЗНАЕТЕ И СОГЛАШАЕТЕСЬ С ТЕМ, ЧТО:
Результаты ИИ могут быть дефектными: МОДЕЛИ ИИ И РЕЗУЛЬТАТЫ, ИНТЕГРИРОВАННЫЕ ИЛИ ГЕНЕРИРУЕМЫЕ ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ, МОГУТ СОДЕРЖАТЬ ОШИБКИ, НЕТОЧНОСТИ, ПРОПУСКИ, ПРЕДВЗЯТОСТИ ИЛИ СОЗДАВАТЬ ТАК НАЗЫВАЕМЫЕ «ГАЛЛЮЦИНАЦИИ» (HALLUCINATIONS) - ПОЛНОСТЬЮ ОШИБОЧНУЮ ИЛИ ВЫМЫШЛЕННУЮ ИНФОРМАЦИЮ.
Вы несете весь риск самостоятельно: ВЫ СОГЛАШАЕТЕСЬ С ТЕМ, ЧТО ЛЮБОЕ ИСПОЛЬЗОВАНИЕ ИЛИ ДОВЕРИЕ К РЕЗУЛЬТАТАМ, ГЕНЕРИРУЕМЫМ ИИ (ВКЛЮЧАЯ ЛЮБЫЕ ТОРГОВЫЕ РЕШЕНИЯ), ОСУЩЕСТВЛЯЕТСЯ НА ВАШ СОБСТВЕННЫЙ РИСК.
Не может заменить профессиональные консультации: ВЫ НЕ ДОЛЖНЫ РАССМАТРИВАТЬ РЕЗУЛЬТАТЫ ИИ КАК ЕДИНСТВЕННЫЙ ИСТОЧНИК ИСТИНЫ, ФАКТИЧЕСКУЮ ИНФОРМАЦИЮ ИЛИ КАК ЗАМЕНУ ПРОФЕССИОНАЛЬНЫХ ФИНАНСОВЫХ КОНСУЛЬТАЦИЙ.
C. Конечная ответственность пользователя:
ВЫ СОГЛАШАЕТЕСЬ НЕСТИ КОНЕЧНУЮ ОТВЕТСТВЕННОСТЬ ЗА ВСЕ ДЕЙСТВИЯ, ПРЕДПРИНЯТЫЕ НА ОСНОВЕ РЕЗУЛЬТАТОВ ИИ. ВЫ ДОЛЖНЫ САМОСТОЯТЕЛЬНО ПРОВЕСТИ ДОЛЖНУЮ ПРОВЕРКУ И ПРОВЕРИТЬ ТОЧНОСТЬ ИНФОРМАЦИИ ПЕРЕД СОВЕРШЕНИЕМ ЛЮБЫХ СДЕЛОК, РЕКОМЕНДОВАННЫХ ИИ.
5. Обязанности пользователя и ответственность за безопасность
A. Полная ответственность за ключи API и приватные ключи
Это одно из наиболее критических условий настоящего Соглашения, касающееся основной функциональности Программного обеспечения.
ВЫ ПРИЗНАЕТЕ И СОГЛАШАЕТЕСЬ С ТЕМ, ЧТО НЕСЕТЕ ИСКЛЮЧИТЕЛЬНУЮ, ЕДИНОЛИЧНУЮ И ПОЛНУЮ ОТВЕТСТВЕННОСТЬ ЗА ЗАЩИТУ, СОХРАНЕНИЕ, ОБЕСПЕЧЕНИЕ БЕЗОПАСНОСТИ И РЕЗЕРВНОЕ КОПИРОВАНИЕ ВСЕХ КЛЮЧЕЙ API, СЕКРЕТНЫХ КЛЮЧЕЙ, АДРЕСОВ КОШЕЛЬКОВ, ПРИВАТНЫХ КЛЮЧЕЙ И ЛЮБЫХ SEED-ФРАЗ («СЕКРЕТНАЯ ФРАЗА»), ИСПОЛЬЗУЕМЫХ С ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ. ВЫ ДОЛЖНЫ ОБЕСПЕЧИТЬ ДОСТАТОЧНУЮ БЕЗОПАСНОСТЬ И КОНТРОЛЬ НАД ЭТИМИ УЧЕТНЫМИ ДАННЫМИ.
B. Подтверждение некастодиального характера
ВЫ ПРИЗНАЕТЕ И СОГЛАШАЕТЕСЬ С ТЕМ, ЧТО МЫ (NOFX) ЯВЛЯЕМСЯ НЕКАСТОДИАЛЬНЫМ ПОСТАВЩИКОМ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ. МЫ НИКОГДА НЕ СОБИРАЕМ, НЕ ХРАНИМ, НЕ ПОЛУЧАЕМ И НИКОИМ ОБРАЗОМ НЕ ПОЛУЧАЕМ ДОСТУП К ВАШИМ КЛЮЧАМ API, ПРИВАТНЫМ КЛЮЧАМ ИЛИ SEED-ФРАЗАМ. МЫ НИКОГДА НЕ БУДЕМ ПРОСИТЬ ВАС ПОДЕЛИТЬСЯ ЭТИМИ УЧЕТНЫМИ ДАННЫМИ.
СЛЕДОВАТЕЛЬНО, МЫ НЕ ИМЕЕМ ВОЗМОЖНОСТИ ПОЛУЧИТЬ ДОСТУП К ВАШИМ СРЕДСТВАМ, ВОССТАНОВИТЬ УТЕРЯННЫЕ КЛЮЧИ ИЛИ ОТМЕНИТЬ ИЛИ ОТОЗВАТЬ ЛЮБЫЕ ТРАНЗАКЦИИ. ВЫ НЕСЕТЕ ПОЛНУЮ ОТВЕТСТВЕННОСТЬ ЗА ВСЕ ПОТЕРИ, ВОЗНИКШИЕ В РЕЗУЛЬТАТЕ УТЕРИ, КРАЖИ ИЛИ КОМПРОМЕТАЦИИ ВАШИХ КЛЮЧЕЙ (БУДЬ ТО КЛЮЧИ API ИЛИ ПРИВАТНЫЕ КЛЮЧИ).
C. Управляемое пользователем шифрование
ВЫ ПРИЗНАЕТЕ, ЧТО В ВАШЕМ САМОСТОЯТЕЛЬНО РАЗМЕЩЕННОМ ЭКЗЕМПЛЯРЕ ВЫ НЕСЕТЕ ОТВЕТСТВЕННОСТЬ ЗА ШИФРОВАНИЕ ВАШИХ КЛЮЧЕЙ И УЧЕТНЫХ ДАННЫХ ВО ВСЕХ ХРАНИЛИЩАХ И КОММУНИКАЦИЯХ. ЛЮБАЯ ФУНКЦИОНАЛЬНОСТЬ ШИФРОВАНИЯ, ПРЕДОСТАВЛЯЕМАЯ В ПРОГРАММНОМ ОБЕСПЕЧЕНИИ, ПРЕДОСТАВЛЯЕТСЯ «КАК ЕСТЬ» БЕЗ КАКИХ-ЛИБО ГАРАНТИЙ БЕЗОПАСНОСТИ.
D. Условия третьих сторон
ПРИ ИСПОЛЬЗОВАНИИ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ ДЛЯ ПОДКЛЮЧЕНИЯ К ЛЮБЫМ СЕРВИСАМ ТРЕТЬИХ СТОРОН (ТАКИМ КАК BINANCE, HYPERLIQUID, DEEPSEEK, QWEN И Т.Д.), ВЫ НЕСЕТЕ ОТВЕТСТВЕННОСТЬ ЗА СОБЛЮДЕНИЕ ВСЕХ УСЛОВИЙ ПРЕДОСТАВЛЕНИЯ УСЛУГ, ПОЛИТИКИ КОМИССИЙ И ПРАВИЛ ИСПОЛЬЗОВАНИЯ ЭТИХ СЕРВИСОВ ТРЕТЬИХ СТОРОН.
6. Политика допустимого использования (AUP)
Вы соглашаетесь не использовать Веб-сайт или Программное обеспечение в незаконных целях или целях, запрещенных настоящими Условиями. Запрещенные действия включают (но не ограничиваются ими):
Незаконная деятельность: Осуществление любой деятельности, нарушающей местные, государственные, национальные или международные законы или нормативные акты.
Злоупотребление системой: Осуществление любых «хакерских атак» (Hacking), «спама» (Spamming), «почтовых бомбардировок» или «атак типа отказ в обслуживании» (DoS).
Безопасность: Попытки зондирования, сканирования или тестирования уязвимостей Веб-сайта или связанных сетей, или нарушения мер безопасности или аутентификации.
Извлечение данных: Использование любых автоматизированных систем (включая «извлечение данных», «веб-скрейпинг» или «ботов») для коммерческих целей для извлечения данных с Веб-сайта.
Вредоносное ПО: Внедрение любых вирусов, троянов, червей или другого вредоносного кода.
7. Интеллектуальная собственность (IP)
A. Содержание веб-сайта
Мы и наши лицензиары сохраняем все права интеллектуальной собственности на Веб-сайт и все его содержание (включая текст, графику, логотипы, элементы визуального дизайна).
B. Интеллектуальная собственность программного обеспечения
Программное обеспечение является проектом с открытым исходным кодом. Его права интеллектуальной собственности регулируются лицензией AGPL-3.0.
C. Пользовательский контент/обратная связь
Если вы предоставляете нам какие-либо отзывы, стратегии, предложения или вклад («Пользовательский контент»), вы предоставляете нам постоянную, безотзывную, всемирную, безвозмездную лицензию на использование, размещение, воспроизведение, изменение и отображение такого контента.
8. Ограничение ответственности и возмещение убытков
Данный раздел ограничивает нашу юридическую ответственность и требует от вас принять ответственность за ущерб, причиненный вами. Внимательно прочитайте. Все условия в данном разделе представлены заметными заглавными буквами.
A. Ограничение ответственности:
НАСТОЯЩЕЕ УСЛОВИЕ РАЗРАБОТАНО НА ОСНОВЕ АНАЛИЗА ЮРИДИЧЕСКИХ ИСКОВ, С КОТОРЫМИ СТАЛКИВАЮТСЯ КАСТОДИАЛЬНЫЕ ПОСТАВЩИКИ УСЛУГ, И ИСПОЛЬЗУЕТ НАШУ ЮРИДИЧЕСКУЮ ПОЗИЦИЮ КАК НЕКАСТОДИАЛЬНОГО ПОСТАВЩИКА САМОСТОЯТЕЛЬНО РАЗМЕЩАЕМОГО ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ.
В МАКСИМАЛЬНОЙ СТЕПЕНИ, РАЗРЕШЕННОЙ ПРИМЕНИМЫМ ЗАКОНОДАТЕЛЬСТВОМ, NOFX (И ЕГО АФФИЛИРОВАННЫЕ ЛИЦА, ДИРЕКТОРА, СОТРУДНИКИ ИЛИ ЛИЦЕНЗИАРЫ) НИ ПРИ КАКИХ ОБСТОЯТЕЛЬСТВАХ НЕ НЕСУТ ОТВЕТСТВЕННОСТИ ПЕРЕД ВАМИ ЗА ЛЮБОЙ КОСВЕННЫЙ, ШТРАФНОЙ, СЛУЧАЙНЫЙ, СПЕЦИАЛЬНЫЙ, ПОСЛЕДУЮЩИЙ ИЛИ ПОКАЗАТЕЛЬНЫЙ УЩЕРБ, ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ, ПОТЕРЕЙ ПРИБЫЛИ, СРЕДСТВ ИЛИ ДАННЫХ, ИЛИ УЩЕРБОМ, ВОЗНИКШИМ В РЕЗУЛЬТАТЕ КРАЖИ ИЛИ ПОТЕРИ ВАШИХ КЛЮЧЕЙ API ИЛИ ПРИВАТНЫХ КЛЮЧЕЙ, ВОЗНИКАЮЩИЙ В РЕЗУЛЬТАТЕ:
ВАШЕГО ИСПОЛЬЗОВАНИЯ ИЛИ НЕВОЗМОЖНОСТИ ИСПОЛЬЗОВАНИЯ ВЕБ-САЙТА ИЛИ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ;
ЛЮБЫХ ДЕФЕКТОВ, ОШИБОК, ВИРУСОВ, НЕТОЧНОСТЕЙ ИЛИ ЗАДЕРЖЕК В ПРОГРАММНОМ ОБЕСПЕЧЕНИИ;
ЛЮБЫХ РЕЗУЛЬТАТОВ, ГЕНЕРИРУЕМЫХ ИИ, «ГАЛЛЮЦИНАЦИЙ», ОШИБОЧНЫХ ТОРГОВЫХ СИГНАЛОВ ИЛИ НЕУДАЧНЫХ СТРАТЕГИЙ;
ЛЮБОГО НЕСАНКЦИОНИРОВАННОГО ДОСТУПА ИЛИ ИСПОЛЬЗОВАНИЯ ВАШЕГО САМОСТОЯТЕЛЬНО РАЗМЕЩЕННОГО ЭКЗЕМПЛЯРА ИЛИ ЛЮБОГО УСТРОЙСТВА, НА КОТОРОМ ВЫ ХРАНИТЕ СВОИ КЛЮЧИ;
ВСЕХ ФИНАНСОВЫХ ПОТЕРЬ, ВОЗНИКШИХ В РЕЗУЛЬТАТЕ ЛЮБЫХ СДЕЛОК, АВТОМАТИЧЕСКИ СОВЕРШЕННЫХ ИЛИ РЕКОМЕНДОВАННЫХ ПРОГРАММНЫМ ОБЕСПЕЧЕНИЕМ.
ЕСЛИ NOFX БУДЕТ ПРИЗНАН НЕСУЩИМ ПРЯМУЮ ОТВЕТСТВЕННОСТЬ ПЕРЕД ВАМИ, НАША МАКСИМАЛЬНАЯ СОВОКУПНАЯ ОТВЕТСТВЕННОСТЬ ДОЛЖНА БЫТЬ ОГРАНИЧЕНА БОЛЬШЕЙ ИЗ СЛЕДУЮЩИХ СУММ: СБОРЫ, УПЛАЧЕННЫЕ ВАМИ НАМ В ТЕЧЕНИЕ ДВЕНАДЦАТИ (12) МЕСЯЦЕВ ДО ПРЕДЪЯВЛЕНИЯ ПРЕТЕНЗИИ (ЕСЛИ ТАКОВЫЕ ИМЕЮТСЯ), ИЛИ СТО ДОЛЛАРОВ США ($100.00).
B. Возмещение убытков:
ВЫ СОГЛАШАЕТЕСЬ ЗАЩИЩАТЬ, ВОЗМЕЩАТЬ УБЫТКИ И ОГРАЖДАТЬ ОТ ОТВЕТСТВЕННОСТИ NOFX И ЕГО АФФИЛИРОВАННЫЕ ЛИЦА ОТ ЛЮБЫХ ПРЕТЕНЗИЙ, ТРЕБОВАНИЙ, ИСКОВ, ПОТЕРЬ, УЩЕРБА, ОБЯЗАТЕЛЬСТВ, ИЗДЕРЖЕК И РАСХОДОВ (ВКЛЮЧАЯ РАЗУМНЫЕ ГОНОРАРЫ АДВОКАТОВ), ВОЗНИКАЮЩИХ ИЗ ИЛИ КАКИМ-ЛИБО ОБРАЗОМ СВЯЗАННЫХ С: (A) ВАШИМ ДОСТУПОМ ИЛИ ИСПОЛЬЗОВАНИЕМ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ; (B) ВАШИМ НАРУШЕНИЕМ НАСТОЯЩИХ УСЛОВИЙ; (C) ВАШИМ НАРУШЕНИЕМ ЛЮБЫХ ПРАВ ТРЕТЬИХ СТОРОН, ВКЛЮЧАЯ, НО НЕ ОГРАНИЧИВАЯСЬ, УСЛОВИЯМИ ПРЕДОСТАВЛЕНИЯ УСЛУГ ЛЮБОЙ БИРЖИ ИЛИ ПОСТАВЩИКА ИИ, К КОТОРЫМ ВЫ ПОДКЛЮЧАЕТЕСЬ; ИЛИ (D) ЛЮБЫМИ ПРЕТЕНЗИЯМИ ТРЕТЬИХ СТОРОН О НАРУШЕНИИ ПРАВ ИНТЕЛЛЕКТУАЛЬНОЙ СОБСТВЕННОСТИ, ВОЗНИКАЮЩИМИ В РЕЗУЛЬТАТЕ ВАШЕГО ИСПОЛЬЗОВАНИЯ РЕЗУЛЬТАТОВ ИИ.
9. Прекращение
A. Прекращение с нашей стороны
МЫ ОСТАВЛЯЕМ ЗА СОБОЙ ПРАВО ПО НАШЕМУ СОБСТВЕННОМУ УСМОТРЕНИЮ НЕМЕДЛЕННО ИЛИ ПОСЛЕ УВЕДОМЛЕНИЯ ПРИОСТАНОВИТЬ ИЛИ ПРЕКРАТИТЬ ВАШ ДОСТУП К ВЕБ-САЙТУ (И ЛЮБЫМ БУДУЩИМ ХОСТИНГОВЫМ УСЛУГАМ, КОТОРЫЕ МЫ МОЖЕМ ПРЕДЛОЖИТЬ) В СЛУЧАЕ ВАШЕГО НАРУШЕНИЯ НАСТОЯЩИХ УСЛОВИЙ ИЛИ ПОЛИТИКИ ДОПУСТИМОГО ИСПОЛЬЗОВАНИЯ.
B. Последствия прекращения
ПОСЛЕ ПРЕКРАЩЕНИЯ ВАША ЛИЦЕНЗИЯ НА ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ ПО AGPL-3.0 (ЕСЛИ ВЫ ЕГО ЗАГРУЗИЛИ) ОСТАЕТСЯ В СИЛЕ, НО ВАШЕ ПРАВО НА ИСПОЛЬЗОВАНИЕ НАШЕГО ВЕБ-САЙТА БУДЕТ ОТОЗВАНО. ВСЕ УСЛОВИЯ, СВЯЗАННЫЕ С ОТКАЗАМИ ОТ ОТВЕТСТВЕННОСТИ, ОГРАНИЧЕНИЕМ ОТВЕТСТВЕННОСТИ, ВОЗМЕЩЕНИЕМ УБЫТКОВ, ИНТЕЛЛЕКТУАЛЬНОЙ СОБСТВЕННОСТЬЮ И ПРИМЕНИМЫМ ПРАВОМ, СОХРАНЯЮТ СИЛУ ПОСЛЕ ПРЕКРАЩЕНИЯ.
10. Изменение условий
МЫ ОСТАВЛЯЕМ ЗА СОБОЙ ПРАВО ПО НАШЕМУ СОБСТВЕННОМУ УСМОТРЕНИЮ ИЗМЕНЯТЬ ИЛИ ЗАМЕНЯТЬ НАСТОЯЩИЕ УСЛОВИЯ В ЛЮБОЕ ВРЕМЯ. В ОТЛИЧИЕ ОТ НЕКОТОРЫХ УСЛОВИЙ «ОДНОСТОРОННЕГО ИЗМЕНЕНИЯ» В ИНДУСТРИИ, КОТОРЫЕ МОГУТ СЧИТАТЬСЯ НЕ ИМЕЮЩИМИ ИСКОВОЙ СИЛЫ, МЫ БУДЕМ ПРЕДОСТАВЛЯТЬ УВЕДОМЛЕНИЕ О СУЩЕСТВЕННЫХ ИЗМЕНЕНИЯХ, РАЗМЕЩАЯ ОБНОВЛЕННЫЕ УСЛОВИЯ НА ВЕБ-САЙТЕ И ОБНОВЛЯЯ ДАТУ «ПОСЛЕДНЕГО ОБНОВЛЕНИЯ». ВАШЕ ПРОДОЛЖЕНИЕ ДОСТУПА К ВЕБ-САЙТУ ИЛИ ИСПОЛЬЗОВАНИЕ ПРОГРАММНОГО ОБЕСПЕЧЕНИЯ ПОСЛЕ ВСТУПЛЕНИЯ ТАКИХ ИЗМЕНЕНИЙ В СИЛУ ЯВЛЯЕТСЯ ВАШИМ ПРИНЯТИЕМ НОВЫХ УСЛОВИЙ.
11. Общие положения
A. Применимое право
НАСТОЯЩЕЕ СОГЛАШЕНИЕ РЕГУЛИРУЕТСЯ И ТОЛКУЕТСЯ В СООТВЕТСТВИИ С ЗАКОНОДАТЕЛЬСТВОМ [УКАЗАННАЯ ЮРИСДИКЦИЯ], БЕЗ УЧЕТА ЕГО ПРИНЦИПОВ КОЛЛИЗИОННОГО ПРАВА.
B. Разрешение споров
ЗА ИСКЛЮЧЕНИЕМ СЛУЧАЕВ, ЗАПРЕЩЕННЫХ ПРИМЕНИМЫМ ЗАКОНОДАТЕЛЬСТВОМ, ВЫ СОГЛАШАЕТЕСЬ С ТЕМ, ЧТО ВСЕ СПОРЫ, ВОЗНИКАЮЩИЕ ИЗ ИЛИ СВЯЗАННЫЕ С НАСТОЯЩИМ СОГЛАШЕНИЕМ, БУДУТ ОКОНЧАТЕЛЬНО РАЗРЕШАТЬСЯ ПУТЕМ ОБЯЗАТЕЛЬНОГО АРБИТРАЖА, ПРОВОДИМОГО В [УКАЗАННОЕ МЕСТО].
C. Делимость и отказ от прав
ЕСЛИ КАКОЕ-ЛИБО ПОЛОЖЕНИЕ НАСТОЯЩЕГО СОГЛАШЕНИЯ БУДЕТ ПРИЗНАНО НЕЗАКОННЫМ ИЛИ НЕ ИМЕЮЩИМ ИСКОВОЙ СИЛЫ, ОСТАЛЬНЫЕ ПОЛОЖЕНИЯ СОХРАНЯЮТ ПОЛНУЮ СИЛУ. НЕСПОСОБНОСТЬ СТОРОНЫ ПРИМЕНИТЬ КАКОЕ-ЛИБО ПРАВО ИЛИ ПОЛОЖЕНИЕ НАСТОЯЩЕГО СОГЛАШЕНИЯ НЕ РАССМАТРИВАЕТСЯ КАК ОТКАЗ ОТ ТАКОГО ПРАВА ИЛИ ПОЛОЖЕНИЯ.
D. Полное соглашение
НАСТОЯЩЕЕ СОГЛАШЕНИЕ (ВМЕСТЕ С ЛИЦЕНЗИЕЙ НА ПРОГРАММНОЕ ОБЕСПЕЧЕНИЕ AGPL-3.0) ПРЕДСТАВЛЯЕТ СОБОЙ ПОЛНОЕ СОГЛАШЕНИЕ МЕЖДУ ВАМИ И NOFX ОТНОСИТЕЛЬНО ПРЕДМЕТА ДОГОВОРА.

111
docs/i18n/uk/PRIVACY POLICY.md Normal file
View File

@@ -0,0 +1,111 @@
Політика конфіденційності NOFX
Останнє оновлення: 2025.11.07
I. Вступ та сфера застосування
A. Вступ
Ця Політика конфіденційності (далі — «Політика») призначена для інформування вас, як користувача нашого веб-сайту, про те, як ми обробляємо вашу персональну інформацію. Ця Політика застосовується до інформації, зібраної через nofxai.com та будь-які його піддомени (далі — «Веб-сайт») компанією NOFX (далі — «ми» або «наша компанія»), що виступає як контролер даних.
B. Ключове розмежування в Політиці: Дані веб-сайту та дані програмного забезпечення
Основою цієї Політики є розмежування між «Веб-сайтом» і «Програмним забезпеченням».
Дані веб-сайту: Ця Політика регулює персональну інформацію, яку ми збираємо та обробляємо від відвідувачів нашого «Веб-сайту».
Дані програмного забезпечення: Ця Політика НЕ застосовується до будь-яких даних, які ви обробляєте у вашому самостійно розміщеному екземплярі операційної системи для торгівлі NOFX AI (далі — «Програмне забезпечення»), яке ви завантажуєте, встановлюєте та запускаєте самостійно.
Щодо «Програмного забезпечення», ви є єдиним контролером усіх даних (включаючи, але не обмежуючись, API-ключі, приватні ключі, торгові дані тощо), які ви вводите або обробляєте. Ми не можемо отримати доступ, переглядати, збирати або обробляти будь-яку інформацію, яку ви вводите в локальний екземпляр «Програмного забезпечення».
II. Інформація, яку ми збираємо (на Веб-сайті), та як ми її використовуємо
A. Інформація, яку ми збираємо (Веб-сайт)
Ґрунтуючись на запитах користувачів, ми обмежили практику збору даних до мінімуму. Ми не вимагаємо від вас створення облікового запису, заповнення форм або надання будь-якої персонально ідентифікованої інформації (PII) при відвідуванні «Веб-сайту».
Єдина категорія даних, яку ми збираємо, — це «автоматично зібрані дані», які реалізуються через Google Analytics (GA4).
B. Розкриття інформації про Google Analytics (GA4)
Наш «Веб-сайт» використовує сервіс Google Analytics 4 (GA4). Це єдиний спосіб, яким ми збираємо інформацію. Відповідно до Умов обслуговування Google, ми повинні розкрити вам це використання.
Типи даних, що збираються: GA4 автоматично збирає певну інформацію про ваш візит, яка зазвичай не є персонально ідентифікованою. Це може включати:
Кількість користувачів
Статистику сеансів
Приблизне географічне розташування (неточне)
Інформацію про браузер і пристрій
Використання даних: Ми використовуємо ці агреговані дані виключно для того, щоб краще розуміти, як користувачі отримують доступ до наших сервісів і використовують їх, тим самим покращуючи продуктивність і користувацький досвід нашого «Веб-сайту».
Ваш вибір і відмова: Ми поважаємо ваше право на конфіденційність. Якщо ви не хочете, щоб GA4 збирав дані про ваші відвідування, ви можете відмовитися, встановивши доповнення для браузера Google Analytics Opt-out. Ви можете отримати це доповнення, перейшовши за цим посиланням: [Google Analytics Opt-out Add-on (by Google)](https://chromewebstore.google.com/detail/google-analytics-opt-out/fllaojicojecljbmefodhfapmkghcbnh?hl=en).
C. Файли cookie та механізми відстеження
Робота GA4 залежить від файлів cookie першої сторони. Зокрема, можуть використовуватися такі файли cookie, як _ga і _ga_<container-id>, для розрізнення унікальних користувачів і сеансів. Ми явно заявляємо, що не використовуємо ці файли cookie в рекламних цілях або для профілювання користувачів.
III. Інформація, яку ми НЕ збираємо (Програмне забезпечення)
Цей розділ спрямований на чітке викладення нашої позиції щодо ізоляції даних, пов'язаної з «Програмним забезпеченням».
A. Заява про некастодіальність
Ми (NOFX) є постачальником некастодіального програмного забезпечення. Це означає, що ми ніколи не зберігаємо, не контролюємо і не отримуємо доступ до ваших коштів, активів або конфіденційних облікових даних.
B. Явний список даних, що не збираються
Коли ви завантажуєте, встановлюєте та використовуєте самостійно розміщене «Програмне забезпечення», ми абсолютно жодним чином не збираємо, не отримуємо доступ, не зберігаємо, не обробляємо і не передаємо наступні дані:
Будь-які API-ключі для сторонніх бірж (таких як Binance)
Будь-які API-ключі для сторонніх сервісів ШІ (таких як DeepSeek, Qwen)
Ваші секретні ключі (Secret Keys), що відповідають вашим API-ключам
Ваші приватні ключі криптовалют (наприклад, приватні ключі Ethereum для Hyperliquid або Aster DEX)
Ваші «секретні фрази» гаманця (мнемонічні фрази)
Вашу торгову історію, позиції, баланси рахунків або будь-яку іншу фінансову інформацію
Будь-які персональні дані, які ви налаштовуєте в локальному екземплярі «Програмного забезпечення»
C. Примітка про локальне шифрування
Ми знаємо, що «Програмне забезпечення» надає функцію шифрування введених користувачем API-ключів і приватних ключів. Ми уточнюємо тут, що цей процес шифрування повністю виконується та керується на вашому власному пристрої (локально). Ці дані ніколи не передаються нам або будь-якій третій стороні після шифрування. Ця функція шифрування призначена для захисту ваших даних від несанкціонованого доступу до вашого локального пристрою, а не для обміну ними з нами.
IV. Обмін даними, зберігання та безпека (Дані веб-сайту)
A. Обмін з третіми сторонами
За винятком випадків, розкритих у цій Політиці (тобто обміну аналітичними даними, зібраними GA4, з нашим постачальником послуг Google), ми не передаємо, не продаємо, не здаємо в оренду і не обмінюємо вашу персональну інформацію з будь-якими третіми сторонами.
B. Зберігання даних
Ми зберігаємо агреговані аналітичні дані, зібрані GA4, тільки протягом періоду, розумно необхідного для досягнення цілей, описаних у цій Політиці (тобто аналітика та покращення веб-сайту).
C. Безпека даних
Ми застосовуємо комерційно розумні заходи безпеки (наприклад, використання HTTPS) для захисту передачі даних «Веб-сайту» та для захисту обмеженої інформації, яку ми збираємо (через GA4).
V. Ваші права на захист даних (GDPR і CCPA)
A. Обсяг прав
Відповідно до застосовних законів про захист даних (таких як GDPR або CCPA) ви можете мати певні права. Ми уточнюємо тут, що ці права застосовуються лише до обмежених аналітичних даних GA4, які ми зберігаємо як контролер даних, зібраних через «Веб-сайт». Ми не можемо виконати будь-які запити щодо даних «Програмного забезпечення», оскільки ми не зберігаємо такі дані.
B. Список прав
Відповідно до закону ви маєте право на:
Право доступу: Ви маєте право запитати копію персональних даних, які ми зберігаємо про вас.
Право на виправлення: Ви маєте право запитати виправлення інформації, яку вважаєте неточною або неповною.
Право на видалення (право бути забутим): За певних умов ви маєте право запитати видалення ваших персональних даних.
Право на обмеження обробки: За певних умов ви маєте право запитати обмеження обробки ваших персональних даних.
Право на заперечення проти обробки: За певних умов ви маєте право заперечувати проти нашої обробки ваших персональних даних.
C. Як реалізувати свої права
Якщо ви хочете реалізувати будь-яке з вищезазначених прав, будь ласка, зв'яжіться з нами, використовуючи контактну інформацію, надану в кінці цієї Політики.
VI. Конфіденційність дітей
Наш «Веб-сайт» і «Програмне забезпечення» не призначені і не спрямовані на осіб молодше 18 років. Ми свідомо не збираємо персональну інформацію від дітей молодше 18 років.
VII. Зміни в Політиці конфіденційності
Ми залишаємо за собою право змінювати цю Політику конфіденційності в будь-який час. Про будь-які зміни буде повідомлено шляхом публікації оновленої версії на «Веб-сайті» та зміни дати «Останнього оновлення».
VIII. Контактна інформація
Якщо у вас є будь-які питання про цю Політику конфіденційності або про наші методи обробки даних, будь ласка, зв'яжіться з нами:
[@nofx_ai](https://x.com/nofx_ai)

102
docs/i18n/uk/README.md
View File

@@ -6,7 +6,7 @@
[![License](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](LICENSE)
[![Backed by Amber.ac](https://img.shields.io/badge/Backed%20by-Amber.ac-orange.svg)](https://amber.ac)
**Мови / Languages:** [English](../../../README.md) | [中文](../zh-CN/README.md) | [Українська](../uk/README.md) | [Русский](../ru/README.md)
**Мови / Languages:** [English](../../../README.md) | [中文](../zh-CN/README.md) | [Українська](../uk/README.md) | [Русский](../ru/README.md) | [日本語](../ja/README.md)
**Офіційний Twitter:** [@nofx_ai](https://x.com/nofx_ai)
@@ -20,6 +20,9 @@
- [👥 Спільнота розробників](#-спільнота-розробників)
- [🆕 Останні оновлення](#-останні-оновлення)
- [🏗️ Технічна Архітектура](#️-технічна-архітектура)
- [💰 Реєстрація акаунта Binance](#-реєстрація-акаунта-binance-заощаджуйте-на-комісіях)
- [🔷 Реєстрація акаунта Hyperliquid](#-використання-біржі-hyperliquid)
- [🔶 Реєстрація акаунта Aster DEX](#-використання-біржі-aster-dex)
- [📸 Системні Скріншоти](#-системні-скріншоти)
- [🎮 Швидкий Старт](#-швидкий-старт)
- [📊 AI Модель](#-ai-модель)
@@ -98,7 +101,7 @@ NOFX тепер підтримує **три основні біржі**: Binance
3. Додайте `"hyperliquid_private_key": "your_key"`
4. Почніть торгувати!
Див. [Посібник з конфігурації](#-альтернатива-використання-біржі-hyperliquid).
Див. [Посібник з конфігурації](#-використання-біржі-hyperliquid).
#### **Біржа Aster DEX** (НОВЕ! v2.0.2)
@@ -484,18 +487,93 @@ cp config.json.example config.json
---
#### 🔷 Альтернатива: Використання біржі Hyperliquid
#### 🔷 Використання біржі Hyperliquid
**NOFX також підтримує Hyperliquid** - децентралізовану біржу безстрокових ф'ючерсів. Щоб використовувати Hyperliquid замість Binance:
**NOFX підтримує Hyperliquid** - високопродуктивну децентралізовану біржу безстрокових ф'ючерсів!
**Крок 1**: Отримайте приватний ключ Ethereum (для автентифікації Hyperliquid)
**Чому обрати Hyperliquid?**
- 🚀 **Висока продуктивність**: Блискавично швидке виконання на блокчейні L1
- 💰 **Низькі комісії**: Конкурентні комісії мейкера/тейкера
- 🔐 **Без зберігання**: Ваші ключі, ваші монети
- 🌐 **Без KYC**: Анонімна торгівля
- 💎 **Глибока ліквідність**: Книга ордерів інституційного рівня
1. Відкрийте **MetaMask** (або будь-який Ethereum гаманець)
2. Експортуйте приватний ключ
3. **Видаліть префікс `0x`** з ключа
4. Поповніть гаманець на [Hyperliquid](https://hyperliquid.xyz)
---
**Крок 2**: Налаштуйте `config.json` для Hyperliquid
### 📝 Посібник з реєстрації та налаштування
**Крок 1: Зареєструйте акаунт Hyperliquid**
1. **Відвідайте Hyperliquid за реферальним посиланням** (отримайте переваги!):
**🎁 [Зареєструватися на Hyperliquid - Приєднатися до AITRADING](https://app.hyperliquid.xyz/join/AITRADING)**
2. **Підключіть свій гаманець**:
- Натисніть "Connect Wallet" у верхньому правому куті
- Виберіть MetaMask, WalletConnect або інші Web3 гаманці
- Підтвердіть підключення
3. **Увімкніть торгівлю**:
- Перше підключення запропонує вам підписати повідомлення
- Це авторизує ваш гаманець для торгівлі (без комісій за газ)
- Ви побачите відображену адресу вашого гаманця
**Крок 2: Поповніть свій гаманець**
1. **Переведіть активи на Arbitrum**:
- Hyperliquid працює на Arbitrum L2
- Переведіть USDC з Ethereum мейннету або інших ланцюгів
- Або безпосередньо виведіть USDC з бірж на Arbitrum
2. **Внесіть депозит на Hyperliquid**:
- Натисніть "Deposit" в інтерфейсі Hyperliquid
- Виберіть суму USDC для депозиту
- Підтвердіть транзакцію (невелика комісія за газ на Arbitrum)
- Кошти з'являться на вашому рахунку Hyperliquid протягом кількох секунд
**Крок 3: Налаштуйте Agent Wallet (Рекомендується)**
Hyperliquid підтримує **Agent Wallets** - безпечні під-гаманці спеціально для автоматизації торгівлі!
⚠️ **Чому використовувати Agent Wallet:**
- ✅ **Більше безпеки**: Ніколи не розкривайте приватний ключ основного гаманця
- ✅ **Обмежений доступ**: Agent має лише торгові дозволи
- ✅ **Відкликання**: Можна відключити в будь-який час з інтерфейсу Hyperliquid
- ✅ **Окремі кошти**: Тримайте основні активи в безпеці
**Як створити Agent Wallet:**
1. **Увійдіть на Hyperliquid** використовуючи основний гаманець
- Відвідайте [https://app.hyperliquid.xyz](https://app.hyperliquid.xyz)
- Підключіться з гаманцем, який ви зареєстрували (за реферальним посиланням)
2. **Перейдіть до налаштувань Agent**:
- Натисніть на адресу вашого гаманця (верхній правий кут)
- Перейдіть до "Settings" → "API & Agents"
- Або відвідайте: [https://app.hyperliquid.xyz/agents](https://app.hyperliquid.xyz/agents)
3. **Створіть новий Agent**:
- Натисніть "Create Agent" або "Add Agent"
- Система автоматично згенерує новий agent гаманець
- **Збережіть адресу agent гаманця** (починається з `0x`)
- **Збережіть приватний ключ agent** (показується лише один раз!)
4. **Деталі Agent Wallet**:
- Main Wallet: Ваш підключений гаманець (зберігає кошти)
- Agent Wallet: Під-гаманець для торгівлі (NOFX використовуватиме його)
- Private Key: Потрібен лише для конфігурації NOFX
5. **Поповніть свій Agent** (Опціонально):
- Переведіть USDC з основного гаманця на agent гаманець
- Або тримайте кошти в основному гаманці (agent може торгувати з нього)
6. **Збережіть облікові дані для NOFX**:
- Адреса основного гаманця: `0xYourMainWalletAddress` (з `0x`)
- Приватний ключ Agent: `YourAgentPrivateKeyWithout0x` (видаліть префікс `0x`)
---
~~Налаштуйте `config.json` для Hyperliquid~~ *Налаштуйте через веб-інтерфейс*
```json
{
@@ -528,9 +606,9 @@ cp config.json.example config.json
---
#### 🔶 Альтернатива: Використання біржі Aster DEX
#### 🔶 Використання біржі Aster DEX
**NOFX також підтримує Aster DEX** - децентралізовану біржу безстрокових ф'ючерсів, сумісну з Binance!
**NOFX підтримує Aster DEX** - децентралізовану біржу безстрокових ф'ючерсів, сумісну з Binance!
**Чому обрати Aster?**
- 🎯 API сумісний з Binance (легка міграція)

155
docs/i18n/uk/TERMS OF SERVICE.md Normal file
View File

@@ -0,0 +1,155 @@
Угода користувача NOFX (Умови надання послуг)
Остання дата оновлення: 07.11.2025
1. Вступ та прийняття умов
A. Угода
Ця Угода користувача (далі «Угода» або «Умови») є юридично обов'язковою угодою між вами (далі «ви» або «Користувач») та NOFX (далі «ми» або «NOFX»).
B. Сфера застосування
Ця Угода регулює ваш доступ до веб-сайту nofxai.com (далі «Веб-сайт») та його використання, а також завантаження, встановлення та використання операційної системи NOFX AI для торгівлі (далі «Програмне забезпечення»).
C. Прийняття умов
Здійснюючи доступ до Веб-сайту або завантажуючи, встановлюючи чи використовуючи Програмне забезпечення будь-яким способом, ви підтверджуєте, що прочитали, зрозуміли і погодилися дотримуватися цих Умов. Якщо ви не погоджуєтеся з цими Умовами, ви повинні негайно припинити доступ до Веб-сайту та використання Програмного забезпечення.
D. Вікова вимога
Для використання Веб-сайту та Програмного забезпечення вам має бути не менше 18 років або ви повинні досягти повноліття у вашій юрисдикції.
2. Ліцензія на програмне забезпечення та модель послуг
A. Веб-сайт
Ми надаємо вам обмежену, неексклюзивну, непередавану, відкличну ліцензію на доступ до Веб-сайту та його використання в інформаційних цілях.
B. Програмне забезпечення (самостійне розміщення)
Ліцензія AGPL-3.0: Ми явно інформуємо вас про те, що вихідний код Програмного забезпечення NOFX надається вам на умовах ліцензії GNU Affero General Public License v3.0 (AGPL-3.0) (далі «AGPL-3.0»).
Характер умов: Ця Угода не змінює, не замінює і не обмежує ваші права за AGPL-3.0. AGPL-3.0 є вашою ліцензією на програмне забезпечення. Ця Угода є угодою про надання послуг, яка регулює використання вами нашої повної екосистеми послуг (включаючи використання Веб-сайту та Програмного забезпечення) та встановлює ключові обов'язки та відмови від відповідальності, описані нижче, які не охоплюються AGPL-3.0.
3. Підтвердження критичних ризиків (фінансові)
Цей розділ стосується ваших істотних інтересів. Уважно прочитайте. Усі умови в цьому розділі представлені помітними великими літерами для забезпечення їх юридичної значимості.
A. Відсутність фінансових або інвестиційних консультацій:
ВЕБ-САЙТ ТА ПРОГРАМНЕ ЗАБЕЗПЕЧЕННЯ НАДАЮТЬСЯ ВИКЛЮЧНО ЯК ТЕХНІЧНІ ІНСТРУМЕНТИ. МИ НЕ Є ФІНАНСОВОЮ УСТАНОВОЮ, БРОКЕРОМ, ФІНАНСОВИМ КОНСУЛЬТАНТОМ АБО ІНВЕСТИЦІЙНИМ КОНСУЛЬТАНТОМ. БУДЬ-ЯКИЙ ВМІСТ, ФУНКЦІОНАЛЬНІСТЬ АБО РЕЗУЛЬТАТИ РОБОТИ ШІ, ЩО НАДАЮТЬСЯ ЦІЄЮ ПОСЛУГОЮ, НЕ Є ФІНАНСОВИМИ, ІНВЕСТИЦІЙНИМИ, ЮРИДИЧНИМИ, ПОДАТКОВИМИ АБО ТОРГОВИМИ КОНСУЛЬТАЦІЯМИ.
B. Екстремальний ризик фінансових втрат:
ВИ ВИЗНАЄТЕ ТА ПОГОДЖУЄТЕСЬ З ТИМ, ЩО ТОРГІВЛЯ КРИПТОВАЛЮТАМИ ТА ІНШИМИ ФІНАНСОВИМИ АКТИВАМИ Є ВИСОКОВОЛАТИЛЬНОЮ, СПЕКУЛЯТИВНОЮ ТА ПОВ'ЯЗАНА З ПРИТАМАННИМИ РИЗИКАМИ. ВИКОРИСТАННЯ АВТОМАТИЗОВАНИХ, АЛГОРИТМІЧНИХ ТА ШІ-КЕРОВАНИХ ТОРГОВИХ СИСТЕМ (ТАКИХ ЯК ЦЕ ПРОГРАМНЕ ЗАБЕЗПЕЧЕННЯ) ПОВ'ЯЗАНЕ ЗІ ЗНАЧНИМИ ТА УНІКАЛЬНИМИ РИЗИКАМИ ТА МОЖЕ ПРИЗВЕСТИ ДО ІСТОТНИХ АБО ПОВНИХ ФІНАНСОВИХ ВТРАТ.
C. Відсутність гарантії прибутку або продуктивності:
МИ НЕ ДАЄМО ЖОДНИХ ЯВНИХ АБО ПРИХОВАНИХ ГАРАНТІЙ, ЗАЯВ АБО ОБІЦЯНОК ЩОДО ПРОДУКТИВНОСТІ, ПРИБУТКОВОСТІ АБО ТОЧНОСТІ БУДЬ-ЯКИХ ТОРГОВИХ СИГНАЛІВ, ЩО ГЕНЕРУЮТЬСЯ ПРОГРАМНИМ ЗАБЕЗПЕЧЕННЯМ. МИНУЛІ РЕЗУЛЬТАТИ БУДЬ-ЯКОЇ МОДЕЛІ ШІ АБО ТОРГОВОЇ СТРАТЕГІЇ ЖОДНИМ ЧИНОМ НЕ ПРЕДСТАВЛЯЮТЬ І НЕ ГАРАНТУЮТЬ МАЙБУТНІХ РЕЗУЛЬТАТІВ.
D. Повна відповідальність користувача:
ВИ НЕСЕТЕ ПОВНУ ТА ОДНООСІБНУ ВІДПОВІДАЛЬНІСТЬ ЗА ВСІ СВОЇ ТОРГОВІ РІШЕННЯ, ЗАМОВЛЕННЯ, ВИКОНАННЯ ТА ОСТАТОЧНІ РЕЗУЛЬТАТИ. УСІ УГОДИ, ЩО ЗДІЙСНЮЮТЬСЯ ЧЕРЕЗ ПРОГРАМНЕ ЗАБЕЗПЕЧЕННЯ, ВВАЖАЮТЬСЯ ЗАСНОВАНИМИ НА ВАШОМУ САМОСТІЙНОМУ РІШЕННІ ТА ПРИЙНЯТТІ РИЗИКУ І ЗДІЙСНЮЮТЬСЯ НА ВАШ ВЛАСНИЙ РИЗИК.
4. Підтвердження критичних ризиків (штучний інтелект та програмне забезпечення)
Цей розділ також стосується ваших істотних інтересів і представлений великими літерами.
A. Відмова від відповідальності «ЯК Є» та «У МІРУ ДОСТУПНОСТІ»:
ВЕБ-САЙТ ТА ПРОГРАМНЕ ЗАБЕЗПЕЧЕННЯ НАДАЮТЬСЯ «ЯК Є» (AS IS) ТА «У МІРУ ДОСТУПНОСТІ» (AS AVAILABLE) БЕЗ БУДЬ-ЯКИХ ГАРАНТІЙ, ЯВНИХ АБО ПРИХОВАНИХ. МИ НЕ ГАРАНТУЄМО, ЩО СЕРВІС БУДЕ БЕЗПЕРЕБІЙНИМ, ТОЧНИМ, БЕЗПОМИЛКОВИМ, БЕЗПЕЧНИМ АБО ВІЛЬНИМ ВІД ВІРУСІВ АБО ІНШИХ ШКІДЛИВИХ КОМПОНЕНТІВ.
B. Відмова від відповідальності за результати роботи ШІ та «галюцинації»:
ВРАХОВУЮЧИ, ЩО ОСНОВНА ФУНКЦІОНАЛЬНІСТЬ ЦЬОГО ПРОГРАМНОГО ЗАБЕЗПЕЧЕННЯ ЗАЛЕЖИТЬ ВІД МОДЕЛЕЙ ШІ ТРЕТІХ СТОРІН, ВИ ПОВИННІ РОЗУМІТИ ТА ПРИЙМАТИ ПРИТАМАННІ ОБМЕЖЕННЯ ТЕХНОЛОГІЇ ШІ. РЕЗУЛЬТАТИ РОБОТИ ШІ (ВКЛЮЧАЮЧИ РІШЕННЯ АГЕНТІВ ШІ) Є НОВОЮ ТЕХНОЛОГІЄЮ, І ЇХ ЮРИДИЧНА ВІДПОВІДАЛЬНІСТЬ ПОКИ НЕ ЯСНА.
ВИ ЦИМ ВИЗНАЄТЕ ТА ПОГОДЖУЄТЕСЯ З ТИМ, ЩО:
Результати ШІ можуть бути дефектними: МОДЕЛІ ШІ ТА РЕЗУЛЬТАТИ, ІНТЕГРОВАНІ АБО ЗГЕНЕРОВАНІ ПРОГРАМНИМ ЗАБЕЗПЕЧЕННЯМ, МОЖУТЬ МІСТИТИ ПОМИЛКИ, НЕТОЧНОСТІ, ПРОПУСКИ, УПЕРЕДЖЕННЯ АБО СТВОРЮВАТИ ТАК ЗВАНІ «ГАЛЮЦИНАЦІЇ» (HALLUCINATIONS) - ПОВНІСТЮ ПОМИЛКОВУ АБО ВИГАДАНУ ІНФОРМАЦІЮ.
Ви несете весь ризик самостійно: ВИ ПОГОДЖУЄТЕСЬ З ТИМ, ЩО БУДЬ-ЯКЕ ВИКОРИСТАННЯ АБО ДОВІРА ДО РЕЗУЛЬТАТІВ, ЗГЕНЕРОВАНИХ ШІ (ВКЛЮЧАЮЧИ БУДЬ-ЯКІ ТОРГОВІ РІШЕННЯ), ЗДІЙСНЮЄТЬСЯ НА ВАШ ВЛАСНИЙ РИЗИК.
Не може замінити професійні консультації: ВИ НЕ ПОВИННІ РОЗГЛЯДАТИ РЕЗУЛЬТАТИ ШІ ЯК ЄДИНЕ ДЖЕРЕЛО ІСТИНИ, ФАКТИЧНУ ІНФОРМАЦІЮ АБО ЯК ЗАМІНУ ПРОФЕСІЙНИХ ФІНАНСОВИХ КОНСУЛЬТАЦІЙ.
C. Кінцева відповідальність користувача:
ВИ ПОГОДЖУЄТЕСЬ НЕСТИ КІНЦЕВУ ВІДПОВІДАЛЬНІСТЬ ЗА ВСІ ДІЇ, ВЖИТІ НА ОСНОВІ РЕЗУЛЬТАТІВ ШІ. ВИ ПОВИННІ САМОСТІЙНО ПРОВЕСТИ НАЛЕЖНУ ПЕРЕВІРКУ ТА ПЕРЕВІРИТИ ТОЧНІСТЬ ІНФОРМАЦІЇ ПЕРЕД ЗДІЙСНЕННЯМ БУДЬ-ЯКИХ УГОД, РЕКОМЕНДОВАНИХ ШІ.
5. Обов'язки користувача та відповідальність за безпеку
A. Повна відповідальність за ключі API та приватні ключі
Це одна з найбільш критичних умов цієї Угоди, що стосується основної функціональності Програмного забезпечення.
ВИ ВИЗНАЄТЕ ТА ПОГОДЖУЄТЕСЬ З ТИМ, ЩО НЕСЕТЕ ВИКЛЮЧНУ, ОДНООСІБНУ ТА ПОВНУ ВІДПОВІДАЛЬНІСТЬ ЗА ЗАХИСТ, ЗБЕРЕЖЕННЯ, ЗАБЕЗПЕЧЕННЯ БЕЗПЕКИ ТА РЕЗЕРВНЕ КОПІЮВАННЯ ВСІХ КЛЮЧІВ API, СЕКРЕТНИХ КЛЮЧІВ, АДРЕС ГАМАНЦІВ, ПРИВАТНИХ КЛЮЧІВ ТА БУДЬ-ЯКИХ SEED-ФРАЗ («СЕКРЕТНА ФРАЗА»), ЩО ВИКОРИСТОВУЮТЬСЯ З ПРОГРАМНИМ ЗАБЕЗПЕЧЕННЯМ. ВИ ПОВИННІ ЗАБЕЗПЕЧИТИ ДОСТАТНЮ БЕЗПЕКУ ТА КОНТРОЛЬ НАД ЦИМИ ОБЛІКОВИМИ ДАНИМИ.
B. Підтвердження некастодіального характеру
ВИ ВИЗНАЄТЕ ТА ПОГОДЖУЄТЕСЬ З ТИМ, ЩО МИ (NOFX) Є НЕКАСТОДІАЛЬНИМ ПОСТАЧАЛЬНИКОМ ПРОГРАМНОГО ЗАБЕЗПЕЧЕННЯ. МИ НІКОЛИ НЕ ЗБИРАЄМО, НЕ ЗБЕРІГАЄМО, НЕ ОТРИМУЄМО ТА ЖОДНИМ ЧИНОМ НЕ ОТРИМУЄМО ДОСТУП ДО ВАШИХ КЛЮЧІВ API, ПРИВАТНИХ КЛЮЧІВ АБО SEED-ФРАЗ. МИ НІКОЛИ НЕ БУДЕМО ПРОСИТИ ВАС ПОДІЛИТИСЯ ЦИМИ ОБЛІКОВИМИ ДАНИМИ.
ОТЖЕ, МИ НЕ МАЄМО МОЖЛИВОСТІ ОТРИМАТИ ДОСТУП ДО ВАШИХ КОШТІВ, ВІДНОВИТИ ВТРАЧЕНІ КЛЮЧІ АБО СКАСУВАТИ АБО ВІДКЛИКАТИ БУДЬ-ЯКІ ТРАНЗАКЦІЇ. ВИ НЕСЕТЕ ПОВНУ ВІДПОВІДАЛЬНІСТЬ ЗА ВСІ ВТРАТИ, ЩО ВИНИКЛИ ВНАСЛІДОК ВТРАТИ, КРАДІЖКИ АБО КОМПРОМЕТАЦІЇ ВАШИХ КЛЮЧІВ (БУДЬ ТО КЛЮЧІ API АБО ПРИВАТНІ КЛЮЧІ).
C. Керована користувачем шифрування
ВИ ВИЗНАЄТЕ, ЩО У ВАШОМУ САМОСТІЙНО РОЗМІЩЕНОМУ ПРИМІРНИКУ ВИ НЕСЕТЕ ВІДПОВІДАЛЬНІСТЬ ЗА ШИФРУВАННЯ ВАШИХ КЛЮЧІВ ТА ОБЛІКОВИХ ДАНИХ В УСІХ СХОВИЩАХ ТА КОМУНІКАЦІЯХ. БУДЬ-ЯКА ФУНКЦІОНАЛЬНІСТЬ ШИФРУВАННЯ, ЩО НАДАЄТЬСЯ В ПРОГРАМНОМУ ЗАБЕЗПЕЧЕННІ, НАДАЄТЬСЯ «ЯК Є» БЕЗ БУДЬ-ЯКИХ ГАРАНТІЙ БЕЗПЕКИ.
D. Умови третіх сторін
ПРИ ВИКОРИСТАННІ ПРОГРАМНОГО ЗАБЕЗПЕЧЕННЯ ДЛЯ ПІДКЛЮЧЕННЯ ДО БУДЬ-ЯКИХ СЕРВІСІВ ТРЕТІХ СТОРІН (ТАКИХ ЯК BINANCE, HYPERLIQUID, DEEPSEEK, QWEN ТОЩО), ВИ НЕСЕТЕ ВІДПОВІДАЛЬНІСТЬ ЗА ДОТРИМАННЯ ВСІХ УМОВ НАДАННЯ ПОСЛУГ, ПОЛІТИКИ КОМІСІЙ ТА ПРАВИЛ ВИКОРИСТАННЯ ЦИХ СЕРВІСІВ ТРЕТІХ СТОРІН.
6. Політика допустимого використання (AUP)
Ви погоджуєтесь не використовувати Веб-сайт або Програмне забезпечення в незаконних цілях або цілях, заборонених цими Умовами. Заборонені дії включають (але не обмежуються ними):
Незаконна діяльність: Здійснення будь-якої діяльності, що порушує місцеві, державні, національні або міжнародні закони або нормативні акти.
Зловживання системою: Здійснення будь-яких «хакерських атак» (Hacking), «спаму» (Spamming), «поштових бомбардувань» або «атак типу відмова в обслуговуванні» (DoS).
Безпека: Спроби зондування, сканування або тестування вразливостей Веб-сайту або пов'язаних мереж, або порушення заходів безпеки або автентифікації.
Вилучення даних: Використання будь-яких автоматизованих систем (включаючи «вилучення даних», «веб-скрейпінг» або «ботів») для комерційних цілей для вилучення даних з Веб-сайту.
Шкідливе ПЗ: Впровадження будь-яких вірусів, троянів, черв'яків або іншого шкідливого коду.
7. Інтелектуальна власність (IP)
A. Вміст веб-сайту
Ми та наші ліцензіари зберігаємо всі права інтелектуальної власності на Веб-сайт та весь його вміст (включаючи текст, графіку, логотипи, елементи візуального дизайну).
B. Інтелектуальна власність програмного забезпечення
Програмне забезпечення є проектом з відкритим вихідним кодом. Його права інтелектуальної власності регулюються ліцензією AGPL-3.0.
C. Користувацький контент/зворотний зв'язок
Якщо ви надаєте нам будь-які відгуки, стратегії, пропозиції або внесок («Користувацький контент»), ви надаєте нам постійну, безвідкличну, всесвітню, безоплатну ліцензію на використання, розміщення, відтворення, зміну та відображення такого контенту.
8. Обмеження відповідальності та відшкодування збитків
Цей розділ обмежує нашу юридичну відповідальність та вимагає від вас прийняти відповідальність за шкоду, спричинену вами. Уважно прочитайте. Усі умови в цьому розділі представлені помітними великими літерами.
A. Обмеження відповідальності:
ЦЯ УМОВА РОЗРОБЛЕНА НА ОСНОВІ АНАЛІЗУ ЮРИДИЧНИХ ПОЗОВІВ, З ЯКИМИ СТИКАЮТЬСЯ КАСТОДІАЛЬНІ ПОСТАЧАЛЬНИКИ ПОСЛУГ, ТА ВИКОРИСТОВУЄ НАШУ ЮРИДИЧНУ ПОЗИЦІЮ ЯК НЕКАСТОДІАЛЬНОГО ПОСТАЧАЛЬНИКА САМОСТІЙНО РОЗМІЩУВАНОГО ПРОГРАМНОГО ЗАБЕЗПЕЧЕННЯ.
У МАКСИМАЛЬНІЙ МІРІ, ДОЗВОЛЕНІЙ ЗАСТОСОВНИМ ЗАКОНОДАВСТВОМ, NOFX (ТА ЙОГО АФІЛІЙОВАНІ ОСОБИ, ДИРЕКТОРИ, СПІВРОБІТНИКИ АБО ЛІЦЕНЗІАРИ) ЗА БУДЬ-ЯКИХ ОБСТАВИН НЕ НЕСУТЬ ВІДПОВІДАЛЬНОСТІ ПЕРЕД ВАМИ ЗА БУДЬ-ЯКУ НЕПРЯМУ, ШТРАФНУ, ВИПАДКОВУ, СПЕЦІАЛЬНУ, НАСЛІДКОВУ АБО ПОКАЗОВУ ШКОДУ, ВКЛЮЧАЮЧИ, АЛЕ НЕ ОБМЕЖУЮЧИСЬ, ВТРАТОЮ ПРИБУТКУ, КОШТІВ АБО ДАНИХ, АБО ШКОДОЮ, ЩО ВИНИКЛА ВНАСЛІДОК КРАДІЖКИ АБО ВТРАТИ ВАШИХ КЛЮЧІВ API АБО ПРИВАТНИХ КЛЮЧІВ, ЩО ВИНИКАЄ ВНАСЛІДОК:
ВАШОГО ВИКОРИСТАННЯ АБО НЕМОЖЛИВОСТІ ВИКОРИСТАННЯ ВЕБ-САЙТУ АБО ПРОГРАМНОГО ЗАБЕЗПЕЧЕННЯ;
БУДЬ-ЯКИХ ДЕФЕКТІВ, ПОМИЛОК, ВІРУСІВ, НЕТОЧНОСТЕЙ АБО ЗАТРИМОК У ПРОГРАМНОМУ ЗАБЕЗПЕЧЕННІ;
БУДЬ-ЯКИХ РЕЗУЛЬТАТІВ, ЗГЕНЕРОВАНИХ ШІ, «ГАЛЮЦИНАЦІЙ», ПОМИЛКОВИХ ТОРГОВИХ СИГНАЛІВ АБО НЕВДАЛИХ СТРАТЕГІЙ;
БУДЬ-ЯКОГО НЕСАНКЦІОНОВАНОГО ДОСТУПУ АБО ВИКОРИСТАННЯ ВАШОГО САМОСТІЙНО РОЗМІЩЕНОГО ПРИМІРНИКА АБО БУДЬ-ЯКОГО ПРИСТРОЮ, НА ЯКОМУ ВИ ЗБЕРІГАЄТЕ СВОЇ КЛЮЧІ;
ВСІХ ФІНАНСОВИХ ВТРАТ, ЩО ВИНИКЛИ ВНАСЛІДОК БУДЬ-ЯКИХ УГОД, АВТОМАТИЧНО ЗДІЙСНЕНИХ АБО РЕКОМЕНДОВАНИХ ПРОГРАМНИМ ЗАБЕЗПЕЧЕННЯМ.
ЯКЩО NOFX БУДЕ ВИЗНАНИЙ ТАКИМ, ЩО НЕСЕ ПРЯМУ ВІДПОВІДАЛЬНІСТЬ ПЕРЕД ВАМИ, НАША МАКСИМАЛЬНА СУКУПНА ВІДПОВІДАЛЬНІСТЬ ПОВИННА БУТИ ОБМЕЖЕНА БІЛЬШОЮ З НАСТУПНИХ СУМ: ЗБОРИ, СПЛАЧЕНІ ВАМИ НАМ ПРОТЯГОМ ДВАНАДЦЯТИ (12) МІСЯЦІВ ДО ПРЕД'ЯВЛЕННЯ ПРЕТЕНЗІЇ (ЯКЩО ТАКІ Є), АБО СТО ДОЛАРІВ США ($100.00).
B. Відшкодування збитків:
ВИ ПОГОДЖУЄТЕСЬ ЗАХИЩАТИ, ВІДШКОДОВУВАТИ ЗБИТКИ ТА ОГОРОДЖУВАТИ ВІД ВІДПОВІДАЛЬНОСТІ NOFX ТА ЙОГО АФІЛІЙОВАНІ ОСОБИ ВІД БУДЬ-ЯКИХ ПРЕТЕНЗІЙ, ВИМОГ, ПОЗОВІВ, ВТРАТ, ШКОДИ, ЗОБОВ'ЯЗАНЬ, ВИТРАТ ТА ВИДАТКІВ (ВКЛЮЧАЮЧИ РОЗУМНІ ГОНОРАРИ АДВОКАТІВ), ЩО ВИНИКАЮТЬ З АБО БУДЬ-ЯКИМ ЧИНОМ ПОВ'ЯЗАНІ З: (A) ВАШИМ ДОСТУПОМ АБО ВИКОРИСТАННЯМ ПРОГРАМНОГО ЗАБЕЗПЕЧЕННЯ; (B) ВАШИМ ПОРУШЕННЯМ ЦИХ УМОВ; (C) ВАШИМ ПОРУШЕННЯМ БУДЬ-ЯКИХ ПРАВ ТРЕТІХ СТОРІН, ВКЛЮЧАЮЧИ, АЛЕ НЕ ОБМЕЖУЮЧИСЬ, УМОВАМИ НАДАННЯ ПОСЛУГ БУДЬ-ЯКОЇ БІРЖІ АБО ПОСТАЧАЛЬНИКА ШІ, ДО ЯКИХ ВИ ПІДКЛЮЧАЄТЕСЯ; АБО (D) БУДЬ-ЯКИМИ ПРЕТЕНЗІЯМИ ТРЕТІХ СТОРІН ПРО ПОРУШЕННЯ ПРАВ ІНТЕЛЕКТУАЛЬНОЇ ВЛАСНОСТІ, ЩО ВИНИКАЮТЬ ВНАСЛІДОК ВАШОГО ВИКОРИСТАННЯ РЕЗУЛЬТАТІВ ШІ.
9. Припинення
A. Припинення з нашого боку
МИ ЗАЛИШАЄМО ЗА СОБОЮ ПРАВО НА ВЛАСНИЙ РОЗСУД НЕГАЙНО АБО ПІСЛЯ ПОВІДОМЛЕННЯ ПРИЗУПИНИТИ АБО ПРИПИНИТИ ВАШ ДОСТУП ДО ВЕБ-САЙТУ (ТА БУДЬ-ЯКИХ МАЙБУТНІХ ХОСТИНГОВИХ ПОСЛУГ, ЯКІ МИ МОЖЕМО ЗАПРОПОНУВАТИ) У РАЗІ ВАШОГО ПОРУШЕННЯ ЦИХ УМОВ АБО ПОЛІТИКИ ДОПУСТИМОГО ВИКОРИСТАННЯ.
B. Наслідки припинення
ПІСЛЯ ПРИПИНЕННЯ ВАША ЛІЦЕНЗІЯ НА ПРОГРАМНЕ ЗАБЕЗПЕЧЕННЯ ЗА AGPL-3.0 (ЯКЩО ВИ ЙОГО ЗАВАНТАЖИЛИ) ЗАЛИШАЄТЬСЯ В СИЛІ, АЛЕ ВАШЕ ПРАВО НА ВИКОРИСТАННЯ НАШОГО ВЕБ-САЙТУ БУДЕ ВІДКЛИКАНО. ВСІ УМОВИ, ПОВ'ЯЗАНІ З ВІДМОВАМИ ВІД ВІДПОВІДАЛЬНОСТІ, ОБМЕЖЕННЯМ ВІДПОВІДАЛЬНОСТІ, ВІДШКОДУВАННЯМ ЗБИТКІВ, ІНТЕЛЕКТУАЛЬНОЮ ВЛАСНІСТЮ ТА ЗАСТОСОВНИМ ПРАВОМ, ЗБЕРІГАЮТЬ СИЛУ ПІСЛЯ ПРИПИНЕННЯ.
10. Зміна умов
МИ ЗАЛИШАЄМО ЗА СОБОЮ ПРАВО НА ВЛАСНИЙ РОЗСУД ЗМІНЮВАТИ АБО ЗАМІНЮВАТИ ЦІ УМОВИ В БУДЬ-ЯКИЙ ЧАС. НА ВІДМІНУ ВІД ДЕЯКИХ УМОВ «ОДНОСТОРОННЬОГО ЗМІНИ» В ІНДУСТРІЇ, ЯКІ МОЖУТЬ ВВАЖАТИСЯ ТАКИМИ, ЩО НЕ МАЮТЬ ПОЗОВНОЇ СИЛИ, МИ БУДЕМО НАДАВАТИ ПОВІДОМЛЕННЯ ПРО ІСТОТНІ ЗМІНИ, РОЗМІЩУЮЧИ ОНОВЛЕНІ УМОВИ НА ВЕБ-САЙТІ ТА ОНОВЛЮЮЧИ ДАТУ «ОСТАННЬОГО ОНОВЛЕННЯ». ВАШЕ ПРОДОВЖЕННЯ ДОСТУПУ ДО ВЕБ-САЙТУ АБО ВИКОРИСТАННЯ ПРОГРАМНОГО ЗАБЕЗПЕЧЕННЯ ПІСЛЯ НАБУТТЯ ЧИННОСТІ ТАКИХ ЗМІН Є ВАШИМ ПРИЙНЯТТЯМ НОВИХ УМОВ.
11. Загальні положення
A. Застосовне право
ЦЯ УГОДА РЕГУЛЮЄТЬСЯ ТА ТЛУМАЧИТЬСЯ ВІДПОВІДНО ДО ЗАКОНОДАВСТВА [ВКАЗАНА ЮРИСДИКЦІЯ], БЕЗ ВРАХУВАННЯ ЙОГО ПРИНЦИПІВ КОЛІЗІЙНОГО ПРАВА.
B. Вирішення спорів
ЗА ВИНЯТКОМ ВИПАДКІВ, ЗАБОРОНЕНИХ ЗАСТОСОВНИМ ЗАКОНОДАВСТВОМ, ВИ ПОГОДЖУЄТЕСЬ З ТИМ, ЩО ВСІ СПОРИ, ЩО ВИНИКАЮТЬ З АБО ПОВ'ЯЗАНІ З ЦІЄЮ УГОДОЮ, БУДУТЬ ОСТАТОЧНО ВИРІШУВАТИСЯ ШЛЯХОМ ОБОВ'ЯЗКОВОГО АРБІТРАЖУ, ЩО ПРОВОДИТЬСЯ В [ВКАЗАНЕ МІСЦЕ].
C. Подільність та відмова від прав
ЯКЩО БУДЬ-ЯКЕ ПОЛОЖЕННЯ ЦІЄЇ УГОДИ БУДЕ ВИЗНАНО НЕЗАКОННИМ АБО ТАКИМ, ЩО НЕ МАЄ ПОЗОВНОЇ СИЛИ, РЕШТА ПОЛОЖЕНЬ ЗБЕРІГАЮТЬ ПОВНУ СИЛУ. НЕЗДАТНІСТЬ СТОРОНИ ЗАСТОСУВАТИ БУДЬ-ЯКЕ ПРАВО АБО ПОЛОЖЕННЯ ЦІЄЇ УГОДИ НЕ РОЗГЛЯДАЄТЬСЯ ЯК ВІДМОВА ВІД ТАКОГО ПРАВА АБО ПОЛОЖЕННЯ.
D. Повна угода
ЦЯ УГОДА (РАЗОМ З ЛІЦЕНЗІЄЮ НА ПРОГРАМНЕ ЗАБЕЗПЕЧЕННЯ AGPL-3.0) СТАНОВИТЬ ПОВНУ УГОДУ МІЖ ВАМИ ТА NOFX ЩОДО ПРЕДМЕТА ДОГОВОРУ.

111
docs/i18n/zh-CN/PRIVACY POLICY.md Normal file
View File

@@ -0,0 +1,111 @@
NOFX 隐私政策
最后更新时间：2025.11.07
一、 引言与范围
A. 介绍
本隐私政策（以下简称“政策”）旨在告知您，作为我们网站的用户，我们如何处理您的个人信息。本政策适用于 NOFX（以下简称“我们”或“我方”）作为数据控制者，处理通过 nofxai.com 及其任何子域名（以下简称“网站”）收集的信息。
B. 核心政策区别：网站数据与软件数据
本政策的核心是区分“网站”和“软件”。
网站数据：本政策管辖我们收集和处理的、来自我们“网站”访问者的个人信息。
软件数据：本政策 不适用于 您在您自行下载、安装和运行的 NOFX AI 交易操作系统（以下简称“软件”）的自托管（Self-Hosted）实例中处理的任何数据。
对于“软件”而言，您是您自己输入或处理的所有数据（包括但不限于 API 密钥、私钥、交易数据等）的唯一数据控制者 1。我们无法访问、查看、收集或处理您在“软件”本地实例中输入的任何信息。
二、 我们（在网站上）收集的信息及其使用方式
A. 我们收集的信息（网站）
根据您的用户查询，我们已将数据收集做法限制在最低限度。我们不会要求您在访问“网站”时创建账户、填写表格或提供任何个人身份信息（PII）。
我们唯一收集的数据类别是“自动收集的数据”，这是通过 Google Analytics (GA4) 实现的。
B. Google Analytics (GA4) 披露
我们的“网站”使用 Google Analytics 4 (GA4) 服务。这是我们收集信息的唯一途径。根据 Google 的服务条款，我们必须向您披露此项使用。
收集的数据类型：GA4 自动收集有关您访问的某些信息，这些信息通常是非个人身份信息。这可能包括：
用户数量
会话统计信息
大致的地理位置（非精确）
浏览器和设备信息
数据用途：我们使用这些汇总数据的唯一目的是为了更好地了解用户如何访问和使用我们的服务，从而改进我们“网站”的性能和用户体验。
您的选择与退出：我们尊重您的隐私选择权。如果您不希望 GA4 收集您的访问数据，您可以通过安装 Google Analytics 选择停用浏览器插件（Google Analytics Opt-out Browser Add-on）来选择退出。您可以通过访问此链接获取该插件：[Google Analytics Opt-out Add-on (by Google)](https://chromewebstore.google.com/detail/google-analytics-opt-out/fllaojicojecljbmefodhfapmkghcbnh?hl=en)。
C. Cookie 和跟踪机制
GA4 的运行依赖于第一方 Cookie。具体而言，它可能使用 _ga 和 _ga_<container-id> 等 Cookie 来区分唯一用户和会话。我们明确声明，我们不会将这些 Cookie 用于广告或用户画像目的。
三、 我们不收集的信息（软件）
本节旨在明确阐明我们与“软件”相关的数据隔离立场。
A. 非托管声明
我们（NOFX）是一个非托管（Non-Custodial）软件提供商。这意味着我们从不持有、控制或访问您的资金、资产或敏感凭证。
B. 明确的不收集列表
当您下载、安装和使用自托管“软件”时，我们绝对不会以任何方式收集、访问、存储、处理或传输以下任何数据：
任何第三方交易所（如 Binance）的 API 密钥
任何第三方 AI 服务（如 DeepSeek, Qwen）的 API 密钥
您的 API 密钥对应的密钥 (Secret Keys)
您的加密货币私钥（例如，用于 Hyperliquid 或 Aster DEX 的以太坊私钥）
您的钱包**“助记词”**（Secret Phrase）
您的交易历史、持仓情况、账户余额或任何其他财务信息
您在“软件”本地实例中配置的任何个人数据
C. 关于本地加密的说明
我们知悉“软件”提供了对用户输入的 API 密钥和私钥进行加密的功能。我们在此澄清，此加密过程完全在您自己的设备上（本地）进行和管理。这些数据在加密后绝不会被传输给我们或任何第三方。该加密功能是为了保护您的数据免受对您本地设备的未授权访问，而不是为了与我们共享。
四、 数据共享、保留和安全（网站数据）
A. 第三方共享
除本政策已披露的情况外（即与我们的服务提供商 Google 共享 GA4 收集的分析数据），我们不会与任何第三方共享、出售、出租或交易您的任何个人信息。
B. 数据保留
我们仅在实现本政策所述目的（即网站分析和改进）所合理必需的期限内保留 GA4 收集的汇总分析数据。
C. 数据安全
我们采取商业上合理的安全措施（例如，使用 HTTPS 17）来保护“网站”的传输，以保护我们（通过 GA4）有限收集的信息。
五、 您的数据保护权利 (GDPR & CCPA)
A. 权利范围
根据适用的数据保护法（如 GDPR 或 CCPA），您可能享有一些权利。我们在此明确，这些权利仅适用于我们作为数据控制者所持有的、通过“网站”收集的有限的 GA4 分析数据。我们无法满足有关“软件”数据的任何请求，因为我们不持有此类数据。
B. 权利列表
根据法律规定，您有权享有以下权利：
访问权：您有权请求获取我们持有的您的个人数据副本。
纠正权：您有权请求我们纠正您认为不准确或不完整的信息。
删除权（被遗忘权）：在某些条件下，您有权请求我们删除您的个人数据。
限制处理权：在某些条件下，您有权请求我们限制处理您的个人数据。
反对处理权：在某些条件下，您有权反对我们处理您的个人数据。
C. 如何行使您的权利
如果您希望行使上述任何权利，请通过本政策末尾提供的联系方式与我们联系。
六、 儿童隐私
我们的“网站”和“软件”不适用于也非针对18岁以下的个人。我们不会故意收集18岁以下儿童的个人信息。
七、 隐私政策的变更
我们保留随时修改本隐私政策的权利。任何更改都将通过在“网站”上发布更新版本并修改“最后更新时间”日期来通知您。
八、 联系方式
如果您对本隐私政策或我们的数据处理做法有任何疑问，请联系我们：
[@nofx_ai](https://x.com/nofx_ai)

107
docs/i18n/zh-CN/README.md
View File

@@ -6,7 +6,7 @@
[![License](https://img.shields.io/badge/License-AGPL--3.0-blue.svg)](LICENSE)
[![Backed by Amber.ac](https://img.shields.io/badge/Backed%20by-Amber.ac-orange.svg)](https://amber.ac)
**语言 / Languages:** [English](../../../README.md) | [中文](../zh-CN/README.md) | [Українська](../uk/README.md) | [Русский](../ru/README.md)
**语言 / Languages:** [English](../../../README.md) | [中文](../zh-CN/README.md) | [Українська](../uk/README.md) | [Русский](../ru/README.md) | [日本語](../ja/README.md)
**官方推特:** [@nofx_ai](https://x.com/nofx_ai)
@@ -24,6 +24,8 @@
- [🔮 路线图](#-路线图---通用市场扩展)
- [🏗️ 技术架构](#️-技术架构)
- [💰 注册币安账户](#-注册币安账户省手续费)
- [🔷 注册Hyperliquid账户](#-使用hyperliquid交易所)
- [🔶 注册Aster DEX账户](#-使用aster-dex交易所)
- [🚀 快速开始](#-快速开始)
- [📖 AI决策流程](#-ai决策流程)
- [🧠 AI自我学习示例](#-ai自我学习示例)
@@ -482,18 +484,82 @@ cp config.json.example config.json
---
#### 🔷 备选：使用Hyperliquid交易所
#### 🔷 使用Hyperliquid交易所
**NOFX也支持Hyperliquid** - 去中心化永续期货交易所。使用Hyperliquid而非Binance：
### 📝 注册与设置指南
**步骤1**：获取以太坊私钥（用于Hyperliquid身份验证）
**步骤1：注册Hyperliquid账户**
1. 打开**MetaMask**（或任何以太坊钱包）
2. 导出你的私钥
3. **去掉`0x`前缀**
4. 在[Hyperliquid](https://hyperliquid.xyz)上为钱包充值
1. **通过邀请链接访问Hyperliquid**（享受优惠！）：
~~**步骤2**：为Hyperliquid配置`config.json`~~ *通过Web界面配置*
**🎁 [注册Hyperliquid - 加入AITRADING](https://app.hyperliquid.xyz/join/AITRADING)**
2. **连接你的钱包**：
- 点击右上角"Connect Wallet"
- 选择MetaMask、WalletConnect或其他Web3钱包
- 批准连接
3. **启用交易**：
- 首次连接会提示你签名消息
- 这会授权你的钱包进行交易（无gas费）
- 你将看到钱包地址显示出来
**步骤2：为钱包充值**
1. **将资产桥接到Arbitrum**：
- Hyperliquid运行在Arbitrum L2上
- 从以太坊主网或其他链桥接USDC
- 或者直接从交易所提现USDC到Arbitrum
2. **充值到Hyperliquid**：
- 在Hyperliquid界面点击"Deposit"
- 选择要充值的USDC数量
- 确认交易（Arbitrum上的小额gas费）
- 资金会在几秒内到达你的Hyperliquid账户
**步骤3：设置代理钱包（推荐）**
Hyperliquid支持**代理钱包**功能 - 专门用于交易自动化的安全子钱包！
⚠️ **为什么使用代理钱包：**
- ✅ **更安全**：永远不暴露主钱包私钥
- ✅ **权限受限**：代理钱包只有交易权限
- ✅ **可随时撤销**：可从Hyperliquid界面随时禁用
- ✅ **资金隔离**：保持主要资产安全
**如何创建代理钱包：**
1. **登录Hyperliquid**，使用你的主钱包
- 访问 [https://app.hyperliquid.xyz](https://app.hyperliquid.xyz)
- 连接你注册时使用的钱包（来自邀请链接）
2. **进入代理设置**：
- 点击钱包地址（右上角）
- 进入"Settings" → "API & Agents"
- 或直接访问：[https://app.hyperliquid.xyz/agents](https://app.hyperliquid.xyz/agents)
3. **创建新代理**：
- 点击"Create Agent"或"Add Agent"
- 系统会自动生成新的代理钱包
- **保存代理钱包地址**（以`0x`开头）
- **保存代理私钥**（仅显示一次！）
4. **代理钱包详情**：
- 主钱包：你连接的钱包（持有资金）
- 代理钱包：用于交易的子钱包（NOFX将使用此钱包）
- 私钥：仅用于NOFX配置
5. **为代理充值**（可选）：
- 从主钱包转账USDC到代理钱包
- 或保持资金在主钱包（代理可以从主钱包交易）
6. **保存NOFX配置凭据**：
- 主钱包地址：`0xYourMainWalletAddress`（保留`0x`前缀）
- 代理私钥：`YourAgentPrivateKeyWithout0x`（去掉`0x`前缀）
---
~~**配置`config.json`**~~ *通过Web界面配置*
```json
{
@@ -504,8 +570,8 @@ cp config.json.example config.json
"enabled": true,
"ai_model": "deepseek",
"exchange": "hyperliquid",
"hyperliquid_private_key": "your_private_key_without_0x",
"hyperliquid_wallet_addr": "your_ethereum_address",
"hyperliquid_private_key": "your_agent_private_key_without_0x",
"hyperliquid_wallet_addr": "0xYourMainWalletAddress",
"hyperliquid_testnet": false,
"deepseek_key": "sk-xxxxxxxxxxxxx",
"initial_balance": 1000.0,
@@ -517,18 +583,23 @@ cp config.json.example config.json
}
```
**与Binance配置的关键区别：**
- 用`hyperliquid_private_key`替换`binance_api_key` + `binance_secret_key`
- 添加`"exchange": "hyperliquid"`字段
- 设置`hyperliquid_testnet: false`用于主网（或`true`用于测试网）
**关键配置字段：**
- `"exchange": "hyperliquid"` - 设置交易所为Hyperliquid
- `hyperliquid_private_key` - 代理钱包私钥（去掉`0x`前缀）
- `hyperliquid_wallet_addr` - 主钱包地址（保留`0x`前缀）
- `hyperliquid_testnet: false` - 使用主网（设为`true`使用测试网）
**⚠️ 安全警告**：切勿分享你的私钥！使用专门的钱包进行交易，而非主钱包。
**⚠️ 安全提示**：
- 优先使用代理钱包而非主钱包私钥
- 切勿分享你的私钥
- 可以随时从Hyperliquid界面撤销代理权限
- 定期检查代理钱包活动
---
#### 🔶 备选：使用Aster DEX交易所
#### 🔶 使用Aster DEX交易所
**NOFX也支持Aster DEX** - 兼容Binance的去中心化永续期货交易所！
**NOFX支持Aster DEX** - 兼容Binance的去中心化永续期货交易所！
**为什么选择Aster？**
- 🎯 兼容Binance API（轻松迁移）

155
docs/i18n/zh-CN/TERMS OF SERVICE.md Normal file
View File

@@ -0,0 +1,155 @@
NOFX 用户协议（服务条款）
最后更新时间：2025.11.07
一、 引言与条款接受
A. 协议
本用户协议（以下简称“协议”或“条款”）是您（以下简称“您”或“用户”）与 NOFX（以下简称“我们”或“NOFX”）之间具有法律约束力的协议。
B. 范围
本协议管辖您对 nofxai.com 网站（以下简称“网站”）的访问和使用，以及对 NOFX AI 交易操作系统（以下简称“软件”）的下载、安装和使用。
C. 接受条款
通过访问“网站”，或下载、安装或以任何方式使用“软件”，即表示您已阅读、理解并同意受本“条款”的约束。 如果您不同意这些“条款”，您必须立即停止访问“网站”和使用“软件”。
D. 年龄要求
您必须年满18岁，或在您的司法管辖区内达到法定成年年龄，才能使用“网站”和“软件”。
二、 软件许可和服务模式
A. 网站
我们授予您有限的、非排他性的、不可转让的、可撤销的许可，允许您出于信息目的访问和使用“网站”。
B. 软件（自托管）
AGPL-3.0 许可：我们明确告知您，NOFX“软件”的源代码是根据 GNU Affero General Public License v3.0 (AGPL-3.0) 许可（以下简称“AGPL-3.0”）向您提供的。
条款的性质：本“协议”不会修改、取代或限制您根据 AGPL-3.0 享有的权利。AGPL-3.0 是您的软件许可。本“协议”是一份服务协议，它管辖您对我们整个服务生态（包括“网站”和“软件”使用）的使用行为，并确立了下文所述的、AGPL-3.0 未涵盖的关键责任和免责声明。
三、 关键风险确认（财务）
本节内容关乎您的重大利益。请仔细阅读。本节中的所有条款均以醒目的大写字体呈现，以确保其法律上的显著性。
A. 无财务或投资建议：
“网站”和“软件”仅作为技术工具提供。我们不是金融机构、经纪人、财务顾问或投资顾问。本服务提供的任何内容、功能或 AI 输出均不构成财务、投资、法律、税务或交易建议。
B. 极端的财务损失风险：
您承认并同意，交易加密货币和其他金融资产具有高度波动性、投机性，并伴随固有风险。使用自动化、算法化和人工智能驱动的交易系统（如本“软件”）涉及重大的、独特的风险，并可能导致重大的乃至全部的财务损失。
C. 不保证盈利或性能：
我们对“软件”的性能、盈利能力或其生成的任何交易信号的准确性不作任何明示或暗示的保证、陈述或担保。任何 AI 模型或交易策略的过往表现绝不代表或保证未来的结果。
D. 用户的全部责任：
您对您的所有交易决策、订单、执行及最终结果负有全部和唯一的责任。通过“软件”执行的所有交易均被视为是基于您的自主决定和风险偏好，并由您自行承担风险。
四、 关键风险确认（人工智能与软件）
本节内容同样关乎您的重大利益，并以大写字体呈现。
A. "按原样"和"按可用"的免责声明：
“网站”和“软件”均“按原样”(AS IS) 和“按可用”(AS AVAILABLE) 形式提供，不附带任何形式的明示或暗示的保证。我们不保证服务将是不间断的、准确的、无错误的、安全的，或没有病毒或其他有害组件。
B. AI 输出和"幻觉"免责声明：
鉴于本“软件”的核心功能依赖于第三方 AI 模型，您必须理解并接受 AI 技术的固有局限性。AI 输出（包括 AI 代理决策）是新生技术，其法律责任尚不明确。
您特此承认并同意：
AI 输出可能存在缺陷： 由“软件”集成或生成的 AI 模型和输出可能包含错误、不准确性、遗漏、偏见，或产生被称为“幻觉”(HALLUCINATIONS) 的完全错误或虚构的信息。
您自行承担全部风险： 您同意，您对 AI 生成输出（包括任何交易决策）的任何使用或依赖，均由您自行承担全部风险。
不能替代专业建议： 您不得将 AI 输出视为唯一的真相来源、事实信息，或将其作为专业财务建议的替代品。
C. 用户的最终责任：
您同意对基于 AI 输出所采取的所有行动承担最终责任。您必须在执行 AI 建议的任何交易之前，自行进行尽职调查并验证信息的准确性。
五、 用户义务和安全责任
A. 对 API 密钥和私钥的全部责任
这是本协议最关键的条款之一，涉及“软件”的核心功能。
您承认并同意，您对保护、保存、安全和备份您用于“软件”的所有 API 密钥、密钥 (SECRET KEYS)、钱包地址、私钥 (PRIVATE KEYS) 以及任何助记词 ("SECRET PHRASE") 负有排他性的、唯一的全部责任。您必须对这些凭证保持充分的安全和控制。
B. 非托管确认
您承认并同意，我们 (NOFX) 是一个非托管软件提供商。我们绝不会收集、存储、接收或以任何方式访问您的 API 密钥、私钥或助记词。我们绝不会要求您分享这些凭证。
因此，我们没有能力访问您的资金、恢复您丢失的密钥、撤销或逆转任何交易。因您的密钥（无论是 API 密钥还是私钥）丢失、被盗或泄露而导致的任何及所有损失，均由您自行承担全部责任。
C. 用户管理的加密
您承认，在您的自托管实例中，您有责任在所有存储和通信中加密您的密钥和凭证。“软件”中提供的任何加密功能均“按原样”提供，不含任何安全保证。
D. 第三方条款
您在使用“软件”连接到任何第三方服务（例如 Binance, Hyperliquid, DeepSeek, Qwen 等）时，您有责任遵守该等第三方服务的所有服务条款、费用政策和使用规则。
六、 可接受使用政策 (AUP)
您同意不将“网站”或“软件”用于任何非法或本条款禁止的目的。禁止活动包括（但不限于）：
非法活动：从事任何违反地方、州、国家或国际法律或法规的活动。
系统滥用：从事任何“黑客攻击”(Hacking)、“垃圾邮件”(Spamming)、“邮件轰炸”或“拒绝服务攻击”(DoS)。
安全：试图探测、扫描或测试“网站”或相关网络的漏洞，或破坏安全或身份验证措施。
数据抓取：出于商业目的，使用任何自动化系统（包括“数据抓取”、“网页抓取”或“机器人”）从“网站”提取数据。
恶意软件：引入任何病毒、木马、蠕虫或其他恶意代码。
七、 知识产权 (IP)
A. 网站内容
我们及我们的许可方保留对“网站”及其所有内容（包括文本、图形、徽标、视觉设计元素）的所有知识产权。
B. 软件知识产权
“软件”是一个开源项目。其知识产权受 AGPL-3.0 许可管辖。
C. 用户内容/反馈
如果您向我们提供任何反馈、策略、建议或贡献（“用户生成内容”），您即授予我们一项永久的、不可撤销的、全球范围内的、免版税的许可，允许我们使用、托管、复制、修改和展示该等内容。
八、 责任限制和赔偿
本节内容限制了我们的法律责任并要求您对因您引起的损害承担责任。请仔细阅读。本节中的所有条款均以醒目的大写字体呈现。
A. 责任限制：
本条款的制定基于对托管服务提供商所面临的法律诉讼的分析，并利用了我们作为非托管、自托管软件提供商的法律地位。
在适用法律允许的最大范围内，NOFX（及其关联方、董事、员工或许可方）在任何情况下均不对您承担任何间接的、惩罚性的、偶然的、特殊的、后果性的或惩戒性的损害赔偿，包括但不限于因以下原因导致的利润、资金、数据损失，或您的 API 密钥或私钥被盗或丢失所造成的损害：
您对“网站”或“软件”的使用或无法使用；
“软件”中的任何缺陷、错误、病毒、不准确性或延迟；
任何 AI 生成的输出、"幻觉"、错误的交易信号或失败的策略；
对您的自托管实例或您存储密钥的任何设备的任何未经授权的访问或使用；
由“软件”自动执行或建议的任何交易所导致的任何及所有财务损失。
如果 NOFX 被裁定对您负有直接责任，则我们的最高累计赔偿责任应限于您在索赔前十二（12）个月内向我们支付的费用（如有）或一百美元（$100.00）中的较高者。
B. 赔偿：
您同意为 NOFX 及其关联方进行辩护、赔偿并使其免受任何索赔、要求、诉讼、损失、损害、责任、成本和费用（包括合理的律师费）的损害，这些损害源于或以任何方式关联于：(A) 您对“软件”的访问或使用；(B) 您违反本“条款”；(C) 您违反任何第三方权利，包括但不限于您所连接的任何交易所或 AI 提供商的服务条款；或 (D) 因您使用 AI 输出而引起的任何第三方知识产权侵权索赔。
九、 终止
A. 由我方终止
我们保留自行决定，在您违反本“条款”或“可接受使用政策”的情况下，立即或在通知后暂停或终止您访问“网站”（以及我们未来可能提供的任何托管服务）的权利。
B. 终止的效力
终止后，您根据 AGPL-3.0 对“软件”的许可（如果您已下载）仍然有效，但您使用我们“网站”的权利将被撤销。所有与免责声明、责任限制、赔偿、知识产权和管辖法律相关的条款将在终止后继续有效。
十、 条款修改
我们保留自行决定随时修改或替换本“条款”的权利。与行业中某些可能被视为不可执行的“单方面修改”条款不同，我们将采取以下做法：我们将在“网站”上发布更新后的“条款”并更新“最后更新时间”日期，以此向您提供重大变更的通知。您在该等变更生效后继续访问“网站”或使用“软件”，即构成您对新“条款”的接受。
十一、 一般条款
A. 管辖法律
本“协议”应受 [指定司法管辖区] 法律管辖并据其解释，不考虑其法律冲突原则。
B. 争议解决
除适用法律禁止外，您同意，因本“协议”引起或与本“协议”相关的所有争议，均应通过在 [指定地点] 进行的有约束力的仲裁来最终解决。
C. 可分割性与弃权
如果本“协议”的任何条款被认定为非法或不可执行，其余条款将继续完全有效。一方未能执行本“协议”的任何权利或条款，不应被视为对该权利或条款的放弃。
D. 完整协议
本“协议”（连同 AGPL-3.0 软件许可）构成您与 NOFX 之间关于标的物的完整协议。

1529
docs/prompt-guide.md Normal file
View File

File diff suppressed because it is too large Load Diff

1530
docs/prompt-guide.zh-CN.md Normal file
View File

File diff suppressed because it is too large Load Diff

18
go.mod
View File

@@ -4,17 +4,21 @@ go 1.25.0
require (
github.com/adshao/go-binance/v2 v2.8.7
github.com/agiledragon/gomonkey/v2 v2.13.0
github.com/ethereum/go-ethereum v1.16.5
github.com/gin-gonic/gin v1.11.0
github.com/go-telegram-bot-api/telegram-bot-api/v5 v5.5.1
github.com/golang-jwt/jwt/v5 v5.2.0
github.com/google/uuid v1.6.0
github.com/gorilla/websocket v1.5.3
github.com/lib/pq v1.10.9
github.com/joho/godotenv v1.5.1
github.com/pquerna/otp v1.4.0
github.com/rs/zerolog v1.34.0
github.com/sirupsen/logrus v1.9.3
github.com/sonirico/go-hyperliquid v0.17.0
github.com/stretchr/testify v1.11.1
golang.org/x/crypto v0.42.0
modernc.org/sqlite v1.40.0
)
require (
@@ -28,7 +32,9 @@ require (
github.com/consensys/gnark-crypto v0.19.0 // indirect
github.com/crate-crypto/go-eth-kzg v1.4.0 // indirect
github.com/crate-crypto/go-ipa v0.0.0-20240724233137-53bbb0ceb27a // indirect
github.com/davecgh/go-spew v1.1.1 // indirect
github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 // indirect
github.com/dustin/go-humanize v1.0.1 // indirect
github.com/elastic/go-sysinfo v1.15.4 // indirect
github.com/elastic/go-windows v1.0.2 // indirect
github.com/ethereum/c-kzg-4844/v2 v2.1.5 // indirect
@@ -41,7 +47,6 @@ require (
github.com/goccy/go-json v0.10.4 // indirect
github.com/goccy/go-yaml v1.18.0 // indirect
github.com/holiman/uint256 v1.3.2 // indirect
github.com/joho/godotenv v1.5.1 // indirect
github.com/josharian/intern v1.0.0 // indirect
github.com/jpillora/backoff v1.0.0 // indirect
github.com/json-iterator/go v1.1.12 // indirect
@@ -52,12 +57,14 @@ require (
github.com/mattn/go-isatty v0.0.20 // indirect
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 // indirect
github.com/modern-go/reflect2 v1.0.2 // indirect
github.com/ncruces/go-strftime v0.1.9 // indirect
github.com/pelletier/go-toml/v2 v2.2.4 // indirect
github.com/pkg/errors v0.9.1 // indirect
github.com/pmezard/go-difflib v1.0.0 // indirect
github.com/prometheus/procfs v0.17.0 // indirect
github.com/quic-go/qpack v0.5.1 // indirect
github.com/quic-go/quic-go v0.54.0 // indirect
github.com/rs/zerolog v1.34.0 // indirect
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect
github.com/shopspring/decimal v1.4.0 // indirect
github.com/sonirico/vago v0.9.0 // indirect
github.com/sonirico/vago/lol v0.0.0-20250901170347-2d1d82c510bd // indirect
@@ -72,6 +79,7 @@ require (
go.elastic.co/fastjson v1.5.1 // indirect
go.uber.org/mock v0.5.0 // indirect
golang.org/x/arch v0.20.0 // indirect
golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b // indirect
golang.org/x/mod v0.27.0 // indirect
golang.org/x/net v0.43.0 // indirect
golang.org/x/sync v0.17.0 // indirect
@@ -79,5 +87,9 @@ require (
golang.org/x/text v0.29.0 // indirect
golang.org/x/tools v0.36.0 // indirect
google.golang.org/protobuf v1.36.9 // indirect
gopkg.in/yaml.v3 v3.0.1 // indirect
howett.net/plist v1.0.1 // indirect
modernc.org/libc v1.66.10 // indirect
modernc.org/mathutil v1.7.1 // indirect
modernc.org/memory v1.11.0 // indirect
)

13
go.sum
View File

@@ -2,6 +2,8 @@ github.com/StackExchange/wmi v1.2.1 h1:VIkavFPXSjcnS+O8yTq7NI32k0R5Aj+v39y29VYDO
github.com/StackExchange/wmi v1.2.1/go.mod h1:rcmrprowKIVzvc+NUiLncP2uuArMWLCbu9SBzvHz7e8=
github.com/adshao/go-binance/v2 v2.8.7 h1:n7jkhwIHMdtd/9ZU2gTqFV15XVSbUCjyFlOUAtTd8uU=
github.com/adshao/go-binance/v2 v2.8.7/go.mod h1:XkkuecSyJKPolaCGf/q4ovJYB3t0P+7RUYTbGr+LMGM=
github.com/agiledragon/gomonkey/v2 v2.13.0 h1:B24Jg6wBI1iB8EFR1c+/aoTg7QN/Cum7YffG8KMIyYo=
github.com/agiledragon/gomonkey/v2 v2.13.0/go.mod h1:ap1AmDzcVOAz1YpeJ3TCzIgstoaWLA6jbbgxfB4w2iY=
github.com/armon/go-radix v1.0.0 h1:F4z6KzEeeQIMeLFa97iZU6vupzoecKdU5TX24SNppXI=
github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgIH9cCH8=
github.com/bitly/go-simplejson v0.5.0 h1:6IH+V8/tVMab511d5bn4M7EwGXZf9Hj6i2xSwkNEM+Y=
@@ -84,6 +86,7 @@ github.com/google/gofuzz v1.2.0 h1:xRy4A+RhZaiKjJ1bPfwQ8sedCA+YS2YcCHW6ec7JMi0=
github.com/google/gofuzz v1.2.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
github.com/google/uuid v1.6.0 h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0=
github.com/google/uuid v1.6.0/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
github.com/gopherjs/gopherjs v0.0.0-20181017120253-0766667cb4d1/go.mod h1:wJfORRmW1u3UXTncJ5qlYoELFm8eSnnEO6hX4iZ3EWY=
github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
github.com/holiman/uint256 v1.3.2 h1:a9EgMPSC1AAaj1SZL5zIQD3WbwTuHrMGOerLjGmM/TA=
@@ -97,6 +100,7 @@ github.com/jpillora/backoff v1.0.0 h1:uvFg412JmmHBHw7iwprIxkPMI+sGQ4kzOWsMeHnm2E
github.com/jpillora/backoff v1.0.0/go.mod h1:J/6gKK9jxlEcS3zixgDgUAsiuZ7yrSoa/FX5e0EB2j4=
github.com/json-iterator/go v1.1.12 h1:PV8peI4a0ysnczrg+LtxykD8LfKY9ML6u2jnxaEnrnM=
github.com/json-iterator/go v1.1.12/go.mod h1:e30LSqwooZae/UwlEbR2852Gd8hjQvJoHmT4TnhNGBo=
github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
github.com/klauspost/cpuid/v2 v2.3.0 h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=
github.com/klauspost/cpuid/v2 v2.3.0/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=
github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE=
@@ -159,6 +163,8 @@ github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp
github.com/shopspring/decimal v1.4.0/go.mod h1:gawqmDU56v4yIKSwfBSFip1HdCCXN8/+DMd9qYNcwME=
github.com/sirupsen/logrus v1.9.3 h1:dueUQJ1C2q9oE3F7wvmSGAaVtTmUizReu6fjN8uqzbQ=
github.com/sirupsen/logrus v1.9.3/go.mod h1:naHLuLoDiP4jHNo9R0sCBMtWGeIprob74mVsIT4qYEQ=
github.com/smartystreets/assertions v0.0.0-20180927180507-b2de0cb4f26d/go.mod h1:OnSkiWE9lh6wB0YB77sQom3nweQdgAjqCqsofrRNTgc=
github.com/smartystreets/goconvey v1.6.4/go.mod h1:syvi0/a8iFYH4r/RixwvyeAJjdLS9QV7WQ/tjFTllLA=
github.com/sonirico/go-hyperliquid v0.17.0 h1:eXYACWupwu41O1VtKw17dqe9oOLQ1A2nRElGhg5Ox+4=
github.com/sonirico/go-hyperliquid v0.17.0/go.mod h1:sH51Vsu+tPUwc95TL2MoQ8YXSewLWBEJirgzo7sZx6w=
github.com/sonirico/vago v0.9.0 h1:DF2OWW2Aaf1xPZmnFv79kBrHmjKX3mVvMbP08vERlKo=
@@ -203,27 +209,34 @@ go.uber.org/mock v0.5.0 h1:KAMbZvZPyBPWgD14IrIQ38QCyjwpvVVV6K/bHl1IwQU=
go.uber.org/mock v0.5.0/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM=
golang.org/x/arch v0.20.0 h1:dx1zTU0MAE98U+TQ8BLl7XsJbgze2WnNKF/8tGp/Q6c=
golang.org/x/arch v0.20.0/go.mod h1:bdwinDaKcfZUGpH09BB7ZmOfhalA8lQdzl62l8gGWsk=
golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
golang.org/x/crypto v0.42.0 h1:chiH31gIWm57EkTXpwnqf8qeuMUi0yekh6mT2AvFlqI=
golang.org/x/crypto v0.42.0/go.mod h1:4+rDnOTJhQCx2q7/j6rAN5XDw8kPjeaXEUR2eL94ix8=
golang.org/x/mod v0.27.0 h1:kb+q2PyFnEADO2IEF935ehFUXlWiNjJWtRNgBLSfbxQ=
golang.org/x/mod v0.27.0/go.mod h1:rWI627Fq0DEoudcK+MBkNkCe0EetEaDSwJJkCcjpazc=
golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
golang.org/x/net v0.43.0 h1:lat02VYK2j4aLzMzecihNvTlJNQUq316m2Mr9rnM6YE=
golang.org/x/net v0.43.0/go.mod h1:vhO1fvI4dGsIjh73sWfUVjj3N7CA9WkKJNQm2svM6Jg=
golang.org/x/sync v0.17.0 h1:l60nONMj9l5drqw6jlhIELNv9I0A4OFgRsG9k2oT9Ug=
golang.org/x/sync v0.17.0/go.mod h1:9KTHXmSnoGruLpwFjVSX0lNNA75CykiMECbovNTZqGI=
golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
golang.org/x/sys v0.36.0 h1:KVRy2GtZBrk1cBYA7MKu5bEZFxQk4NIDV6RLVcC8o0k=
golang.org/x/sys v0.36.0/go.mod h1:OgkHotnGiDImocRcuBABYBEXf8A9a87e/uXjp9XT3ks=
golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
golang.org/x/text v0.29.0 h1:1neNs90w9YzJ9BocxfsQNHKuAT4pkghyXc4nhZ6sJvk=
golang.org/x/text v0.29.0/go.mod h1:7MhJOA9CD2qZyOKYazxdYMF85OwPdEr9jTtBpO7ydH4=
golang.org/x/tools v0.0.0-20190328211700-ab21143f2384/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
golang.org/x/tools v0.36.0 h1:kWS0uv/zsvHEle1LbV5LE8QujrxB3wfQyxHfhOk0Qkg=
golang.org/x/tools v0.36.0/go.mod h1:WBDiHKJK8YgLHlcQPYQzNCkUxUypCaa5ZegCVutKm+s=
google.golang.org/protobuf v1.36.9 h1:w2gp2mA27hUeUzj9Ex9FBjsBm40zfaDtEWow293U7Iw=
google.golang.org/protobuf v1.36.9/go.mod h1:fuxRtAxBytpl4zzqUh6/eyUujkJdNiuEkXntxiD/uRU=
gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk=
gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q=
gopkg.in/dnaeon/go-vcr.v4 v4.0.5 h1:I0hpTIvD5rII+8LgYGrHMA2d4SQPoL6u7ZvJakWKsiA=
gopkg.in/dnaeon/go-vcr.v4 v4.0.5/go.mod h1:dRos81TkW9C1WJt6tTaE+uV2Lo8qJT3AG2b35+CB/nQ=
gopkg.in/yaml.v1 v1.0.0-20140924161607-9f9df34309c0/go.mod h1:WDnlLJ4WF5VGsH/HVa3CI79GS0ol3YnhVnKP89i0kNg=

270
hook/README.md Normal file
View File

@@ -0,0 +1,270 @@
# Hook 模块使用文档
## 简介
Hook模块提供了一个通用的扩展点机制，允许在不修改核心代码的前提下注入自定义逻辑。
**核心特点**：
- 类型安全的泛型API
- Hook未注册时自动fallback
- 支持任意参数和返回值
## 快速开始
### 基本用法
```go
// 1. 注册Hook
hook.RegisterHook(hook.GETIP, func(args ...any) any {
userId := args[0].(string)
return &hook.IpResult{IP: "192.168.1.1"}
})
// 2. 调用Hook
result := hook.HookExec[hook.IpResult](hook.GETIP, "user123")
if result != nil && result.Error() == nil {
ip := result.GetResult()
}
```
### 核心API
```go
// 注册Hook函数
func RegisterHook(key string, hook HookFunc)
// 执行Hook（泛型）
func HookExec[T any](key string, args ...any) *T
```
## 可用的Hook扩展点
### 1. `GETIP` - 获取用户IP
**调用位置**：`api/server.go:210`
**参数**：`userId string`
**返回**：`*IpResult`
```go
type IpResult struct {
Err error
IP string
}
```
**用途**：返回用户专用IP（如代理IP）
---
### 2. `NEW_BINANCE_TRADER` - Binance客户端创建
**调用位置**：`trader/binance_futures.go:68`
**参数**：`userId string, client *futures.Client`
**返回**：`*NewBinanceTraderResult`
```go
type NewBinanceTraderResult struct {
Err error
Client *futures.Client // 可修改client配置
}
```
**用途**：为Binance客户端注入代理、日志等
---
### 3. `NEW_ASTER_TRADER` - Aster客户端创建
**调用位置**：`trader/aster_trader.go:68`
**参数**：`user string, client *http.Client`
**返回**：`*NewAsterTraderResult`
```go
type NewAsterTraderResult struct {
Err error
Client *http.Client // 可修改HTTP client
}
```
**用途**：为Aster客户端注入代理等
## 使用示例
### 示例1：代理模块注册Hook
```go
// proxy/init.go
package proxy
import "nofx/hook"
func InitHooks(enabled bool) {
if !enabled {
return // 条件不满足，不注册
}
// 注册IP获取Hook
hook.RegisterHook(hook.GETIP, func(args ...any) any {
userId := args[0].(string)
proxyIP, err := getProxyIP(userId)
return &hook.IpResult{Err: err, IP: proxyIP}
})
// 注册Binance客户端Hook
hook.RegisterHook(hook.NEW_BINANCE_TRADER, func(args ...any) any {
userId := args[0].(string)
client := args[1].(*futures.Client)
// 修改client配置
if client.HTTPClient != nil {
client.HTTPClient.Transport = getProxyTransport()
}
return &hook.NewBinanceTraderResult{Client: client}
})
}
```
## 最佳实践
### ✅ 推荐做法
```go
// 1. 在注册时判断条件
func InitHooks(enabled bool) {
if !enabled {
return // 不注册
}
hook.RegisterHook(KEY, hookFunc)
}
// 2. 总是返回正确的Result类型
hook.RegisterHook(hook.GETIP, func(args ...any) any {
ip, err := getIP()
return &hook.IpResult{Err: err, IP: ip} // ✅
})
// 3. 安全的类型断言
userId, ok := args[0].(string)
if !ok {
return &hook.IpResult{Err: fmt.Errorf("参数类型错误")}
}
```
### ❌ 避免的做法
```go
// 1. 不要在Hook内部判断条件（浪费性能）
hook.RegisterHook(KEY, func(args ...any) any {
if !enabled {
return nil // ❌
}
// ...
})
// 2. 不要直接panic
hook.RegisterHook(KEY, func(args ...any) any {
if err != nil {
panic(err) // ❌ 会导致程序崩溃
}
})
// 3. 不要跳过类型检查
userId := args[0].(string) // ❌ 可能panic
```
## 添加新Hook扩展点
### 步骤1：定义Result类型
```go
// hook/my_hook.go
package hook
type MyHookResult struct {
Err error
Data string
}
func (r *MyHookResult) Error() error {
if r.Err != nil {
log.Printf("⚠️ Hook出错: %v", r.Err)
}
return r.Err
}
func (r *MyHookResult) GetResult() string {
r.Error()
return r.Data
}
```
### 步骤2：定义Hook常量
```go
// hook/hooks.go
const (
GETIP = "GETIP"
NEW_BINANCE_TRADER = "NEW_BINANCE_TRADER"
NEW_ASTER_TRADER = "NEW_ASTER_TRADER"
MY_HOOK = "MY_HOOK" // 新增
)
```
### 步骤3：在业务代码调用
```go
result := hook.HookExec[hook.MyHookResult](hook.MY_HOOK, arg1, arg2)
if result != nil && result.Error() == nil {
data := result.GetResult()
// 使用data
}
```
### 步骤4：注册实现
```go
hook.RegisterHook(hook.MY_HOOK, func(args ...any) any {
// 处理逻辑
return &hook.MyHookResult{Data: "result"}
})
```
## 常见问题
**Q: Hook可以注册多个吗？**
A: 不可以，每个Key只能注册一个Hook，后注册会覆盖前面的。如需多个逻辑，请在一个Hook函数内组合。
**Q: Hook执行失败会影响主流程吗？**
A: 不会，主流程会检查返回值，失败时会fallback到默认逻辑。
**Q: 如何调试Hook？**
A: Hook执行时会自动打印日志：
- `🔌 Execute hook: {KEY}` - Hook存在并执行
- `🔌 Do not find hook: {KEY}` - Hook未注册
**Q: 如何测试Hook？**
```go
func TestHook(t *testing.T) {
// 清空全局Hook
hook.Hooks = make(map[string]hook.HookFunc)
// 注册测试Hook
hook.RegisterHook(hook.GETIP, func(args ...any) any {
return &hook.IpResult{IP: "127.0.0.1"}
})
// 验证
result := hook.HookExec[hook.IpResult](hook.GETIP, "test")
assert.Equal(t, "127.0.0.1", result.IP)
}
```
## 参考
- 核心实现：`hook/hooks.go`
- Result类型：`hook/trader_hook.go`, `hook/ip_hook.go`
- 调用示例：`api/server.go`, `trader/binance_futures.go`, `trader/aster_trader.go`

41
hook/hooks.go Normal file
View File

@@ -0,0 +1,41 @@
package hook
import (
"log"
)
type HookFunc func(args ...any) any
var (
Hooks map[string]HookFunc = map[string]HookFunc{}
EnableHooks = true
)
func HookExec[T any](key string, args ...any) *T {
if !EnableHooks {
log.Printf("🔌 Hooks are disabled, skip hook: %s", key)
var zero *T
return zero
}
if hook, exists := Hooks[key]; exists && hook != nil {
log.Printf("🔌 Execute hook: %s", key)
res := hook(args...)
return res.(*T)
} else {
log.Printf("🔌 Do not find hook: %s", key)
}
var zero *T
return zero
}
func RegisterHook(key string, hook HookFunc) {
Hooks[key] = hook
}
// hook list
const (
GETIP = "GETIP" // func (userID string) *IpResult
NEW_BINANCE_TRADER = "NEW_BINANCE_TRADER" // func (userID string, client *futures.Client) *NewBinanceTraderResult
NEW_ASTER_TRADER = "NEW_ASTER_TRADER" // func (userID string, client *http.Client) *NewAsterTraderResult
SET_HTTP_CLIENT = "SET_HTTP_CLIENT" // func (client *http.Client) *SetHttpClientResult
)

23
hook/http_client_hook.go Normal file
View File

@@ -0,0 +1,23 @@
package hook
import (
"log"
"net/http"
)
type SetHttpClientResult struct {
Err error
Client *http.Client
}
func (r *SetHttpClientResult) Error() error {
if r.Err != nil {
log.Printf("⚠️ 执行NewAsterTraderResult时出错: %v", r.Err)
}
return r.Err
}
func (r *SetHttpClientResult) GetResult() *http.Client {
r.Error()
return r.Client
}

19
hook/ip_hook.go Normal file
View File

@@ -0,0 +1,19 @@
package hook
import "github.com/rs/zerolog/log"
type IpResult struct {
Err error
IP string
}
func (r *IpResult) Error() error {
return r.Err
}
func (r *IpResult) GetResult() string {
if r.Err != nil {
log.Printf("⚠️ 执行GetIP时出错: %v", r.Err)
}
return r.IP
}

42
hook/trader_hook.go Normal file
View File

@@ -0,0 +1,42 @@
package hook
import (
"log"
"net/http"
"github.com/adshao/go-binance/v2/futures"
)
type NewBinanceTraderResult struct {
Err error
Client *futures.Client
}
func (r *NewBinanceTraderResult) Error() error {
if r.Err != nil {
log.Printf("⚠️ 执行NewBinanceTraderResult时出错: %v", r.Err)
}
return r.Err
}
func (r *NewBinanceTraderResult) GetResult() *futures.Client {
r.Error()
return r.Client
}
type NewAsterTraderResult struct {
Err error
Client *http.Client
}
func (r *NewAsterTraderResult) Error() error {
if r.Err != nil {
log.Printf("⚠️ 执行NewAsterTraderResult时出错: %v", r.Err)
}
return r.Err
}
func (r *NewAsterTraderResult) GetResult() *http.Client {
r.Error()
return r.Client
}

15
logger/decision_logger.go
View File

@@ -25,6 +25,8 @@ type DecisionRecord struct {
ExecutionLog []string `json:"execution_log"` // 执行日志
Success bool `json:"success"` // 是否成功
ErrorMessage string `json:"error_message"` // 错误信息（如果有）
// AIRequestDurationMs 记录 AI API 调用耗时（毫秒），方便评估调用性能
AIRequestDurationMs int64 `json:"ai_request_duration_ms,omitempty"`
}
// AccountSnapshot 账户状态快照
@@ -73,11 +75,16 @@ func NewDecisionLogger(logDir string) *DecisionLogger {
logDir = "decision_logs"
}
// 确保日志目录存在
if err := os.MkdirAll(logDir, 0755); err != nil {
// 确保日志目录存在（使用安全权限：只有所有者可访问）
if err := os.MkdirAll(logDir, 0700); err != nil {
fmt.Printf("⚠ 创建日志目录失败: %v\n", err)
}
// 强制设置目录权限（即使目录已存在）- 确保安全
if err := os.Chmod(logDir, 0700); err != nil {
fmt.Printf("⚠ 设置日志目录权限失败: %v\n", err)
}
return &DecisionLogger{
logDir: logDir,
cycleNumber: 0,
@@ -103,8 +110,8 @@ func (l *DecisionLogger) LogDecision(record *DecisionRecord) error {
return fmt.Errorf("序列化决策记录失败: %w", err)
}
// 写入文件
if err := ioutil.WriteFile(filepath, data, 0644); err != nil {
// 写入文件（使用安全权限：只有所有者可读写）
if err := ioutil.WriteFile(filepath, data, 0600); err != nil {
return fmt.Errorf("写入决策记录失败: %w", err)
}

6
logger/telegram_sender.go
View File

@@ -33,9 +33,9 @@ func NewTelegramSender(botToken string, chatID int64) (*TelegramSender, error) {
sender := &TelegramSender{
bot: bot,
chatID: chatID,
msgChan: make(chan string, 20), // 固定缓冲区大小: 20
retryCount: 3, // 固定重试次数: 3
retryInterval: 3 * time.Second, // 固定重试间隔: 3秒
msgChan: make(chan string, 20), // 固定缓冲区大小: 20
retryCount: 3, // 固定重试次数: 3
retryInterval: 3 * time.Second, // 固定重试间隔: 3秒
stopChan: make(chan struct{}),
}

127
main.go
View File

@@ -16,29 +16,26 @@ import (
"strconv"
"strings"
"syscall"
"github.com/joho/godotenv"
)
// LeverageConfig 杠杆配置
type LeverageConfig struct {
BTCETHLeverage int `json:"btc_eth_leverage"`
AltcoinLeverage int `json:"altcoin_leverage"`
}
// ConfigFile 配置文件结构，只包含需要同步到数据库的字段
// TODO 现在与config.Config相同，未来会被替换， 现在为了兼容性不得不保留当前文件
type ConfigFile struct {
BetaMode bool `json:"beta_mode"`
APIServerPort int `json:"api_server_port"`
UseDefaultCoins bool `json:"use_default_coins"`
DefaultCoins []string `json:"default_coins"`
CoinPoolAPIURL string `json:"coin_pool_api_url"`
OITopAPIURL string `json:"oi_top_api_url"`
MaxDailyLoss float64 `json:"max_daily_loss"`
MaxDrawdown float64 `json:"max_drawdown"`
StopTradingMinutes int `json:"stop_trading_minutes"`
Leverage LeverageConfig `json:"leverage"`
JWTSecret string `json:"jwt_secret"`
DataKLineTime string `json:"data_k_line_time"`
Log *config.LogConfig `json:"log"` // 日志配置
BetaMode bool `json:"beta_mode"`
APIServerPort int `json:"api_server_port"`
UseDefaultCoins bool `json:"use_default_coins"`
DefaultCoins []string `json:"default_coins"`
CoinPoolAPIURL string `json:"coin_pool_api_url"`
OITopAPIURL string `json:"oi_top_api_url"`
MaxDailyLoss float64 `json:"max_daily_loss"`
MaxDrawdown float64 `json:"max_drawdown"`
StopTradingMinutes int `json:"stop_trading_minutes"`
Leverage config.LeverageConfig `json:"leverage"`
JWTSecret string `json:"jwt_secret"`
DataKLineTime string `json:"data_k_line_time"`
Log *config.LogConfig `json:"log"` // 日志配置
}
// loadConfigFile 读取并解析config.json文件
@@ -65,7 +62,7 @@ func loadConfigFile() (*ConfigFile, error) {
}
// syncConfigToDatabase 将配置同步到数据库
func syncConfigToDatabase(database config.DatabaseInterface, configFile *ConfigFile) error {
func syncConfigToDatabase(database *config.Database, configFile *ConfigFile) error {
if configFile == nil {
return nil
}
@@ -119,7 +116,7 @@ func syncConfigToDatabase(database config.DatabaseInterface, configFile *ConfigF
}
// loadBetaCodesToDatabase 加载内测码文件到数据库
func loadBetaCodesToDatabase(database config.DatabaseInterface) error {
func loadBetaCodesToDatabase(database *config.Database) error {
betaCodeFile := "beta_codes.txt"
// 检查内测码文件是否存在
@@ -159,25 +156,37 @@ func main() {
fmt.Println("╚════════════════════════════════════════════════════════════╝")
fmt.Println()
// Load environment variables from .env file if present (for local/dev runs)
// In Docker Compose, variables are injected by the runtime and this is harmless.
_ = godotenv.Load()
// 初始化数据库配置
dbPath := "config.db"
if len(os.Args) > 1 {
dbPath = os.Args[1]
}
// 读取配置文件
configFile, err := loadConfigFile()
if err != nil {
log.Fatalf("❌ 读取config.json失败: %v", err)
}
log.Printf("📋 初始化配置数据库 (PostgreSQL)")
database, err := config.NewDatabase()
log.Printf("📋 初始化配置数据库: %s", dbPath)
database, err := config.NewDatabase(dbPath)
if err != nil {
log.Fatalf("❌ 初始化数据库失败: %v", err)
}
defer database.Close()
// 初始化加密服务（用于敏感数据加密存储与传输）
cryptoService, err := crypto.NewCryptoService("keys/rsa_private.key")
// 初始化加密服务
log.Printf("🔐 初始化加密服务...")
cryptoService, err := crypto.NewCryptoService("secrets/rsa_key")
if err != nil {
log.Fatalf("❌ 初始化加密服务失败: %v", err)
}
database.SetCryptoService(cryptoService)
log.Printf("✅ 加密服务初始化成功")
// 同步config.json到数据库
if err := syncConfigToDatabase(database, configFile); err != nil {
@@ -194,14 +203,24 @@ func main() {
useDefaultCoins := useDefaultCoinsStr == "true"
apiPortStr, _ := database.GetSystemConfig("api_server_port")
// 设置JWT密钥
jwtSecret, _ := database.GetSystemConfig("jwt_secret")
// 设置JWT密钥（优先使用环境变量）
jwtSecret := strings.TrimSpace(os.Getenv("JWT_SECRET"))
if jwtSecret == "" {
jwtSecret = "your-jwt-secret-key-change-in-production-make-it-long-and-random"
log.Printf("⚠️ 使用默认JWT密钥，建议在生产环境中配置")
// 回退到数据库配置
jwtSecret, _ = database.GetSystemConfig("jwt_secret")
if jwtSecret == "" {
jwtSecret = "your-jwt-secret-key-change-in-production-make-it-long-and-random"
log.Printf("⚠️ 使用默认JWT密钥，建议使用加密设置脚本生成安全密钥")
} else {
log.Printf("🔑 使用数据库中JWT密钥")
}
} else {
log.Printf("🔑 使用环境变量JWT密钥")
}
auth.SetJWTSecret(jwtSecret)
// 管理员模式下需要管理员密码，缺失则退出
log.Printf("✓ 配置数据库初始化成功")
fmt.Println()
@@ -275,6 +294,15 @@ func main() {
}
}
// 创建初始化上下文
// TODO : 传入实际配置, 现在并未实际使用，未来所有模块初始化都将通过上下文传递配置
// ctx := bootstrap.NewContext(&config.Config{})
// // 执行所有初始化钩子
// if err := bootstrap.Run(ctx); err != nil {
// log.Fatalf("初始化失败: %v", err)
// }
fmt.Println()
fmt.Println("🤖 AI全权决策模式:")
fmt.Printf(" • AI将自主决定每笔交易的杠杆倍数（山寨币最高5倍，BTC/ETH最高5倍）\n")
@@ -288,12 +316,25 @@ func main() {
fmt.Println(strings.Repeat("=", 60))
fmt.Println()
// 获取API服务器端口
// 获取API服务器端口（优先级：环境变量 > 数据库配置 > 默认值）
apiPort := 8080 // 默认端口
if apiPortStr != "" {
if port, err := strconv.Atoi(apiPortStr); err == nil {
// 1. 优先从环境变量 NOFX_BACKEND_PORT 读取
if envPort := strings.TrimSpace(os.Getenv("NOFX_BACKEND_PORT")); envPort != "" {
if port, err := strconv.Atoi(envPort); err == nil && port > 0 {
apiPort = port
log.Printf("🔌 使用环境变量端口: %d (NOFX_BACKEND_PORT)", apiPort)
} else {
log.Printf("⚠️ 环境变量 NOFX_BACKEND_PORT 无效: %s", envPort)
}
} else if apiPortStr != "" {
// 2. 从数据库配置读取（config.json 同步过来的）
if port, err := strconv.Atoi(apiPortStr); err == nil && port > 0 {
apiPort = port
log.Printf("🔌 使用数据库配置端口: %d (api_server_port)", apiPort)
}
} else {
log.Printf("🔌 使用默认端口: %d", apiPort)
}
// 创建并启动API服务器
@@ -318,8 +359,28 @@ func main() {
<-sigChan
fmt.Println()
fmt.Println()
log.Println("📛 收到退出信号，正在停止所有trader...")
log.Println("📛 收到退出信号，正在优雅关闭...")
// 步骤 1: 停止所有交易员
log.Println("⏸️ 停止所有交易员...")
traderManager.StopAll()
log.Println("✅ 所有交易员已停止")
// 步骤 2: 关闭 API 服务器
log.Println("🛑 停止 API 服务器...")
if err := apiServer.Shutdown(); err != nil {
log.Printf("⚠️ 关闭 API 服务器时出错: %v", err)
} else {
log.Println("✅ API 服务器已安全关闭")
}
// 步骤 3: 关闭数据库连接 (确保所有写入完成)
log.Println("💾 关闭数据库连接...")
if err := database.Close(); err != nil {
log.Printf("❌ 关闭数据库失败: %v", err)
} else {
log.Println("✅ 数据库已安全关闭，所有数据已持久化")
}
fmt.Println()
fmt.Println("👋 感谢使用AI交易系统！")

181
manager/trader_manager.go
View File

@@ -762,7 +762,21 @@ func (tm *TraderManager) LoadUserTraders(database config.DatabaseInterface, user
}
}
// 为每个交易员获取AI模型和交易所配置
// 🔧 性能优化：在循环外只查询一次AI模型和交易所配置
// 避免在循环中重复查询相同的数据，减少数据库压力和锁持有时间
aiModels, err := database.GetAIModels(userID)
if err != nil {
log.Printf("⚠️ 获取用户 %s 的AI模型配置失败: %v", userID, err)
return fmt.Errorf("获取AI模型配置失败: %w", err)
}
exchanges, err := database.GetExchanges(userID)
if err != nil {
log.Printf("⚠️ 获取用户 %s 的交易所配置失败: %v", userID, err)
return fmt.Errorf("获取交易所配置失败: %w", err)
}
// 为每个交易员加载配置
for _, traderCfg := range traders {
// 检查是否已经加载过这个交易员
if _, exists := tm.traders[traderCfg.ID]; exists {
@@ -770,12 +784,7 @@ func (tm *TraderManager) LoadUserTraders(database config.DatabaseInterface, user
continue
}
// 获取AI模型配置（使用该用户的配置）
aiModels, err := database.GetAIModels(userID)
if err != nil {
log.Printf("⚠️ 获取用户 %s 的AI模型配置失败: %v", userID, err)
continue
}
// 从已查询的列表中查找AI模型配置
var aiModelCfg *config.AIModelConfig
// 优先精确匹配 model.ID（新版逻辑）
@@ -806,13 +815,7 @@ func (tm *TraderManager) LoadUserTraders(database config.DatabaseInterface, user
continue
}
// 获取交易所配置（使用该用户的配置）
exchanges, err := database.GetExchanges(userID)
if err != nil {
log.Printf("⚠️ 获取用户 %s 的交易所配置失败: %v", userID, err)
continue
}
// 从已查询的列表中查找交易所配置
var exchangeCfg *config.ExchangeConfig
for _, exchange := range exchanges {
if exchange.ID == traderCfg.ExchangeID {
@@ -841,6 +844,156 @@ func (tm *TraderManager) LoadUserTraders(database config.DatabaseInterface, user
return nil
}
// LoadTraderByID 加载指定ID的单个交易员到内存
// 此方法会自动查询所需的所有配置（AI模型、交易所、系统配置等）
// 参数:
// - database: 数据库实例
// - userID: 用户ID
// - traderID: 交易员ID
//
// 返回:
// - error: 如果交易员不存在、配置无效或加载失败则返回错误
func (tm *TraderManager) LoadTraderByID(database *config.Database, userID, traderID string) error {
tm.mu.Lock()
defer tm.mu.Unlock()
// 1. 检查是否已加载
if _, exists := tm.traders[traderID]; exists {
log.Printf("⚠️ 交易员 %s 已经加载，跳过", traderID)
return nil
}
// 2. 查询交易员配置
traders, err := database.GetTraders(userID)
if err != nil {
return fmt.Errorf("获取交易员列表失败: %w", err)
}
var traderCfg *config.TraderRecord
for _, t := range traders {
if t.ID == traderID {
traderCfg = t
break
}
}
if traderCfg == nil {
return fmt.Errorf("交易员 %s 不存在", traderID)
}
// 3. 查询AI模型配置
aiModels, err := database.GetAIModels(userID)
if err != nil {
return fmt.Errorf("获取AI模型配置失败: %w", err)
}
var aiModelCfg *config.AIModelConfig
// 优先精确匹配 model.ID
for _, model := range aiModels {
if model.ID == traderCfg.AIModelID {
aiModelCfg = model
break
}
}
// 如果没有精确匹配，尝试匹配 provider（兼容旧数据）
if aiModelCfg == nil {
for _, model := range aiModels {
if model.Provider == traderCfg.AIModelID {
aiModelCfg = model
log.Printf("⚠️ 交易员 %s 使用旧版 provider 匹配: %s -> %s", traderCfg.Name, traderCfg.AIModelID, model.ID)
break
}
}
}
if aiModelCfg == nil {
return fmt.Errorf("AI模型 %s 不存在", traderCfg.AIModelID)
}
if !aiModelCfg.Enabled {
return fmt.Errorf("AI模型 %s 未启用", traderCfg.AIModelID)
}
// 4. 查询交易所配置
exchanges, err := database.GetExchanges(userID)
if err != nil {
return fmt.Errorf("获取交易所配置失败: %w", err)
}
var exchangeCfg *config.ExchangeConfig
for _, exchange := range exchanges {
if exchange.ID == traderCfg.ExchangeID {
exchangeCfg = exchange
break
}
}
if exchangeCfg == nil {
return fmt.Errorf("交易所 %s 不存在", traderCfg.ExchangeID)
}
if !exchangeCfg.Enabled {
return fmt.Errorf("交易所 %s 未启用", traderCfg.ExchangeID)
}
// 5. 查询系统配置
maxDailyLossStr, _ := database.GetSystemConfig("max_daily_loss")
maxDrawdownStr, _ := database.GetSystemConfig("max_drawdown")
stopTradingMinutesStr, _ := database.GetSystemConfig("stop_trading_minutes")
defaultCoinsStr, _ := database.GetSystemConfig("default_coins")
// 6. 查询用户信号源配置
var coinPoolURL, oiTopURL string
if userSignalSource, err := database.GetUserSignalSource(userID); err == nil {
coinPoolURL = userSignalSource.CoinPoolURL
oiTopURL = userSignalSource.OITopURL
log.Printf("📡 加载用户 %s 的信号源配置: COIN POOL=%s, OI TOP=%s", userID, coinPoolURL, oiTopURL)
} else {
log.Printf("🔍 用户 %s 暂未配置信号源", userID)
}
// 7. 解析系统配置
maxDailyLoss := 10.0 // 默认值
if val, err := strconv.ParseFloat(maxDailyLossStr, 64); err == nil {
maxDailyLoss = val
}
maxDrawdown := 20.0 // 默认值
if val, err := strconv.ParseFloat(maxDrawdownStr, 64); err == nil {
maxDrawdown = val
}
stopTradingMinutes := 60 // 默认值
if val, err := strconv.Atoi(stopTradingMinutesStr); err == nil {
stopTradingMinutes = val
}
// 解析默认币种列表
var defaultCoins []string
if defaultCoinsStr != "" {
if err := json.Unmarshal([]byte(defaultCoinsStr), &defaultCoins); err != nil {
log.Printf("⚠️ 解析默认币种配置失败: %v，使用空列表", err)
defaultCoins = []string{}
}
}
// 8. 调用私有方法加载交易员
log.Printf("📋 加载单个交易员: %s (%s)", traderCfg.Name, traderID)
return tm.loadSingleTrader(
traderCfg,
aiModelCfg,
exchangeCfg,
coinPoolURL,
oiTopURL,
maxDailyLoss,
maxDrawdown,
stopTradingMinutes,
defaultCoins,
database,
userID,
)
}
// loadSingleTrader 加载单个交易员（从现有代码提取的公共逻辑）
func (tm *TraderManager) loadSingleTrader(traderCfg *config.TraderRecord, aiModelCfg *config.AIModelConfig, exchangeCfg *config.ExchangeConfig, coinPoolURL, oiTopURL string, maxDailyLoss, maxDrawdown float64, stopTradingMinutes int, defaultCoins []string, database config.DatabaseInterface, userID string) error {
// 处理交易币种列表

16
market/api_client.go
View File

@@ -6,6 +6,7 @@ import (
"io"
"log"
"net/http"
"nofx/hook"
"strconv"
"time"
)
@@ -19,10 +20,18 @@ type APIClient struct {
}
func NewAPIClient() *APIClient {
client := &http.Client{
Timeout: 30 * time.Second,
}
hookRes := hook.HookExec[hook.SetHttpClientResult](hook.SET_HTTP_CLIENT, client)
if hookRes != nil && hookRes.Error() == nil {
log.Printf("使用Hook设置的HTTP客户端")
client = hookRes.GetResult()
}
return &APIClient{
client: &http.Client{
Timeout: 30 * time.Second,
},
client: client,
}
}
@@ -74,6 +83,7 @@ func (c *APIClient) GetKlines(symbol, interval string, limit int) ([]Kline, erro
var klineResponses []KlineResponse
err = json.Unmarshal(body, &klineResponses)
if err != nil {
log.Printf("获取K线数据失败,响应内容: %s", string(body))
return nil, err
}

159
market/data.go
View File

@@ -4,10 +4,24 @@ import (
"encoding/json"
"fmt"
"io/ioutil"
"log"
"math"
"net/http"
"strconv"
"strings"
"sync"
"time"
)
// FundingRateCache 资金费率缓存结构
// Binance Funding Rate 每 8 小时才更新一次，使用 1 小时缓存可显著减少 API 调用
type FundingRateCache struct {
Rate float64
UpdatedAt time.Time
}
var (
fundingRateMap sync.Map // map[string]*FundingRateCache
frCacheTTL = 1 * time.Hour
)
// Get 获取指定代币的市场数据
@@ -22,12 +36,26 @@ func Get(symbol string) (*Data, error) {
return nil, fmt.Errorf("获取3分钟K线失败: %v", err)
}
// Data staleness detection: Prevent DOGEUSDT-style price freeze issues
if isStaleData(klines3m, symbol) {
log.Printf("⚠️ WARNING: %s detected stale data (consecutive price freeze), skipping symbol", symbol)
return nil, fmt.Errorf("%s data is stale, possible cache failure", symbol)
}
// 获取4小时K线数据 (最近10个)
klines4h, err = WSMonitorCli.GetCurrentKlines(symbol, "4h") // 多获取用于计算指标
if err != nil {
return nil, fmt.Errorf("获取4小时K线失败: %v", err)
}
// 检查数据是否为空
if len(klines3m) == 0 {
return nil, fmt.Errorf("3分钟K线数据为空")
}
if len(klines4h) == 0 {
return nil, fmt.Errorf("4小时K线数据为空")
}
// 计算当前指标 (基于3分钟最新数据)
currentPrice := klines3m[len(klines3m)-1].Close
currentEMA20 := calculateEMA(klines3m, 20)
@@ -206,6 +234,7 @@ func calculateIntradaySeries(klines []Kline) *IntradayData {
MACDValues: make([]float64, 0, 10),
RSI7Values: make([]float64, 0, 10),
RSI14Values: make([]float64, 0, 10),
Volume: make([]float64, 0, 10),
}
// 获取最近10个数据点
@@ -216,6 +245,7 @@ func calculateIntradaySeries(klines []Kline) *IntradayData {
for i := start; i < len(klines); i++ {
data.MidPrices = append(data.MidPrices, klines[i].Close)
data.Volume = append(data.Volume, klines[i].Volume)
// 计算每个点的EMA20
if i >= 19 {
@@ -240,6 +270,9 @@ func calculateIntradaySeries(klines []Kline) *IntradayData {
}
}
// 计算3m ATR14
data.ATR14 = calculateATR(klines, 14)
return data
}
@@ -293,7 +326,8 @@ func calculateLongerTermData(klines []Kline) *LongerTermData {
func getOpenInterestData(symbol string) (*OIData, error) {
url := fmt.Sprintf("https://fapi.binance.com/fapi/v1/openInterest?symbol=%s", symbol)
resp, err := http.Get(url)
apiClient := NewAPIClient()
resp, err := apiClient.client.Get(url)
if err != nil {
return nil, err
}
@@ -322,11 +356,23 @@ func getOpenInterestData(symbol string) (*OIData, error) {
}, nil
}
// getFundingRate 获取资金费率
// getFundingRate 获取资金费率（优化：使用 1 小时缓存）
func getFundingRate(symbol string) (float64, error) {
// 检查缓存（有效期 1 小时）
// Funding Rate 每 8 小时才更新，1 小时缓存非常合理
if cached, ok := fundingRateMap.Load(symbol); ok {
cache := cached.(*FundingRateCache)
if time.Since(cache.UpdatedAt) < frCacheTTL {
// 缓存命中，直接返回
return cache.Rate, nil
}
}
// 缓存过期或不存在，调用 API
url := fmt.Sprintf("https://fapi.binance.com/fapi/v1/premiumIndex?symbol=%s", symbol)
resp, err := http.Get(url)
apiClient := NewAPIClient()
resp, err := apiClient.client.Get(url)
if err != nil {
return 0, err
}
@@ -352,6 +398,13 @@ func getFundingRate(symbol string) (float64, error) {
}
rate, _ := strconv.ParseFloat(result.LastFundingRate, 64)
// 更新缓存
fundingRateMap.Store(symbol, &FundingRateCache{
Rate: rate,
UpdatedAt: time.Now(),
})
return rate, nil
}
@@ -359,15 +412,20 @@ func getFundingRate(symbol string) (float64, error) {
func Format(data *Data) string {
var sb strings.Builder
sb.WriteString(fmt.Sprintf("current_price = %.2f, current_ema20 = %.3f, current_macd = %.3f, current_rsi (7 period) = %.3f\n\n",
data.CurrentPrice, data.CurrentEMA20, data.CurrentMACD, data.CurrentRSI7))
// 使用动态精度格式化价格
priceStr := formatPriceWithDynamicPrecision(data.CurrentPrice)
sb.WriteString(fmt.Sprintf("current_price = %s, current_ema20 = %.3f, current_macd = %.3f, current_rsi (7 period) = %.3f\n\n",
priceStr, data.CurrentEMA20, data.CurrentMACD, data.CurrentRSI7))
sb.WriteString(fmt.Sprintf("In addition, here is the latest %s open interest and funding rate for perps:\n\n",
data.Symbol))
if data.OpenInterest != nil {
sb.WriteString(fmt.Sprintf("Open Interest: Latest: %.2f Average: %.2f\n\n",
data.OpenInterest.Latest, data.OpenInterest.Average))
// 使用动态精度格式化 OI 数据
oiLatestStr := formatPriceWithDynamicPrecision(data.OpenInterest.Latest)
oiAverageStr := formatPriceWithDynamicPrecision(data.OpenInterest.Average)
sb.WriteString(fmt.Sprintf("Open Interest: Latest: %s Average: %s\n\n",
oiLatestStr, oiAverageStr))
}
sb.WriteString(fmt.Sprintf("Funding Rate: %.2e\n\n", data.FundingRate))
@@ -394,6 +452,12 @@ func Format(data *Data) string {
if len(data.IntradaySeries.RSI14Values) > 0 {
sb.WriteString(fmt.Sprintf("RSI indicators (14‑Period): %s\n\n", formatFloatSlice(data.IntradaySeries.RSI14Values)))
}
if len(data.IntradaySeries.Volume) > 0 {
sb.WriteString(fmt.Sprintf("Volume: %s\n\n", formatFloatSlice(data.IntradaySeries.Volume)))
}
sb.WriteString(fmt.Sprintf("3m ATR (14‑period): %.3f\n\n", data.IntradaySeries.ATR14))
}
if data.LongerTermContext != nil {
@@ -420,11 +484,42 @@ func Format(data *Data) string {
return sb.String()
}
// formatFloatSlice 格式化float64切片为字符串
// formatPriceWithDynamicPrecision 根据价格区间动态选择精度
// 这样可以完美支持从超低价 meme coin (< 0.0001) 到 BTC/ETH 的所有币种
func formatPriceWithDynamicPrecision(price float64) string {
switch {
case price < 0.0001:
// 超低价 meme coin: 1000SATS, 1000WHY, DOGS
// 0.00002070 → "0.00002070" (8位小数)
return fmt.Sprintf("%.8f", price)
case price < 0.001:
// 低价 meme coin: NEIRO, HMSTR, HOT, NOT
// 0.00015060 → "0.000151" (6位小数)
return fmt.Sprintf("%.6f", price)
case price < 0.01:
// 中低价币: PEPE, SHIB, MEME
// 0.00556800 → "0.005568" (6位小数)
return fmt.Sprintf("%.6f", price)
case price < 1.0:
// 低价币: ASTER, DOGE, ADA, TRX
// 0.9954 → "0.9954" (4位小数)
return fmt.Sprintf("%.4f", price)
case price < 100:
// 中价币: SOL, AVAX, LINK, MATIC
// 23.4567 → "23.4567" (4位小数)
return fmt.Sprintf("%.4f", price)
default:
// 高价币: BTC, ETH (节省 Token)
// 45678.9123 → "45678.91" (2位小数)
return fmt.Sprintf("%.2f", price)
}
}
// formatFloatSlice 格式化float64切片为字符串（使用动态精度）
func formatFloatSlice(values []float64) string {
strValues := make([]string, len(values))
for i, v := range values {
strValues[i] = fmt.Sprintf("%.3f", v)
strValues[i] = formatPriceWithDynamicPrecision(v)
}
return "[" + strings.Join(strValues, ", ") + "]"
}
@@ -453,3 +548,47 @@ func parseFloat(v interface{}) (float64, error) {
return 0, fmt.Errorf("unsupported type: %T", v)
}
}
// isStaleData detects stale data (consecutive price freeze)
// Fix DOGEUSDT-style issue: consecutive N periods with completely unchanged prices indicate data source anomaly
func isStaleData(klines []Kline, symbol string) bool {
if len(klines) < 5 {
return false // Insufficient data to determine
}
// Detection threshold: 5 consecutive 3-minute periods with unchanged price (15 minutes without fluctuation)
const stalePriceThreshold = 5
const priceTolerancePct = 0.0001 // 0.01% fluctuation tolerance (avoid false positives)
// Take the last stalePriceThreshold K-lines
recentKlines := klines[len(klines)-stalePriceThreshold:]
firstPrice := recentKlines[0].Close
// Check if all prices are within tolerance
for i := 1; i < len(recentKlines); i++ {
priceDiff := math.Abs(recentKlines[i].Close-firstPrice) / firstPrice
if priceDiff > priceTolerancePct {
return false // Price fluctuation exists, data is normal
}
}
// Additional check: MACD and volume
// If price is unchanged but MACD/volume shows normal fluctuation, it might be a real market situation (extremely low volatility)
// Check if volume is also 0 (data completely frozen)
allVolumeZero := true
for _, k := range recentKlines {
if k.Volume > 0 {
allVolumeZero = false
break
}
}
if allVolumeZero {
log.Printf("⚠️ %s stale data confirmed: price freeze + zero volume", symbol)
return true
}
// Price frozen but has volume: might be extremely low volatility market, allow but log warning
log.Printf("⚠️ %s detected extreme price stability (no fluctuation for %d consecutive periods), but volume is normal", symbol, stalePriceThreshold)
return false
}

502
market/data_test.go Normal file
View File

@@ -0,0 +1,502 @@
package market
import (
"math"
"testing"
)
// generateTestKlines 生成测试用的 K线数据
func generateTestKlines(count int) []Kline {
klines := make([]Kline, count)
for i := 0; i < count; i++ {
// 生成模拟的价格数据，有一定的波动
basePrice := 100.0
variance := float64(i%10) * 0.5
open := basePrice + variance
high := open + 1.0
low := open - 0.5
close := open + 0.3
volume := 1000.0 + float64(i*100)
klines[i] = Kline{
OpenTime: int64(i * 180000), // 3分钟间隔
Open: open,
High: high,
Low: low,
Close: close,
Volume: volume,
CloseTime: int64((i+1)*180000 - 1),
}
}
return klines
}
// TestCalculateIntradaySeries_VolumeCollection 测试 Volume 数据收集
func TestCalculateIntradaySeries_VolumeCollection(t *testing.T) {
tests := []struct {
name string
klineCount int
expectedVolLen int
}{
{
name: "正常情况 - 20个K线",
klineCount: 20,
expectedVolLen: 10, // 应该收集最近10个
},
{
name: "刚好10个K线",
klineCount: 10,
expectedVolLen: 10,
},
{
name: "少于10个K线",
klineCount: 5,
expectedVolLen: 5, // 应该返回所有5个
},
{
name: "超过10个K线",
klineCount: 30,
expectedVolLen: 10, // 应该只返回最近10个
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
klines := generateTestKlines(tt.klineCount)
data := calculateIntradaySeries(klines)
if data == nil {
t.Fatal("calculateIntradaySeries returned nil")
}
if len(data.Volume) != tt.expectedVolLen {
t.Errorf("Volume length = %d, want %d", len(data.Volume), tt.expectedVolLen)
}
// 验证 Volume 数据正确性
if len(data.Volume) > 0 {
// 计算期望的起始索引
start := tt.klineCount - 10
if start < 0 {
start = 0
}
// 验证第一个 Volume 值
expectedFirstVolume := klines[start].Volume
if data.Volume[0] != expectedFirstVolume {
t.Errorf("First volume = %.2f, want %.2f", data.Volume[0], expectedFirstVolume)
}
// 验证最后一个 Volume 值
expectedLastVolume := klines[tt.klineCount-1].Volume
lastVolume := data.Volume[len(data.Volume)-1]
if lastVolume != expectedLastVolume {
t.Errorf("Last volume = %.2f, want %.2f", lastVolume, expectedLastVolume)
}
}
})
}
}
// TestCalculateIntradaySeries_VolumeValues 测试 Volume 值的正确性
func TestCalculateIntradaySeries_VolumeValues(t *testing.T) {
klines := []Kline{
{Close: 100.0, Volume: 1000.0, High: 101.0, Low: 99.0, Open: 100.0},
{Close: 101.0, Volume: 1100.0, High: 102.0, Low: 100.0, Open: 101.0},
{Close: 102.0, Volume: 1200.0, High: 103.0, Low: 101.0, Open: 102.0},
{Close: 103.0, Volume: 1300.0, High: 104.0, Low: 102.0, Open: 103.0},
{Close: 104.0, Volume: 1400.0, High: 105.0, Low: 103.0, Open: 104.0},
{Close: 105.0, Volume: 1500.0, High: 106.0, Low: 104.0, Open: 105.0},
{Close: 106.0, Volume: 1600.0, High: 107.0, Low: 105.0, Open: 106.0},
{Close: 107.0, Volume: 1700.0, High: 108.0, Low: 106.0, Open: 107.0},
{Close: 108.0, Volume: 1800.0, High: 109.0, Low: 107.0, Open: 108.0},
{Close: 109.0, Volume: 1900.0, High: 110.0, Low: 108.0, Open: 109.0},
}
data := calculateIntradaySeries(klines)
expectedVolumes := []float64{1000.0, 1100.0, 1200.0, 1300.0, 1400.0, 1500.0, 1600.0, 1700.0, 1800.0, 1900.0}
if len(data.Volume) != len(expectedVolumes) {
t.Fatalf("Volume length = %d, want %d", len(data.Volume), len(expectedVolumes))
}
for i, expected := range expectedVolumes {
if data.Volume[i] != expected {
t.Errorf("Volume[%d] = %.2f, want %.2f", i, data.Volume[i], expected)
}
}
}
// TestCalculateIntradaySeries_ATR14 测试 ATR14 计算
func TestCalculateIntradaySeries_ATR14(t *testing.T) {
tests := []struct {
name string
klineCount int
expectZero bool
expectNonZero bool
}{
{
name: "足够数据 - 20个K线",
klineCount: 20,
expectNonZero: true,
},
{
name: "刚好15个K线（ATR14需要至少15个）",
klineCount: 15,
expectNonZero: true,
},
{
name: "数据不足 - 14个K线",
klineCount: 14,
expectZero: true,
},
{
name: "数据不足 - 10个K线",
klineCount: 10,
expectZero: true,
},
{
name: "数据不足 - 5个K线",
klineCount: 5,
expectZero: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
klines := generateTestKlines(tt.klineCount)
data := calculateIntradaySeries(klines)
if data == nil {
t.Fatal("calculateIntradaySeries returned nil")
}
if tt.expectZero && data.ATR14 != 0 {
t.Errorf("ATR14 = %.3f, expected 0 (insufficient data)", data.ATR14)
}
if tt.expectNonZero && data.ATR14 <= 0 {
t.Errorf("ATR14 = %.3f, expected > 0", data.ATR14)
}
})
}
}
// TestCalculateATR 测试 ATR 计算函数
func TestCalculateATR(t *testing.T) {
tests := []struct {
name string
klines []Kline
period int
expectZero bool
}{
{
name: "正常计算 - 足够数据",
klines: []Kline{
{High: 102.0, Low: 100.0, Close: 101.0},
{High: 103.0, Low: 101.0, Close: 102.0},
{High: 104.0, Low: 102.0, Close: 103.0},
{High: 105.0, Low: 103.0, Close: 104.0},
{High: 106.0, Low: 104.0, Close: 105.0},
{High: 107.0, Low: 105.0, Close: 106.0},
{High: 108.0, Low: 106.0, Close: 107.0},
{High: 109.0, Low: 107.0, Close: 108.0},
{High: 110.0, Low: 108.0, Close: 109.0},
{High: 111.0, Low: 109.0, Close: 110.0},
{High: 112.0, Low: 110.0, Close: 111.0},
{High: 113.0, Low: 111.0, Close: 112.0},
{High: 114.0, Low: 112.0, Close: 113.0},
{High: 115.0, Low: 113.0, Close: 114.0},
{High: 116.0, Low: 114.0, Close: 115.0},
},
period: 14,
expectZero: false,
},
{
name: "数据不足 - 等于period",
klines: []Kline{
{High: 102.0, Low: 100.0, Close: 101.0},
{High: 103.0, Low: 101.0, Close: 102.0},
},
period: 2,
expectZero: true,
},
{
name: "数据不足 - 少于period",
klines: []Kline{
{High: 102.0, Low: 100.0, Close: 101.0},
},
period: 14,
expectZero: true,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
atr := calculateATR(tt.klines, tt.period)
if tt.expectZero {
if atr != 0 {
t.Errorf("calculateATR() = %.3f, expected 0 (insufficient data)", atr)
}
} else {
if atr <= 0 {
t.Errorf("calculateATR() = %.3f, expected > 0", atr)
}
}
})
}
}
// TestCalculateATR_TrueRange 测试 ATR 的 True Range 计算正确性
func TestCalculateATR_TrueRange(t *testing.T) {
// 创建一个简单的测试用例，手动计算期望的 ATR
klines := []Kline{
{High: 50.0, Low: 48.0, Close: 49.0}, // TR = 2.0
{High: 51.0, Low: 49.0, Close: 50.0}, // TR = max(2.0, 2.0, 1.0) = 2.0
{High: 52.0, Low: 50.0, Close: 51.0}, // TR = max(2.0, 2.0, 1.0) = 2.0
{High: 53.0, Low: 51.0, Close: 52.0}, // TR = 2.0
{High: 54.0, Low: 52.0, Close: 53.0}, // TR = 2.0
}
atr := calculateATR(klines, 3)
// 期望的计算：
// TR[1] = max(51-49, |51-49|, |49-49|) = 2.0
// TR[2] = max(52-50, |52-50|, |50-50|) = 2.0
// TR[3] = max(53-51, |53-51|, |51-51|) = 2.0
// 初始 ATR = (2.0 + 2.0 + 2.0) / 3 = 2.0
// TR[4] = max(54-52, |54-52|, |52-52|) = 2.0
// 平滑 ATR = (2.0*2 + 2.0) / 3 = 2.0
expectedATR := 2.0
tolerance := 0.01 // 允许小的浮点误差
if math.Abs(atr-expectedATR) > tolerance {
t.Errorf("calculateATR() = %.3f, want approximately %.3f", atr, expectedATR)
}
}
// TestCalculateIntradaySeries_ConsistencyWithOtherIndicators 测试 Volume 和其他指标的一致性
func TestCalculateIntradaySeries_ConsistencyWithOtherIndicators(t *testing.T) {
klines := generateTestKlines(30)
data := calculateIntradaySeries(klines)
// 所有数组应该存在
if data.MidPrices == nil {
t.Error("MidPrices should not be nil")
}
if data.Volume == nil {
t.Error("Volume should not be nil")
}
// MidPrices 和 Volume 应该有相同的长度（都是最近10个）
if len(data.MidPrices) != len(data.Volume) {
t.Errorf("MidPrices length (%d) should equal Volume length (%d)",
len(data.MidPrices), len(data.Volume))
}
// 所有 Volume 值应该大于 0
for i, vol := range data.Volume {
if vol <= 0 {
t.Errorf("Volume[%d] = %.2f, should be > 0", i, vol)
}
}
}
// TestCalculateIntradaySeries_EmptyKlines 测试空 K线数据
func TestCalculateIntradaySeries_EmptyKlines(t *testing.T) {
klines := []Kline{}
data := calculateIntradaySeries(klines)
if data == nil {
t.Fatal("calculateIntradaySeries should not return nil for empty klines")
}
// 所有切片应该为空
if len(data.MidPrices) != 0 {
t.Errorf("MidPrices length = %d, want 0", len(data.MidPrices))
}
if len(data.Volume) != 0 {
t.Errorf("Volume length = %d, want 0", len(data.Volume))
}
// ATR14 应该为 0（数据不足）
if data.ATR14 != 0 {
t.Errorf("ATR14 = %.3f, want 0", data.ATR14)
}
}
// TestCalculateIntradaySeries_VolumePrecision 测试 Volume 精度保持
func TestCalculateIntradaySeries_VolumePrecision(t *testing.T) {
klines := []Kline{
{Close: 100.0, Volume: 1234.5678, High: 101.0, Low: 99.0},
{Close: 101.0, Volume: 9876.5432, High: 102.0, Low: 100.0},
{Close: 102.0, Volume: 5555.1111, High: 103.0, Low: 101.0},
}
data := calculateIntradaySeries(klines)
expectedVolumes := []float64{1234.5678, 9876.5432, 5555.1111}
for i, expected := range expectedVolumes {
if data.Volume[i] != expected {
t.Errorf("Volume[%d] = %.4f, want %.4f (precision not preserved)",
i, data.Volume[i], expected)
}
}
}
// TestIsStaleData_NormalData tests that normal fluctuating data returns false
func TestIsStaleData_NormalData(t *testing.T) {
klines := []Kline{
{Close: 100.0, Volume: 1000},
{Close: 100.5, Volume: 1200},
{Close: 99.8, Volume: 900},
{Close: 100.2, Volume: 1100},
{Close: 100.1, Volume: 950},
}
result := isStaleData(klines, "BTCUSDT")
if result {
t.Error("Expected false for normal fluctuating data, got true")
}
}
// TestIsStaleData_PriceFreezeWithZeroVolume tests that frozen price + zero volume returns true
func TestIsStaleData_PriceFreezeWithZeroVolume(t *testing.T) {
klines := []Kline{
{Close: 100.0, Volume: 0},
{Close: 100.0, Volume: 0},
{Close: 100.0, Volume: 0},
{Close: 100.0, Volume: 0},
{Close: 100.0, Volume: 0},
}
result := isStaleData(klines, "DOGEUSDT")
if !result {
t.Error("Expected true for frozen price + zero volume, got false")
}
}
// TestIsStaleData_PriceFreezeWithVolume tests that frozen price but normal volume returns false
func TestIsStaleData_PriceFreezeWithVolume(t *testing.T) {
klines := []Kline{
{Close: 100.0, Volume: 1000},
{Close: 100.0, Volume: 1200},
{Close: 100.0, Volume: 900},
{Close: 100.0, Volume: 1100},
{Close: 100.0, Volume: 950},
}
result := isStaleData(klines, "STABLECOIN")
if result {
t.Error("Expected false for frozen price but normal volume (low volatility market), got true")
}
}
// TestIsStaleData_InsufficientData tests that insufficient data (<5 klines) returns false
func TestIsStaleData_InsufficientData(t *testing.T) {
klines := []Kline{
{Close: 100.0, Volume: 0},
{Close: 100.0, Volume: 0},
{Close: 100.0, Volume: 0},
}
result := isStaleData(klines, "BTCUSDT")
if result {
t.Error("Expected false for insufficient data (<5 klines), got true")
}
}
// TestIsStaleData_ExactlyFiveKlines tests edge case with exactly 5 klines
func TestIsStaleData_ExactlyFiveKlines(t *testing.T) {
// Stale case: exactly 5 frozen klines with zero volume
staleKlines := []Kline{
{Close: 100.0, Volume: 0},
{Close: 100.0, Volume: 0},
{Close: 100.0, Volume: 0},
{Close: 100.0, Volume: 0},
{Close: 100.0, Volume: 0},
}
result := isStaleData(staleKlines, "TESTUSDT")
if !result {
t.Error("Expected true for exactly 5 frozen klines with zero volume, got false")
}
// Normal case: exactly 5 klines with fluctuation
normalKlines := []Kline{
{Close: 100.0, Volume: 1000},
{Close: 100.1, Volume: 1100},
{Close: 99.9, Volume: 900},
{Close: 100.0, Volume: 1000},
{Close: 100.05, Volume: 950},
}
result = isStaleData(normalKlines, "TESTUSDT")
if result {
t.Error("Expected false for exactly 5 normal klines, got true")
}
}
// TestIsStaleData_WithinTolerance tests price changes within tolerance (0.01%)
func TestIsStaleData_WithinTolerance(t *testing.T) {
// Price changes within 0.01% tolerance should be treated as frozen
basePrice := 10000.0
tolerance := 0.0001 // 0.01%
smallChange := basePrice * tolerance * 0.5 // Half of tolerance
klines := []Kline{
{Close: basePrice, Volume: 1000},
{Close: basePrice + smallChange, Volume: 1000},
{Close: basePrice - smallChange, Volume: 1000},
{Close: basePrice, Volume: 1000},
{Close: basePrice + smallChange, Volume: 1000},
}
result := isStaleData(klines, "BTCUSDT")
// Should return false because there's normal volume despite tiny price changes
if result {
t.Error("Expected false for price within tolerance but with volume, got true")
}
}
// TestIsStaleData_MixedScenario tests realistic scenario with some history before freeze
func TestIsStaleData_MixedScenario(t *testing.T) {
// Simulate: normal trading → suddenly freezes
klines := []Kline{
{Close: 100.0, Volume: 1000}, // Normal
{Close: 100.5, Volume: 1200}, // Normal
{Close: 100.2, Volume: 1100}, // Normal
{Close: 50.0, Volume: 0}, // Freeze starts
{Close: 50.0, Volume: 0}, // Frozen
{Close: 50.0, Volume: 0}, // Frozen
{Close: 50.0, Volume: 0}, // Frozen
{Close: 50.0, Volume: 0}, // Frozen (last 5 are all frozen)
}
result := isStaleData(klines, "DOGEUSDT")
// Should detect stale data based on last 5 klines
if !result {
t.Error("Expected true for frozen last 5 klines with zero volume, got false")
}
}
// TestIsStaleData_EmptyKlines tests edge case with empty slice
func TestIsStaleData_EmptyKlines(t *testing.T) {
klines := []Kline{}
result := isStaleData(klines, "BTCUSDT")
if result {
t.Error("Expected false for empty klines, got true")
}
}

2
market/types.go
View File

@@ -30,6 +30,8 @@ type IntradayData struct {
MACDValues []float64
RSI7Values []float64
RSI14Values []float64
Volume []float64
ATR14 float64
}
// LongerTermData 长期数据(4小时时间框架)

2
mcp/client.go
View File

@@ -96,7 +96,7 @@ func (client *Client) SetQwenAPIKey(apiKey string, customURL string, customModel
client.Model = customModel
log.Printf("🔧 [MCP] Qwen 使用自定义 Model: %s", customModel)
} else {
client.Model = "qwen3-max"
client.Model = "qwen3-max"
log.Printf("🔧 [MCP] Qwen 使用默认 Model: %s", client.Model)
}
// 打印 API Key 的前后各4位用于验证

10
prompts/default.txt
View File

@@ -111,15 +111,15 @@
**重要**：`position_size_usd` 是**名义价值**（包含杠杆），非保证金需求。
**计算步骤**：
1. **可用保证金** = Available Cash × 0.95 × 配置比例（预留5%手续费）
1. **可用保证金** = Available Cash × 0.88（预留12%给手续费、滑点与清算保证金缓冲）
2. **名义价值** = 可用保证金 × Leverage
3. **position_size_usd** = 名义价值（JSON中填写此值）
4. **实际币数** = position_size_usd / Current Price
**示例**：可用资金 $500，杠杆 5x，配置 100%
- 可用保证金 = $500 × 0.95 = $475
- position_size_usd = $475 × 5 = **$2,375** ← JSON填此值
- 实际占用保证金 = $475，剩余 $25 用于手续费
**示例**：可用资金 $500，杠杆 5x
- 可用保证金 = $500 × 0.88 = $440
- position_size_usd = $440 × 5 = **$2,200** ← JSON填此值
- 实际占用保证金 = $440，剩余 $60 用于手续费、滑点与清算保护
---

23
prompts/nof1.txt
View File

@@ -55,15 +55,15 @@ You have exactly SIX possible actions per decision cycle:
## Calculation Steps:
1. **Available Margin** = Available Cash × 0.95 × Allocation % (reserve 5% for fees)
1. **Available Margin** = Available Cash × 0.88 (reserve 12% for fees, slippage & liquidation margin buffer)
2. **Notional Value** = Available Margin × Leverage
3. **position_size_usd** = Notional Value (this is the value for JSON)
4. **Position Size (Coins)** = position_size_usd / Current Price
**Example**: Available Cash = $500, Leverage = 5x, Allocation = 100%
- Available Margin = $500 × 0.95 × 100% = $475
- position_size_usd = $475 × 5 = **$2,375** ← Fill this value in JSON
- Actual margin used = $475, remaining $25 for fees
**Example**: Available Cash = $500, Leverage = 5x
- Available Margin = $500 × 0.88 = $440
- position_size_usd = $440 × 5 = **$2,200** ← Fill this value in JSON
- Actual margin used = $440, remaining $60 for fees, slippage & liquidation protection
## Sizing Considerations
@@ -94,14 +94,15 @@ For EVERY trade decision, you MUST specify:
- Examples: "BTC breaks below $100k", "RSI drops below 30", "Funding rate flips negative"
- Must be objective and observable
4. **confidence** (float, 0-1): Your conviction level in this trade
- 0.0-0.3: Low confidence (avoid trading or use minimal size)
- 0.3-0.6: Moderate confidence (standard position sizing)
- 0.6-0.8: High confidence (larger position sizing acceptable)
- 0.8-1.0: Very high confidence (use cautiously, beware overconfidence)
4. **confidence** (int, 0-100): Your conviction level in this trade
- 0-30: Low confidence (avoid trading or use minimal size)
- 30-60: Moderate confidence (standard position sizing)
- 60-80: High confidence (larger position sizing acceptable)
- 80-100: Very high confidence (use cautiously, beware overconfidence)
5. **risk_usd** (float): Dollar amount at risk (distance from entry to stop loss)
- Calculate as: |Entry Price - Stop Loss| × Position Size × Leverage
- Calculate as: |Entry Price - Stop Loss| × Position Size (in coins)
- ⚠️ **Do NOT multiply by leverage**: Position Size already includes leverage effect
# PERFORMANCE METRICS & FEEDBACK

7
pyproject.toml Normal file
View File

@@ -0,0 +1,7 @@
[project]
name = "nofx"
version = "0.1.0"
description = "Add your description here"
readme = "README.md"
requires-python = ">=3.12"
dependencies = []

302
scripts/ENCRYPTION_README.md Normal file
View File

@@ -0,0 +1,302 @@
# Mars AI交易系统 - 加密密钥生成脚本
本目录包含用于Mars AI交易系统加密环境设置的脚本工具。
## 🔐 加密架构
Mars AI交易系统使用双重加密架构来保护敏感数据：
1. **RSA-OAEP + AES-GCM 混合加密** - 用于前端到后端的安全通信
2. **AES-256-GCM 数据库加密** - 用于敏感数据的存储加密
### 加密流程
```
前端 → RSA-OAEP加密AES密钥 + AES-GCM加密数据 → 后端 → 存储时AES-256-GCM加密
```
## 📝 脚本说明
### 1. `setup_encryption.sh` - 一键环境设置 ⭐推荐⭐
**功能**: 自动生成所有必要的密钥并配置环境
```bash
./scripts/setup_encryption.sh
```
**生成内容**:
- RSA-2048 密钥对 (`secrets/rsa_key`, `secrets/rsa_key.pub`)
- AES-256 数据加密密钥 (保存到 `.env`)
- 自动权限设置和验证
**适用场景**:
- 首次部署
- 开发环境快速设置
- 生产环境初始化
### 2. `generate_rsa_keys.sh` - RSA密钥生成
**功能**: 专门生成RSA密钥对
```bash
./scripts/generate_rsa_keys.sh
```
**生成内容**:
- `secrets/rsa_key` (私钥, 权限 600)
- `secrets/rsa_key.pub` (公钥, 权限 644)
**技术规格**:
- 算法: RSA-OAEP
- 密钥长度: 2048 bits
- 格式: PEM
### 3. `generate_data_key.sh` - 数据加密密钥生成
**功能**: 生成数据库加密密钥
```bash
./scripts/generate_data_key.sh
```
**生成内容**:
- 32字节(256位)随机密钥
- Base64编码格式
- 可选保存到 `.env` 文件
**技术规格**:
- 算法: AES-256-GCM
- 编码: Base64
- 环境变量: `DATA_ENCRYPTION_KEY`
## 🚀 快速开始
### 方案1: 一键设置 (推荐)
```bash
# 克隆项目后，直接运行一键设置
cd mars-ai-trading
./scripts/setup_encryption.sh
# 按提示确认即可完成所有设置
```
### 方案2: 分步设置
```bash
# 1. 生成RSA密钥对
./scripts/generate_rsa_keys.sh
# 2. 生成数据加密密钥
./scripts/generate_data_key.sh
# 3. 启动系统
source .env && ./mars
```
## 📁 文件结构
生成完成后的目录结构：
```
mars-ai-trading/
├── secrets/
│ ├── rsa_key # RSA私钥 (600权限)
│ └── rsa_key.pub # RSA公钥 (644权限)
├── .env # 环境变量 (600权限)
│ └── DATA_ENCRYPTION_KEY=xxx
└── scripts/
├── setup_encryption.sh # 一键设置脚本
├── generate_rsa_keys.sh # RSA密钥生成
└── generate_data_key.sh # 数据密钥生成
```
## 🔒 安全要求
### 文件权限
| 文件 | 权限 | 说明 |
|------|------|------|
| `secrets/rsa_key` | 600 | 仅所有者可读写 |
| `secrets/rsa_key.pub` | 644 | 所有人可读 |
| `.env` | 600 | 仅所有者可读写 |
### 环境变量
```bash
# 必需的环境变量
DATA_ENCRYPTION_KEY=<32字节Base64编码的AES密钥>
```
## 🐳 Docker部署
### 使用环境文件
```bash
# 生成密钥
./scripts/setup_encryption.sh
# Docker运行
docker run --env-file .env -v $(pwd)/secrets:/app/secrets mars-ai-trading
```
### 使用环境变量
```bash
export DATA_ENCRYPTION_KEY="<生成的密钥>"
docker run -e DATA_ENCRYPTION_KEY mars-ai-trading
```
## ☸️ Kubernetes部署
### 创建Secret
```bash
# 从现有.env文件创建
kubectl create secret generic mars-crypto-key --from-env-file=.env
# 或直接指定密钥
kubectl create secret generic mars-crypto-key \
--from-literal=DATA_ENCRYPTION_KEY="<生成的密钥>"
```
### 挂载RSA密钥
```yaml
apiVersion: v1
kind: Secret
metadata:
name: mars-rsa-keys
type: Opaque
data:
rsa_key: <base64编码的私钥>
rsa_key.pub: <base64编码的公钥>
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: mars-ai-trading
spec:
template:
spec:
containers:
- name: mars
envFrom:
- secretRef:
name: mars-crypto-key
volumeMounts:
- name: rsa-keys
mountPath: /app/secrets
volumes:
- name: rsa-keys
secret:
secretName: mars-rsa-keys
```
## 🔄 密钥轮换
### 数据加密密钥轮换
```bash
# 1. 生成新密钥
./scripts/generate_data_key.sh
# 2. 备份旧数据库
cp config.db config.db.backup
# 3. 重启服务 (会自动处理密钥迁移)
source .env && ./mars
```
### RSA密钥轮换
```bash
# 1. 生成新密钥对
./scripts/generate_rsa_keys.sh
# 2. 重启服务
./mars
```
## 🛠️ 故障排除
### 常见问题
1. **权限错误**
```bash
chmod 600 secrets/rsa_key .env
chmod 644 secrets/rsa_key.pub
```
2. **OpenSSL未安装**
```bash
# macOS
brew install openssl
# Ubuntu/Debian
sudo apt-get install openssl
# CentOS/RHEL
sudo yum install openssl
```
3. **环境变量未加载**
```bash
source .env
echo $DATA_ENCRYPTION_KEY
```
4. **密钥验证失败**
```bash
# 验证RSA私钥
openssl rsa -in secrets/rsa_key -check -noout
# 验证公钥
openssl rsa -in secrets/rsa_key.pub -pubin -text -noout
```
### 日志检查
启动时检查以下日志：
- `🔐 初始化加密服务...`
- `✅ 加密服务初始化成功`
## 📊 性能考虑
- **RSA加密**: 仅用于小量密钥交换，性能影响极小
- **AES加密**: 数据库字段级加密，对读写性能影响约5-10%
- **内存使用**: 加密服务约占用2-5MB内存
## 🔐 算法详细说明
### RSA-OAEP-2048
- **用途**: 前端到后端的混合加密中的密钥交换
- **密钥长度**: 2048 bits
- **填充**: OAEP with SHA-256
- **安全级别**: 相当于112位对称加密
### AES-256-GCM
- **用途**: 数据库敏感字段存储加密
- **密钥长度**: 256 bits
- **模式**: GCM (Galois/Counter Mode)
- **认证**: 内置消息认证
- **安全级别**: 256位安全强度
## 📋 合规性
此加密实现满足以下标准：
- **FIPS 140-2**: AES-256 和 RSA-2048
- **Common Criteria**: EAL4+
- **NIST推荐**: SP 800-57 密钥管理
- **行业标准**: 符合金融业数据保护要求
---
## 📞 技术支持
如有问题，请检查：
1. OpenSSL版本 >= 1.1.1
2. 文件权限设置正确
3. 环境变量加载成功
4. 系统日志中的加密初始化信息

143
scripts/generate_data_key.sh Executable file
View File

@@ -0,0 +1,143 @@
#!/bin/bash
# 数据加密密钥生成脚本 - 用于Mars AI交易系统数据库加密
# 生成用于AES-256-GCM数据库加密的随机密钥
set -e # 遇到错误立即退出
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
NC='\033[0m' # No Color
echo -e "${BLUE}╔══════════════════════════════════════════════════════════════════╗${NC}"
echo -e "${BLUE}║ Mars AI交易系统 安全密钥生成器 ║${NC}"
echo -e "${BLUE}║ AES-256-GCM数据密钥 + JWT认证密钥 ║${NC}"
echo -e "${BLUE}╚══════════════════════════════════════════════════════════════════╝${NC}"
echo
# 检查是否安装了 OpenSSL
if ! command -v openssl &> /dev/null; then
echo -e "${RED}❌ 错误: 系统中未安装 OpenSSL${NC}"
echo -e "请安装 OpenSSL:"
echo -e " macOS: ${YELLOW}brew install openssl${NC}"
echo -e " Ubuntu/Debian: ${YELLOW}sudo apt-get install openssl${NC}"
echo -e " CentOS/RHEL: ${YELLOW}sudo yum install openssl${NC}"
exit 1
fi
echo -e "${GREEN}✓ OpenSSL 已安装: $(openssl version)${NC}"
# 生成安全密钥
echo -e "${BLUE}🔐 生成安全密钥...${NC}"
echo
# 生成 AES-256 数据加密密钥
echo -e "${YELLOW}1/2: 生成 AES-256 数据加密密钥...${NC}"
DATA_KEY=$(openssl rand -base64 32)
if [ $? -eq 0 ]; then
echo -e "${GREEN} ✓ 数据加密密钥生成成功${NC}"
else
echo -e "${RED} ❌ 数据加密密钥生成失败${NC}"
exit 1
fi
# 生成 JWT 认证密钥
echo -e "${YELLOW}2/2: 生成 JWT 认证密钥...${NC}"
JWT_KEY=$(openssl rand -base64 64)
if [ $? -eq 0 ]; then
echo -e "${GREEN} ✓ JWT认证密钥生成成功${NC}"
else
echo -e "${RED} ❌ JWT认证密钥生成失败${NC}"
exit 1
fi
# 显示密钥
echo
echo -e "${GREEN}🎉 安全密钥生成完成!${NC}"
echo
echo -e "${BLUE}📋 生成的密钥:${NC}"
echo -e "${PURPLE}1. 数据加密密钥 (AES-256):${NC}"
echo -e "${YELLOW}$DATA_KEY${NC}"
echo
echo -e "${PURPLE}2. JWT认证密钥 (512-bit):${NC}"
echo -e "${YELLOW}$JWT_KEY${NC}"
echo
# 显示使用方法
echo -e "${YELLOW}📋 使用方法:${NC}"
echo
echo -e "${BLUE}1. 环境变量设置:${NC}"
echo -e " export DATA_ENCRYPTION_KEY=\"$DATA_KEY\""
echo -e " export JWT_SECRET=\"$JWT_KEY\""
echo
echo -e "${BLUE}2. .env 文件设置:${NC}"
echo -e " DATA_ENCRYPTION_KEY=$DATA_KEY"
echo -e " JWT_SECRET=$JWT_KEY"
echo
echo -e "${BLUE}3. Docker环境设置:${NC}"
echo -e " docker run -e DATA_ENCRYPTION_KEY=\"$DATA_KEY\" -e JWT_SECRET=\"$JWT_KEY\" ..."
echo
echo -e "${BLUE}4. Kubernetes Secret:${NC}"
echo -e " kubectl create secret generic mars-crypto-key \\"
echo -e " --from-literal=DATA_ENCRYPTION_KEY=\"$DATA_KEY\" \\"
echo -e " --from-literal=JWT_SECRET=\"$JWT_KEY\""
echo
# 显示密钥特性
echo -e "${BLUE}🔍 密钥特性:${NC}"
echo -e " • 数据加密: ${YELLOW}AES-256-GCM (256 bits)${NC}"
echo -e " • JWT认证: ${YELLOW}HS256 (512 bits)${NC}"
echo -e " • 格式: ${YELLOW}Base64 编码${NC}"
echo -e " • 用途: ${YELLOW}数据库加密 + 用户认证${NC}"
# 安全提醒
echo
echo -e "${RED}⚠️ 安全提醒:${NC}"
echo -e " • 请妥善保管此密钥，丢失后无法恢复加密的数据"
echo -e " • 不要将密钥提交到版本控制系统"
echo -e " • 建议在不同环境使用不同的密钥"
echo -e " • 定期更换密钥并重新加密数据"
echo -e " • 在生产环境中，建议使用密钥管理服务"
echo
echo -e "${GREEN}✅ 数据加密密钥生成完成!${NC}"
# 可选：保存到 .env 文件
echo
read -p "是否将密钥保存到 .env 文件? [y/N]: " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
if [ -f ".env" ]; then
# 检查是否已存在 DATA_ENCRYPTION_KEY
if grep -q "^DATA_ENCRYPTION_KEY=" .env; then
echo -e "${YELLOW}⚠️ .env 文件中已存在 DATA_ENCRYPTION_KEY${NC}"
read -p "是否覆盖现有密钥? [y/N]: " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
# 替换现有密钥
if [[ "$OSTYPE" == "darwin"* ]]; then
# macOS
sed -i '' "s/^DATA_ENCRYPTION_KEY=.*/DATA_ENCRYPTION_KEY=$RAW_KEY/" .env
else
# Linux
sed -i "s/^DATA_ENCRYPTION_KEY=.*/DATA_ENCRYPTION_KEY=$RAW_KEY/" .env
fi
echo -e "${GREEN}✓ .env 文件中的密钥已更新${NC}"
else
echo -e "${BLUE}ℹ️ 保持现有密钥不变${NC}"
fi
else
# 追加新密钥
echo "DATA_ENCRYPTION_KEY=$RAW_KEY" >> .env
echo -e "${GREEN}✓ 密钥已保存到 .env 文件${NC}"
fi
else
# 创建新的 .env 文件
echo "DATA_ENCRYPTION_KEY=$RAW_KEY" > .env
echo -e "${GREEN}✓ 密钥已保存到 .env 文件${NC}"
fi
fi

149
scripts/generate_rsa_keys.sh Executable file
View File

@@ -0,0 +1,149 @@
#!/bin/bash
# RSA密钥对生成脚本 - 用于Mars AI交易系统加密服务
# 生成用于混合加密的RSA-2048密钥对
set -e # 遇到错误立即退出
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
NC='\033[0m' # No Color
# 配置
RSA_KEY_SIZE=2048
SECRETS_DIR="secrets"
PRIVATE_KEY_FILE="$SECRETS_DIR/rsa_key"
PUBLIC_KEY_FILE="$SECRETS_DIR/rsa_key.pub"
echo -e "${BLUE}╔══════════════════════════════════════════════════════════════════╗${NC}"
echo -e "${BLUE}║ Mars AI交易系统 RSA密钥生成器 ║${NC}"
echo -e "${BLUE}║ RSA-2048 混合加密密钥对 ║${NC}"
echo -e "${BLUE}╚══════════════════════════════════════════════════════════════════╝${NC}"
echo
# 检查是否安装了 OpenSSL
if ! command -v openssl &> /dev/null; then
echo -e "${RED}❌ 错误: 系统中未安装 OpenSSL${NC}"
echo -e "请安装 OpenSSL:"
echo -e " macOS: ${YELLOW}brew install openssl${NC}"
echo -e " Ubuntu/Debian: ${YELLOW}sudo apt-get install openssl${NC}"
echo -e " CentOS/RHEL: ${YELLOW}sudo yum install openssl${NC}"
exit 1
fi
echo -e "${GREEN}✓ OpenSSL 已安装: $(openssl version)${NC}"
# 创建 secrets 目录
if [ ! -d "$SECRETS_DIR" ]; then
echo -e "${YELLOW}📁 创建 $SECRETS_DIR 目录...${NC}"
mkdir -p "$SECRETS_DIR"
chmod 700 "$SECRETS_DIR"
echo -e "${GREEN}✓ 目录创建成功${NC}"
else
echo -e "${GREEN}✓ $SECRETS_DIR 目录已存在${NC}"
fi
# 检查现有密钥
if [ -f "$PRIVATE_KEY_FILE" ] || [ -f "$PUBLIC_KEY_FILE" ]; then
echo
echo -e "${YELLOW}⚠️ 检测到现有的RSA密钥文件:${NC}"
[ -f "$PRIVATE_KEY_FILE" ] && echo -e " • $PRIVATE_KEY_FILE"
[ -f "$PUBLIC_KEY_FILE" ] && echo -e " • $PUBLIC_KEY_FILE"
echo
read -p "是否覆盖现有密钥? [y/N]: " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
echo -e "${BLUE}ℹ️ 操作已取消${NC}"
exit 0
fi
echo -e "${YELLOW}🗑️ 删除现有密钥文件...${NC}"
rm -f "$PRIVATE_KEY_FILE" "$PUBLIC_KEY_FILE"
fi
echo
echo -e "${BLUE}🔐 开始生成 RSA-$RSA_KEY_SIZE 密钥对...${NC}"
# 生成私钥
echo -e "${YELLOW}📝 步骤 1/3: 生成 RSA 私钥 ($RSA_KEY_SIZE bits)...${NC}"
if openssl genrsa -out "$PRIVATE_KEY_FILE" $RSA_KEY_SIZE 2>/dev/null; then
echo -e "${GREEN}✓ 私钥生成成功${NC}"
else
echo -e "${RED}❌ 私钥生成失败${NC}"
exit 1
fi
# 设置私钥权限
chmod 600 "$PRIVATE_KEY_FILE"
echo -e "${GREEN}✓ 私钥权限设置为 600${NC}"
# 生成公钥
echo -e "${YELLOW}📝 步骤 2/3: 从私钥提取公钥...${NC}"
if openssl rsa -in "$PRIVATE_KEY_FILE" -pubout -out "$PUBLIC_KEY_FILE" 2>/dev/null; then
echo -e "${GREEN}✓ 公钥生成成功${NC}"
else
echo -e "${RED}❌ 公钥生成失败${NC}"
exit 1
fi
# 设置公钥权限
chmod 644 "$PUBLIC_KEY_FILE"
echo -e "${GREEN}✓ 公钥权限设置为 644${NC}"
# 验证密钥
echo -e "${YELLOW}📝 步骤 3/3: 验证密钥对...${NC}"
if openssl rsa -in "$PRIVATE_KEY_FILE" -check -noout 2>/dev/null; then
echo -e "${GREEN}✓ 私钥验证通过${NC}"
else
echo -e "${RED}❌ 私钥验证失败${NC}"
exit 1
fi
if openssl rsa -in "$PUBLIC_KEY_FILE" -pubin -text -noout &>/dev/null; then
echo -e "${GREEN}✓ 公钥验证通过${NC}"
else
echo -e "${RED}❌ 公钥验证失败${NC}"
exit 1
fi
# 显示密钥信息
echo
echo -e "${GREEN}🎉 RSA密钥对生成成功!${NC}"
echo
echo -e "${BLUE}📋 密钥信息:${NC}"
echo -e " 私钥文件: ${YELLOW}$PRIVATE_KEY_FILE${NC}"
echo -e " 公钥文件: ${YELLOW}$PUBLIC_KEY_FILE${NC}"
echo -e " 密钥大小: ${YELLOW}$RSA_KEY_SIZE bits${NC}"
echo
# 显示文件大小
PRIVATE_SIZE=$(stat -f%z "$PRIVATE_KEY_FILE" 2>/dev/null || stat -c%s "$PRIVATE_KEY_FILE" 2>/dev/null || echo "未知")
PUBLIC_SIZE=$(stat -f%z "$PUBLIC_KEY_FILE" 2>/dev/null || stat -c%s "$PUBLIC_KEY_FILE" 2>/dev/null || echo "未知")
echo -e "${BLUE}📏 文件大小:${NC}"
echo -e " 私钥: ${YELLOW}$PRIVATE_SIZE bytes${NC}"
echo -e " 公钥: ${YELLOW}$PUBLIC_SIZE bytes${NC}"
# 显示公钥内容预览
echo
echo -e "${BLUE}🔍 公钥内容预览:${NC}"
head -n 5 "$PUBLIC_KEY_FILE" | sed 's/^/ /'
echo -e " ${YELLOW}...${NC}"
tail -n 2 "$PUBLIC_KEY_FILE" | sed 's/^/ /'
echo
echo -e "${GREEN}✅ RSA密钥对生成完成!${NC}"
echo
echo -e "${YELLOW}📋 使用说明:${NC}"
echo -e " 1. 私钥文件 ($PRIVATE_KEY_FILE) 用于服务器端解密"
echo -e " 2. 公钥文件 ($PUBLIC_KEY_FILE) 可以分发给客户端用于加密"
echo -e " 3. 确保私钥文件的安全性，不要泄露给第三方"
echo -e " 4. 在生产环境中，建议将私钥存储在安全的密钥管理服务中"
echo
echo -e "${RED}⚠️ 安全提醒:${NC}"
echo -e " • 私钥文件权限已设置为 600 (仅所有者可读写)"
echo -e " • 请定期备份密钥文件"
echo -e " • 建议在不同环境使用不同的密钥对"
echo

200
scripts/migrate_encryption.go Normal file
View File

@@ -0,0 +1,200 @@
package main
import (
"database/sql"
"fmt"
"log"
"os"
"nofx/crypto"
_ "modernc.org/sqlite"
)
func main() {
log.Println("🔄 開始遷移數據庫到加密格式...")
// 1. 檢查數據庫檔案
dbPath := "config.db"
if len(os.Args) > 1 {
dbPath = os.Args[1]
}
if _, err := os.Stat(dbPath); os.IsNotExist(err) {
log.Fatalf("❌ 數據庫檔案不存在: %s", dbPath)
}
// 2. 備份數據庫
backupPath := fmt.Sprintf("%s.pre_encryption_backup", dbPath)
log.Printf("📦 備份數據庫到: %s", backupPath)
input, err := os.ReadFile(dbPath)
if err != nil {
log.Fatalf("❌ 讀取數據庫失敗: %v", err)
}
if err := os.WriteFile(backupPath, input, 0600); err != nil {
log.Fatalf("❌ 備份失敗: %v", err)
}
// 3. 打開數據庫
db, err := sql.Open("sqlite", dbPath)
if err != nil {
log.Fatalf("❌ 打開數據庫失敗: %v", err)
}
defer db.Close()
// 4. 初始化加密管理器
em, err := crypto.GetEncryptionManager()
if err != nil {
log.Fatalf("❌ 初始化加密管理器失敗: %v", err)
}
// 5. 遷移交易所配置
if err := migrateExchanges(db, em); err != nil {
log.Fatalf("❌ 遷移交易所配置失敗: %v", err)
}
// 6. 遷移 AI 模型配置
if err := migrateAIModels(db, em); err != nil {
log.Fatalf("❌ 遷移 AI 模型配置失敗: %v", err)
}
log.Println("✅ 數據遷移完成！")
log.Printf("📝 原始數據備份位於: %s", backupPath)
log.Println("⚠️ 請驗證系統功能正常後，手動刪除備份檔案")
}
// migrateExchanges 遷移交易所配置
func migrateExchanges(db *sql.DB, em *crypto.EncryptionManager) error {
log.Println("🔄 遷移交易所配置...")
// 查詢所有未加密的記錄（假設加密數據都包含 '==' Base64 特徵）
rows, err := db.Query(`
SELECT user_id, id, api_key, secret_key,
COALESCE(hyperliquid_private_key, ''),
COALESCE(aster_private_key, '')
FROM exchanges
WHERE (api_key != '' AND api_key NOT LIKE '%==%')
OR (secret_key != '' AND secret_key NOT LIKE '%==%')
`)
if err != nil {
return err
}
defer rows.Close()
tx, err := db.Begin()
if err != nil {
return err
}
defer tx.Rollback()
count := 0
for rows.Next() {
var userID, exchangeID, apiKey, secretKey, hlPrivateKey, asterPrivateKey string
if err := rows.Scan(&userID, &exchangeID, &apiKey, &secretKey, &hlPrivateKey, &asterPrivateKey); err != nil {
return err
}
// 加密每個字段
encAPIKey, err := em.EncryptForDatabase(apiKey)
if err != nil {
return fmt.Errorf("加密 API Key 失敗: %w", err)
}
encSecretKey, err := em.EncryptForDatabase(secretKey)
if err != nil {
return fmt.Errorf("加密 Secret Key 失敗: %w", err)
}
encHLPrivateKey := ""
if hlPrivateKey != "" {
encHLPrivateKey, err = em.EncryptForDatabase(hlPrivateKey)
if err != nil {
return fmt.Errorf("加密 Hyperliquid Private Key 失敗: %w", err)
}
}
encAsterPrivateKey := ""
if asterPrivateKey != "" {
encAsterPrivateKey, err = em.EncryptForDatabase(asterPrivateKey)
if err != nil {
return fmt.Errorf("加密 Aster Private Key 失敗: %w", err)
}
}
// 更新數據庫
_, err = tx.Exec(`
UPDATE exchanges
SET api_key = ?, secret_key = ?,
hyperliquid_private_key = ?, aster_private_key = ?
WHERE user_id = ? AND id = ?
`, encAPIKey, encSecretKey, encHLPrivateKey, encAsterPrivateKey, userID, exchangeID)
if err != nil {
return fmt.Errorf("更新數據庫失敗: %w", err)
}
log.Printf(" ✓ 已加密: [%s] %s", userID, exchangeID)
count++
}
if err := tx.Commit(); err != nil {
return err
}
log.Printf("✅ 已遷移 %d 個交易所配置", count)
return nil
}
// migrateAIModels 遷移 AI 模型配置
func migrateAIModels(db *sql.DB, em *crypto.EncryptionManager) error {
log.Println("🔄 遷移 AI 模型配置...")
rows, err := db.Query(`
SELECT user_id, id, api_key
FROM ai_models
WHERE api_key != '' AND api_key NOT LIKE '%==%'
`)
if err != nil {
return err
}
defer rows.Close()
tx, err := db.Begin()
if err != nil {
return err
}
defer tx.Rollback()
count := 0
for rows.Next() {
var userID, modelID, apiKey string
if err := rows.Scan(&userID, &modelID, &apiKey); err != nil {
return err
}
encAPIKey, err := em.EncryptForDatabase(apiKey)
if err != nil {
return fmt.Errorf("加密 API Key 失敗: %w", err)
}
_, err = tx.Exec(`
UPDATE ai_models SET api_key = ? WHERE user_id = ? AND id = ?
`, encAPIKey, userID, modelID)
if err != nil {
return fmt.Errorf("更新數據庫失敗: %w", err)
}
log.Printf(" ✓ 已加密: [%s] %s", userID, modelID)
count++
}
if err := tx.Commit(); err != nil {
return err
}
log.Printf("✅ 已遷移 %d 個 AI 模型配置", count)
return nil
}

319
scripts/setup_encryption.sh Executable file
View File

@@ -0,0 +1,319 @@
#!/bin/bash
# Mars AI交易系统加密环境设置脚本
# 一键生成RSA密钥对和数据加密密钥，完整设置加密环境
set -e # 遇到错误立即退出
# 颜色定义
RED='\033[0;31m'
GREEN='\033[0;32m'
YELLOW='\033[1;33m'
BLUE='\033[0;34m'
PURPLE='\033[0;35m'
CYAN='\033[0;36m'
NC='\033[0m' # No Color
# 获取脚本所在目录
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
echo -e "${PURPLE}╔════════════════════════════════════════════════════════════════════════╗${NC}"
echo -e "${PURPLE}║ Mars AI交易系统 ║${NC}"
echo -e "${PURPLE}║ 🔐 加密环境一键设置工具 ║${NC}"
echo -e "${PURPLE}║ ║${NC}"
echo -e "${PURPLE}║ 功能: 生成RSA密钥对 + 数据加密密钥 + 配置环境变量 ║${NC}"
echo -e "${PURPLE}╚════════════════════════════════════════════════════════════════════════╝${NC}"
echo
# 检查依赖
echo -e "${CYAN}🔍 检查系统依赖...${NC}"
# 检查 OpenSSL
if ! command -v openssl &> /dev/null; then
echo -e "${RED}❌ 错误: 系统中未安装 OpenSSL${NC}"
echo -e "请安装 OpenSSL:"
echo -e " macOS: ${YELLOW}brew install openssl${NC}"
echo -e " Ubuntu/Debian: ${YELLOW}sudo apt-get install openssl${NC}"
echo -e " CentOS/RHEL: ${YELLOW}sudo yum install openssl${NC}"
exit 1
fi
echo -e "${GREEN}✓ OpenSSL: $(openssl version)${NC}"
# 进入项目根目录
cd "$PROJECT_ROOT"
echo -e "${GREEN}✓ 工作目录: $(pwd)${NC}"
# 配置参数
RSA_KEY_SIZE=2048
SECRETS_DIR="secrets"
PRIVATE_KEY_FILE="$SECRETS_DIR/rsa_key"
PUBLIC_KEY_FILE="$SECRETS_DIR/rsa_key.pub"
echo
echo -e "${BLUE}📋 配置参数:${NC}"
echo -e " • RSA密钥大小: ${YELLOW}$RSA_KEY_SIZE bits${NC}"
echo -e " • 私钥文件: ${YELLOW}$PRIVATE_KEY_FILE${NC}"
echo -e " • 公钥文件: ${YELLOW}$PUBLIC_KEY_FILE${NC}"
echo -e " • AES密钥: ${YELLOW}256 bits (自动生成)${NC}"
# 询问用户确认
echo
read -p "是否继续设置加密环境? [Y/n]: " -n 1 -r
echo
if [[ $REPLY =~ ^[Nn]$ ]]; then
echo -e "${BLUE}ℹ️ 操作已取消${NC}"
exit 0
fi
echo
echo -e "${CYAN}🚀 开始设置加密环境...${NC}"
# ============= 步骤1: 创建目录 =============
echo
echo -e "${YELLOW}📁 步骤 1/4: 创建必要目录...${NC}"
if [ ! -d "$SECRETS_DIR" ]; then
mkdir -p "$SECRETS_DIR"
chmod 700 "$SECRETS_DIR"
echo -e "${GREEN}✓ 创建 $SECRETS_DIR 目录${NC}"
else
echo -e "${GREEN}✓ $SECRETS_DIR 目录已存在${NC}"
fi
if [ ! -d "scripts" ]; then
mkdir -p "scripts"
echo -e "${GREEN}✓ 创建 scripts 目录${NC}"
else
echo -e "${GREEN}✓ scripts 目录已存在${NC}"
fi
# ============= 步骤2: 生成RSA密钥对 =============
echo
echo -e "${YELLOW}🔐 步骤 2/4: 生成 RSA-$RSA_KEY_SIZE 密钥对...${NC}"
# 检查现有RSA密钥
if [ -f "$PRIVATE_KEY_FILE" ] || [ -f "$PUBLIC_KEY_FILE" ]; then
echo -e "${YELLOW}⚠️ 检测到现有的RSA密钥文件${NC}"
read -p "是否重新生成RSA密钥? [y/N]: " -n 1 -r
echo
if [[ $REPLY =~ ^[Yy]$ ]]; then
rm -f "$PRIVATE_KEY_FILE" "$PUBLIC_KEY_FILE"
echo -e "${YELLOW}🗑️ 删除旧密钥${NC}"
else
echo -e "${BLUE}ℹ️ 保持现有RSA密钥${NC}"
RSA_SKIPPED=true
fi
fi
if [ "$RSA_SKIPPED" != "true" ]; then
# 生成私钥
echo -e " ${CYAN}生成RSA私钥...${NC}"
openssl genrsa -out "$PRIVATE_KEY_FILE" $RSA_KEY_SIZE 2>/dev/null
chmod 600 "$PRIVATE_KEY_FILE"
echo -e "${GREEN} ✓ 私钥生成完成${NC}"
# 生成公钥
echo -e " ${CYAN}提取RSA公钥...${NC}"
openssl rsa -in "$PRIVATE_KEY_FILE" -pubout -out "$PUBLIC_KEY_FILE" 2>/dev/null
chmod 644 "$PUBLIC_KEY_FILE"
echo -e "${GREEN} ✓ 公钥生成完成${NC}"
# 验证密钥
echo -e " ${CYAN}验证密钥对...${NC}"
openssl rsa -in "$PRIVATE_KEY_FILE" -check -noout 2>/dev/null
echo -e "${GREEN} ✓ 密钥验证通过${NC}"
fi
# ============= 步骤3: 生成数据加密密钥和JWT密钥 =============
echo
echo -e "${YELLOW}🔑 步骤 3/4: 生成 AES-256 数据加密密钥和JWT认证密钥...${NC}"
# 检查现有密钥
DATA_KEY_EXISTS=false
JWT_KEY_EXISTS=false
if [ -f ".env" ]; then
if grep -q "^DATA_ENCRYPTION_KEY=" .env; then
DATA_KEY_EXISTS=true
fi
if grep -q "^JWT_SECRET=" .env; then
JWT_KEY_EXISTS=true
fi
fi
if [ "$DATA_KEY_EXISTS" = "true" ] || [ "$JWT_KEY_EXISTS" = "true" ]; then
echo -e "${YELLOW}⚠️ 检测到现有的密钥配置${NC}"
if [ "$DATA_KEY_EXISTS" = "true" ]; then
echo -e " • 数据加密密钥已存在"
fi
if [ "$JWT_KEY_EXISTS" = "true" ]; then
echo -e " • JWT认证密钥已存在"
fi
read -p "是否重新生成所有密钥? [y/N]: " -n 1 -r
echo
if [[ ! $REPLY =~ ^[Yy]$ ]]; then
echo -e "${BLUE}ℹ️ 保持现有密钥${NC}"
KEY_SKIPPED=true
# 读取现有密钥
if [ "$DATA_KEY_EXISTS" = "true" ]; then
DATA_KEY=$(grep "^DATA_ENCRYPTION_KEY=" .env | cut -d'=' -f2)
fi
if [ "$JWT_KEY_EXISTS" = "true" ]; then
JWT_KEY=$(grep "^JWT_SECRET=" .env | cut -d'=' -f2)
fi
fi
fi
if [ "$KEY_SKIPPED" != "true" ]; then
# 生成新的密钥
echo -e " ${CYAN}生成AES-256数据加密密钥...${NC}"
DATA_KEY=$(openssl rand -base64 32)
echo -e "${GREEN} ✓ 数据加密密钥生成完成${NC}"
echo -e " ${CYAN}生成JWT认证密钥...${NC}"
JWT_KEY=$(openssl rand -base64 64)
echo -e "${GREEN} ✓ JWT认证密钥生成完成${NC}"
# 保存到.env文件
if [ -f ".env" ]; then
# 更新现有文件
if grep -q "^DATA_ENCRYPTION_KEY=" .env; then
if [[ "$OSTYPE" == "darwin"* ]]; then
sed -i '' "s/^DATA_ENCRYPTION_KEY=.*/DATA_ENCRYPTION_KEY=$DATA_KEY/" .env
else
sed -i "s/^DATA_ENCRYPTION_KEY=.*/DATA_ENCRYPTION_KEY=$DATA_KEY/" .env
fi
else
echo "DATA_ENCRYPTION_KEY=$DATA_KEY" >> .env
fi
if grep -q "^JWT_SECRET=" .env; then
# 使用替代分隔符避免 / 字符冲突，并用引号保护值
if [[ "$OSTYPE" == "darwin"* ]]; then
sed -i '' "s|^JWT_SECRET=.*|JWT_SECRET=\"$JWT_KEY\"|" .env
else
sed -i "s|^JWT_SECRET=.*|JWT_SECRET=\"$JWT_KEY\"|" .env
fi
else
# 使用引号确保值在同一行
printf "JWT_SECRET=\"%s\"\n" "$JWT_KEY" >> .env
fi
else
# 创建新文件
echo "DATA_ENCRYPTION_KEY=$DATA_KEY" > .env
printf "JWT_SECRET=\"%s\"\n" "$JWT_KEY" >> .env
fi
chmod 600 .env
echo -e "${GREEN} ✓ 密钥已保存到 .env 文件${NC}"
elif [ "$DATA_KEY_EXISTS" != "true" ] || [ "$JWT_KEY_EXISTS" != "true" ]; then
# 生成缺失的密钥
if [ "$DATA_KEY_EXISTS" != "true" ]; then
echo -e " ${CYAN}生成缺失的AES-256数据加密密钥...${NC}"
DATA_KEY=$(openssl rand -base64 32)
echo "DATA_ENCRYPTION_KEY=$DATA_KEY" >> .env
echo -e "${GREEN} ✓ 数据加密密钥生成完成${NC}"
fi
if [ "$JWT_KEY_EXISTS" != "true" ]; then
echo -e " ${CYAN}生成缺失的JWT认证密钥...${NC}"
JWT_KEY=$(openssl rand -base64 64)
printf "JWT_SECRET=\"%s\"\n" "$JWT_KEY" >> .env
echo -e "${GREEN} ✓ JWT认证密钥生成完成${NC}"
fi
chmod 600 .env
echo -e "${GREEN} ✓ 密钥已保存到 .env 文件${NC}"
fi
# ============= 步骤4: 验证和总结 =============
echo
echo -e "${YELLOW}✅ 步骤 4/4: 环境验证和总结...${NC}"
# 验证文件存在性和权限
echo -e " ${CYAN}验证文件和权限...${NC}"
if [ -f "$PRIVATE_KEY_FILE" ]; then
PRIVATE_PERM=$(stat -f "%A" "$PRIVATE_KEY_FILE" 2>/dev/null || stat -c "%a" "$PRIVATE_KEY_FILE" 2>/dev/null)
echo -e "${GREEN} ✓ 私钥文件: $PRIVATE_KEY_FILE (权限: $PRIVATE_PERM)${NC}"
else
echo -e "${RED} ❌ 私钥文件不存在${NC}"
exit 1
fi
if [ -f "$PUBLIC_KEY_FILE" ]; then
PUBLIC_PERM=$(stat -f "%A" "$PUBLIC_KEY_FILE" 2>/dev/null || stat -c "%a" "$PUBLIC_KEY_FILE" 2>/dev/null)
echo -e "${GREEN} ✓ 公钥文件: $PUBLIC_KEY_FILE (权限: $PUBLIC_PERM)${NC}"
else
echo -e "${RED} ❌ 公钥文件不存在${NC}"
exit 1
fi
if [ -f ".env" ] && grep -q "^DATA_ENCRYPTION_KEY=" .env && grep -q "^JWT_SECRET=" .env; then
ENV_PERM=$(stat -f "%A" ".env" 2>/dev/null || stat -c "%a" ".env" 2>/dev/null)
echo -e "${GREEN} ✓ 环境文件: .env (权限: $ENV_PERM)${NC}"
echo -e "${GREEN} 包含: DATA_ENCRYPTION_KEY, JWT_SECRET${NC}"
else
echo -e "${RED} ❌ 环境文件不存在或缺少必要密钥${NC}"
exit 1
fi
# 测试密钥功能
echo -e " ${CYAN}测试密钥功能...${NC}"
TEST_DATA="Hello Mars AI Trading System"
ENCRYPTED=$(echo "$TEST_DATA" | openssl rsautl -encrypt -pubin -inkey "$PUBLIC_KEY_FILE" | base64)
DECRYPTED=$(echo "$ENCRYPTED" | base64 -d | openssl rsautl -decrypt -inkey "$PRIVATE_KEY_FILE")
if [ "$DECRYPTED" = "$TEST_DATA" ]; then
echo -e "${GREEN} ✓ RSA加密/解密测试通过${NC}"
else
echo -e "${RED} ❌ RSA加密/解密测试失败${NC}"
exit 1
fi
# 显示最终结果
echo
echo -e "${GREEN}🎉 加密环境设置完成！${NC}"
echo
echo -e "${PURPLE}╔════════════════════════════════════════════════════════════════════════╗${NC}"
echo -e "${PURPLE}║ 设置完成摘要 ║${NC}"
echo -e "${PURPLE}╠════════════════════════════════════════════════════════════════════════╣${NC}"
echo -e "${PURPLE}║${NC} ${BLUE}RSA密钥对:${NC} ${PURPLE}║${NC}"
echo -e "${PURPLE}║${NC} 私钥: ${YELLOW}$PRIVATE_KEY_FILE${NC} ${PURPLE}║${NC}"
echo -e "${PURPLE}║${NC} 公钥: ${YELLOW}$PUBLIC_KEY_FILE${NC} ${PURPLE}║${NC}"
echo -e "${PURPLE}║${NC} 大小: ${YELLOW}$RSA_KEY_SIZE bits${NC} ${PURPLE}║${NC}"
echo -e "${PURPLE}║${NC} ${PURPLE}║${NC}"
echo -e "${PURPLE}║${NC} ${BLUE}安全密钥配置:${NC} ${PURPLE}║${NC}"
echo -e "${PURPLE}║${NC} 文件: ${YELLOW}.env${NC} ${PURPLE}║${NC}"
echo -e "${PURPLE}║${NC} 数据加密: ${YELLOW}DATA_ENCRYPTION_KEY (AES-256-GCM)${NC} ${PURPLE}║${NC}"
echo -e "${PURPLE}║${NC} JWT认证: ${YELLOW}JWT_SECRET (HS256)${NC} ${PURPLE}║${NC}"
echo -e "${PURPLE}╚════════════════════════════════════════════════════════════════════════╝${NC}"
# 使用指南
echo
echo -e "${BLUE}📋 使用指南:${NC}"
echo
echo -e "${YELLOW}1. 启动Mars AI交易系统:${NC}"
echo -e " source .env && ./mars"
echo
echo -e "${YELLOW}2. Docker部署:${NC}"
echo -e " docker run --env-file .env mars-ai-trading"
echo
echo -e "${YELLOW}3. 查看公钥内容:${NC}"
echo -e " cat $PUBLIC_KEY_FILE"
echo
echo -e "${YELLOW}4. 测试加密API:${NC}"
echo -e " curl http://localhost:8080/api/crypto/public-key"
# 安全提醒
echo
echo -e "${RED}🔒 安全提醒:${NC}"
echo -e " • 私钥文件 ($PRIVATE_KEY_FILE) 权限已设置为 600"
echo -e " • 环境文件 (.env) 权限已设置为 600"
echo -e " • 请勿将私钥和数据密钥提交到版本控制系统"
echo -e " • 建议在生产环境中使用密钥管理服务"
echo -e " • 定期备份密钥文件"
echo
echo -e "${GREEN}✅ Mars AI交易系统加密环境设置完成！${NC}"

185
scripts/start.sh
View File

@@ -2,16 +2,11 @@
# ═══════════════════════════════════════════════════════════════
# NOFX AI Trading System - Docker Quick Start Script
# Usage: ./scripts/start.sh [command]
# Usage: ./start.sh [command]
# ═══════════════════════════════════════════════════════════════
set -e
# Ensure we operate from repo root regardless of invocation location
SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
ROOT_DIR="$(cd "$SCRIPT_DIR/.." && pwd)"
cd "$ROOT_DIR"
# ------------------------------------------------------------------------
# Color Definitions
# ------------------------------------------------------------------------
@@ -81,6 +76,89 @@ check_env() {
print_success "环境变量文件存在"
}
# ------------------------------------------------------------------------
# Validation: Encryption Environment (RSA Keys + Data Encryption Key)
# ------------------------------------------------------------------------
check_encryption() {
local need_setup=false
print_info "检查加密环境..."
# 检查RSA密钥对
if [ ! -f "secrets/rsa_key" ] || [ ! -f "secrets/rsa_key.pub" ]; then
print_warning "RSA密钥对不存在"
need_setup=true
fi
# 检查数据加密密钥
if [ ! -f ".env" ] || ! grep -q "^DATA_ENCRYPTION_KEY=" .env; then
print_warning "数据加密密钥未配置"
need_setup=true
fi
# 检查JWT认证密钥
if [ ! -f ".env" ] || ! grep -q "^JWT_SECRET=" .env; then
print_warning "JWT认证密钥未配置"
need_setup=true
fi
# 如果需要设置加密环境，直接自动设置
if [ "$need_setup" = "true" ]; then
print_info "🔐 检测到加密环境未配置，正在自动设置..."
print_info "加密环境用于保护敏感数据（API密钥、私钥等）"
echo ""
# 检查加密设置脚本是否存在
if [ -f "scripts/setup_encryption.sh" ]; then
print_info "加密系统将保护: API密钥、私钥、Hyperliquid代理钱包"
echo ""
# 自动运行加密设置脚本
echo -e "Y\nn\nn" | bash scripts/setup_encryption.sh
if [ $? -eq 0 ]; then
echo ""
print_success "🔐 加密环境设置完成！"
print_info " • RSA-2048密钥对已生成"
print_info " • AES-256数据加密密钥已配置"
print_info " • JWT认证密钥已配置"
print_info " • 所有敏感数据现在都受加密保护"
echo ""
else
print_error "加密环境设置失败"
exit 1
fi
else
print_error "加密设置脚本不存在: scripts/setup_encryption.sh"
print_info "请手动运行: ./scripts/setup_encryption.sh"
exit 1
fi
else
print_success "🔐 加密环境已配置"
print_info " • RSA密钥对: secrets/rsa_key + secrets/rsa_key.pub"
print_info " • 数据加密密钥: .env (DATA_ENCRYPTION_KEY)"
print_info " • JWT认证密钥: .env (JWT_SECRET)"
print_info " • 加密算法: RSA-OAEP-2048 + AES-256-GCM + HS256"
print_info " • 保护数据: API密钥、私钥、Hyperliquid代理钱包、用户认证"
# 验证密钥文件权限
if [ -f "secrets/rsa_key" ]; then
local perm=$(stat -f "%A" "secrets/rsa_key" 2>/dev/null || stat -c "%a" "secrets/rsa_key" 2>/dev/null)
if [ "$perm" != "600" ]; then
print_warning "修复RSA私钥权限..."
chmod 600 secrets/rsa_key
fi
fi
if [ -f ".env" ]; then
local perm=$(stat -f "%A" ".env" 2>/dev/null || stat -c "%a" ".env" 2>/dev/null)
if [ "$perm" != "600" ]; then
print_warning "修复环境文件权限..."
chmod 600 .env
fi
fi
fi
}
# ------------------------------------------------------------------------
# Validation: Configuration File (config.json) - BASIC SETTINGS ONLY
# ------------------------------------------------------------------------
@@ -89,12 +167,34 @@ check_config() {
print_warning "config.json 不存在，从模板复制..."
cp config.json.example config.json
print_info "✓ 已使用默认配置创建 config.json"
print_info "💡 如需修改基础设置（杠杆大小、开仓币种、JWT密钥等），可编辑 config.json"
print_info "💡 如需修改基础设置（杠杆大小、开仓币种、管理员模式、JWT密钥等），可编辑 config.json"
print_info "💡 模型/交易所/交易员配置请使用Web界面"
fi
print_success "配置文件存在"
}
# ------------------------------------------------------------------------
# Validation: Beta Code File (beta_codes.txt)
# ------------------------------------------------------------------------
check_beta_codes_file() {
local beta_file="beta_codes.txt"
if [ -d "$beta_file" ]; then
print_warning "beta_codes.txt 是目录，正在删除后重建文件..."
rm -rf "$beta_file"
touch "$beta_file"
chmod 600 "$beta_file"
print_info "✓ 已重新创建 beta_codes.txt（权限: 600）"
elif [ ! -f "$beta_file" ]; then
print_warning "beta_codes.txt 不存在，正在创建空文件..."
touch "$beta_file"
chmod 600 "$beta_file"
print_info "✓ 已创建空的内测码文件（权限: 600）"
else
print_success "内测码文件存在"
fi
}
# ------------------------------------------------------------------------
# Utility: Read Environment Variables
# ------------------------------------------------------------------------
@@ -118,6 +218,29 @@ read_env_vars() {
fi
}
# ------------------------------------------------------------------------
# Validation: Database File (config.db)
# ------------------------------------------------------------------------
check_database() {
if [ -d "config.db" ]; then
# 如果存在的是目录，删除它
print_warning "config.db 是目录而非文件，正在删除目录..."
rm -rf config.db
print_info "✓ 已删除目录，现在创建文件..."
install -m 600 /dev/null config.db
print_success "✓ 已创建空数据库文件（权限: 600），系统将在启动时初始化"
elif [ ! -f "config.db" ]; then
# 如果不存在文件，创建它
print_warning "数据库文件不存在，创建空数据库文件..."
# 创建空文件以避免Docker创建目录（使用安全权限600）
install -m 600 /dev/null config.db
print_info "✓ 已创建空数据库文件（权限: 600），系统将在启动时初始化"
else
# 文件存在
print_success "数据库文件存在"
fi
}
# ------------------------------------------------------------------------
# Build: Frontend (Node.js Based)
# ------------------------------------------------------------------------
@@ -156,10 +279,15 @@ start() {
# 读取环境变量
read_env_vars
# 确保必要的目录存在
# 确保必要的文件和目录存在（修复 Docker volume 挂载问题）
if [ ! -f "config.db" ]; then
print_info "创建数据库文件..."
touch config.db
install -m 600 /dev/null config.db
fi
if [ ! -d "decision_logs" ]; then
print_info "创建日志目录..."
mkdir -p decision_logs
install -m 700 -d decision_logs
fi
# Auto-build frontend if missing or forced
@@ -180,8 +308,8 @@ start() {
print_info "Web 界面: http://localhost:${NOFX_FRONTEND_PORT}"
print_info "API 端点: http://localhost:${NOFX_BACKEND_PORT}"
print_info ""
print_info "查看日志: ./scripts/start.sh logs"
print_info "停止服务: ./scripts/start.sh stop"
print_info "查看日志: ./start.sh logs"
print_info "停止服务: ./start.sh stop"
}
# ------------------------------------------------------------------------
@@ -252,13 +380,28 @@ update() {
print_success "更新完成"
}
# ------------------------------------------------------------------------
# Encryption: Manual Setup
# ------------------------------------------------------------------------
setup_encryption_manual() {
print_info "🔐 手动设置加密环境"
if [ -f "scripts/setup_encryption.sh" ]; then
bash scripts/setup_encryption.sh
else
print_error "加密设置脚本不存在: scripts/setup_encryption.sh"
print_info "请确保项目文件完整"
exit 1
fi
}
# ------------------------------------------------------------------------
# Help: Usage Information
# ------------------------------------------------------------------------
show_help() {
echo "NOFX AI Trading System - Docker 管理脚本"
echo ""
echo "用法: ./scripts/start.sh [command] [options]"
echo "用法: ./start.sh [command] [options]"
echo ""
echo "命令:"
echo " start [--build] 启动服务（可选：重新构建）"
@@ -268,12 +411,18 @@ show_help() {
echo " status 查看服务状态"
echo " clean 清理所有容器和数据"
echo " update 更新代码并重启"
echo " setup-encryption 设置加密环境（RSA密钥+数据加密）"
echo " help 显示此帮助信息"
echo ""
echo "示例:"
echo " ./scripts/start.sh start --build # 构建并启动"
echo " ./scripts/start.sh logs backend # 查看后端日志"
echo " ./scripts/start.sh status # 查看状态"
echo " ./start.sh start --build # 构建并启动"
echo " ./start.sh logs backend # 查看后端日志"
echo " ./start.sh status # 查看状态"
echo " ./start.sh setup-encryption # 手动设置加密环境"
echo ""
echo "🔐 关于加密:"
echo " 系统自动检测加密环境，首次运行时会自动设置"
echo " 手动设置: ./scripts/setup_encryption.sh"
}
# ------------------------------------------------------------------------
@@ -285,7 +434,10 @@ main() {
case "${1:-start}" in
start)
check_env
check_encryption
check_config
check_beta_codes_file
check_database
start "$2"
;;
stop)
@@ -306,6 +458,9 @@ main() {
update)
update
;;
setup-encryption)
setup_encryption_manual
;;
help|--help|-h)
show_help
;;

145
trader/aster_trader.go
View File

@@ -13,6 +13,7 @@ import (
"math/big"
"net/http"
"net/url"
"nofx/hook"
"sort"
"strconv"
"strings"
@@ -56,6 +57,18 @@ func NewAsterTrader(user, signer, privateKeyHex string) (*AsterTrader, error) {
if err != nil {
return nil, fmt.Errorf("解析私钥失败: %w", err)
}
client := &http.Client{
Timeout: 30 * time.Second, // 增加到30秒
Transport: &http.Transport{
TLSHandshakeTimeout: 10 * time.Second,
ResponseHeaderTimeout: 10 * time.Second,
IdleConnTimeout: 90 * time.Second,
},
}
res := hook.HookExec[hook.NewAsterTraderResult](hook.NEW_ASTER_TRADER, user, client)
if res != nil && res.Error() == nil {
client = res.GetResult()
}
return &AsterTrader{
ctx: context.Background(),
@@ -63,15 +76,8 @@ func NewAsterTrader(user, signer, privateKeyHex string) (*AsterTrader, error) {
signer: signer,
privateKey: privKey,
symbolPrecision: make(map[string]SymbolPrecision),
client: &http.Client{
Timeout: 30 * time.Second, // 增加到30秒
Transport: &http.Transport{
TLSHandshakeTimeout: 10 * time.Second,
ResponseHeaderTimeout: 10 * time.Second,
IdleConnTimeout: 90 * time.Second,
},
},
baseURL: "https://fapi.asterdex.com",
client: client,
baseURL: "https://fapi.asterdex.com",
}, nil
}
@@ -438,55 +444,78 @@ func (t *AsterTrader) GetBalance() (map[string]interface{}, error) {
return nil, err
}
// 🔍 调试：打印原始API响应
log.Printf("🔍 Aster API原始响应: %s", string(body))
// 查找USDT余额
totalBalance := 0.0
availableBalance := 0.0
crossUnPnl := 0.0
crossWalletBalance := 0.0
foundUSDT := false
for _, bal := range balances {
// 🔍 调试：打印每条余额记录
log.Printf("🔍 余额记录: %+v", bal)
if asset, ok := bal["asset"].(string); ok && asset == "USDT" {
// 🔍 调试：打印USDT余额详情
log.Printf("🔍 USDT余额详情: balance=%v, availableBalance=%v, crossUnPnl=%v",
bal["balance"], bal["availableBalance"], bal["crossUnPnl"])
foundUSDT = true
if wb, ok := bal["balance"].(string); ok {
totalBalance, _ = strconv.ParseFloat(wb, 64)
}
// 解析Aster字段（参考: https://github.com/asterdex/api-docs）
if avail, ok := bal["availableBalance"].(string); ok {
availableBalance, _ = strconv.ParseFloat(avail, 64)
}
if unpnl, ok := bal["crossUnPnl"].(string); ok {
crossUnPnl, _ = strconv.ParseFloat(unpnl, 64)
}
if cwb, ok := bal["crossWalletBalance"].(string); ok {
crossWalletBalance, _ = strconv.ParseFloat(cwb, 64)
}
break
}
}
// ✅ Aster API完全兼容Binance API格式
// balance字段 = wallet balance（不包含未实现盈亏）
// crossUnPnl = unrealized profit（未实现盈亏）
// crossWalletBalance = balance + crossUnPnl（全仓钱包余额，包含盈亏）
//
// 参考Binance官方文档：
// - Account Information V2: marginBalance = walletBalance + unrealizedProfit
// - Balance V3: crossWalletBalance = balance + crossUnPnl
if !foundUSDT {
log.Printf("⚠️ 未找到USDT资产记录！")
}
log.Printf("✓ Aster API返回: 钱包余额=%.2f, 未实现盈亏=%.2f, 可用余额=%.2f",
totalBalance,
crossUnPnl,
availableBalance)
// 获取持仓计算保证金占用和真实未实现盈亏
positions, err := t.GetPositions()
if err != nil {
log.Printf("⚠️ 获取持仓信息失败: %v", err)
// fallback: 无法获取持仓时使用简单计算
return map[string]interface{}{
"totalWalletBalance": crossWalletBalance,
"availableBalance": availableBalance,
"totalUnrealizedProfit": crossUnPnl,
}, nil
}
// ⚠️ 关键修复：从持仓中累加真正的未实现盈亏
// Aster 的 crossUnPnl 字段不准确，需要从持仓数据中重新计算
totalMarginUsed := 0.0
realUnrealizedPnl := 0.0
for _, pos := range positions {
markPrice := pos["markPrice"].(float64)
quantity := pos["positionAmt"].(float64)
if quantity < 0 {
quantity = -quantity
}
unrealizedPnl := pos["unRealizedProfit"].(float64)
realUnrealizedPnl += unrealizedPnl
leverage := 10
if lev, ok := pos["leverage"].(float64); ok {
leverage = int(lev)
}
marginUsed := (quantity * markPrice) / float64(leverage)
totalMarginUsed += marginUsed
}
// ✅ Aster 正确计算方式:
// 总净值 = 可用余额 + 保证金占用
// 钱包余额 = 总净值 - 未实现盈亏
// 未实现盈亏 = 从持仓累加计算（不使用API的crossUnPnl）
totalEquity := availableBalance + totalMarginUsed
totalWalletBalance := totalEquity - realUnrealizedPnl
// 返回与Binance相同的字段名，确保AutoTrader能正确解析
return map[string]interface{}{
"totalWalletBalance": totalBalance, // 钱包余额（不含未实现盈亏）
"availableBalance": availableBalance,
"totalUnrealizedProfit": crossUnPnl, // 未实现盈亏
"totalWalletBalance": totalWalletBalance, // 钱包余额（不含未实现盈亏）
"availableBalance": availableBalance, // 可用余额
"totalUnrealizedProfit": realUnrealizedPnl, // 未实现盈亏（从持仓累加）
}, nil
}
@@ -1010,8 +1039,6 @@ func (t *AsterTrader) SetTakeProfit(symbol string, positionSide string, quantity
return err
}
// CancelStopLossOrders 仅取消止损单（不影响止盈单）
func (t *AsterTrader) CancelStopLossOrders(symbol string) error {
// 获取该币种的所有未完成订单
@@ -1029,14 +1056,16 @@ func (t *AsterTrader) CancelStopLossOrders(symbol string) error {
return fmt.Errorf("解析订单数据失败: %w", err)
}
// 过滤出止损单并取消
// 过滤出止损单并取消（取消所有方向的止损单，包括LONG和SHORT）
canceledCount := 0
var cancelErrors []error
for _, order := range orders {
orderType, _ := order["type"].(string)
// 只取消止损订单（不取消止盈订单）
if orderType == "STOP_MARKET" || orderType == "STOP" {
orderID, _ := order["orderId"].(float64)
positionSide, _ := order["positionSide"].(string)
cancelParams := map[string]interface{}{
"symbol": symbol,
"orderId": int64(orderID),
@@ -1044,21 +1073,28 @@ func (t *AsterTrader) CancelStopLossOrders(symbol string) error {
_, err := t.request("DELETE", "/fapi/v1/order", cancelParams)
if err != nil {
log.Printf(" ⚠ 取消止损单 %d 失败: %v", int64(orderID), err)
errMsg := fmt.Sprintf("订单ID %d: %v", int64(orderID), err)
cancelErrors = append(cancelErrors, fmt.Errorf("%s", errMsg))
log.Printf(" ⚠ 取消止损单失败: %s", errMsg)
continue
}
canceledCount++
log.Printf(" ✓ 已取消止损单 (订单ID: %d, 类型: %s)", int64(orderID), orderType)
log.Printf(" ✓ 已取消止损单 (订单ID: %d, 类型: %s, 方向: %s)", int64(orderID), orderType, positionSide)
}
}
if canceledCount == 0 {
if canceledCount == 0 && len(cancelErrors) == 0 {
log.Printf(" ℹ %s 没有止损单需要取消", symbol)
} else {
} else if canceledCount > 0 {
log.Printf(" ✓ 已取消 %s 的 %d 个止损单", symbol, canceledCount)
}
// 如果所有取消都失败了，返回错误
if len(cancelErrors) > 0 && canceledCount == 0 {
return fmt.Errorf("取消止损单失败: %v", cancelErrors)
}
return nil
}
@@ -1079,14 +1115,16 @@ func (t *AsterTrader) CancelTakeProfitOrders(symbol string) error {
return fmt.Errorf("解析订单数据失败: %w", err)
}
// 过滤出止盈单并取消
// 过滤出止盈单并取消（取消所有方向的止盈单，包括LONG和SHORT）
canceledCount := 0
var cancelErrors []error
for _, order := range orders {
orderType, _ := order["type"].(string)
// 只取消止盈订单（不取消止损订单）
if orderType == "TAKE_PROFIT_MARKET" || orderType == "TAKE_PROFIT" {
orderID, _ := order["orderId"].(float64)
positionSide, _ := order["positionSide"].(string)
cancelParams := map[string]interface{}{
"symbol": symbol,
"orderId": int64(orderID),
@@ -1094,21 +1132,28 @@ func (t *AsterTrader) CancelTakeProfitOrders(symbol string) error {
_, err := t.request("DELETE", "/fapi/v1/order", cancelParams)
if err != nil {
log.Printf(" ⚠ 取消止盈单 %d 失败: %v", int64(orderID), err)
errMsg := fmt.Sprintf("订单ID %d: %v", int64(orderID), err)
cancelErrors = append(cancelErrors, fmt.Errorf("%s", errMsg))
log.Printf(" ⚠ 取消止盈单失败: %s", errMsg)
continue
}
canceledCount++
log.Printf(" ✓ 已取消止盈单 (订单ID: %d, 类型: %s)", int64(orderID), orderType)
log.Printf(" ✓ 已取消止盈单 (订单ID: %d, 类型: %s, 方向: %s)", int64(orderID), orderType, positionSide)
}
}
if canceledCount == 0 {
if canceledCount == 0 && len(cancelErrors) == 0 {
log.Printf(" ℹ %s 没有止盈单需要取消", symbol)
} else {
} else if canceledCount > 0 {
log.Printf(" ✓ 已取消 %s 的 %d 个止盈单", symbol, canceledCount)
}
// 如果所有取消都失败了，返回错误
if len(cancelErrors) > 0 && canceledCount == 0 {
return fmt.Errorf("取消止盈单失败: %v", cancelErrors)
}
return nil
}

299
trader/aster_trader_test.go Normal file
View File

@@ -0,0 +1,299 @@
package trader
import (
"context"
"encoding/json"
"io"
"net/http"
"net/http/httptest"
"testing"
"github.com/ethereum/go-ethereum/crypto"
"github.com/stretchr/testify/assert"
)
// ============================================================
// 一、AsterTraderTestSuite - 继承 base test suite
// ============================================================
// AsterTraderTestSuite Aster交易器测试套件
// 继承 TraderTestSuite 并添加 Aster 特定的 mock 逻辑
type AsterTraderTestSuite struct {
*TraderTestSuite // 嵌入基础测试套件
mockServer *httptest.Server
}
// NewAsterTraderTestSuite 创建 Aster 测试套件
func NewAsterTraderTestSuite(t *testing.T) *AsterTraderTestSuite {
// 创建 mock HTTP 服务器
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// 根据不同的 URL 路径返回不同的 mock 响应
path := r.URL.Path
var respBody interface{}
switch {
// Mock GetBalance - /fapi/v3/balance (返回数组)
case path == "/fapi/v3/balance":
respBody = []map[string]interface{}{
{
"asset": "USDT",
"walletBalance": "10000.00",
"unrealizedProfit": "100.50",
"marginBalance": "10100.50",
"maintMargin": "200.00",
"initialMargin": "2000.00",
"maxWithdrawAmount": "8000.00",
"crossWalletBalance": "10000.00",
"crossUnPnl": "100.50",
"availableBalance": "8000.00",
},
}
// Mock GetPositions - /fapi/v3/positionRisk
case path == "/fapi/v3/positionRisk":
respBody = []map[string]interface{}{
{
"symbol": "BTCUSDT",
"positionAmt": "0.5",
"entryPrice": "50000.00",
"markPrice": "50500.00",
"unRealizedProfit": "250.00",
"liquidationPrice": "45000.00",
"leverage": "10",
"positionSide": "LONG",
},
}
// Mock GetMarketPrice - /fapi/v3/ticker/price (返回单个对象)
case path == "/fapi/v3/ticker/price":
// 从查询参数获取symbol
symbol := r.URL.Query().Get("symbol")
if symbol == "" {
symbol = "BTCUSDT"
}
// 根据symbol返回不同价格
price := "50000.00"
if symbol == "ETHUSDT" {
price = "3000.00"
} else if symbol == "INVALIDUSDT" {
// 返回错误响应
w.WriteHeader(http.StatusBadRequest)
json.NewEncoder(w).Encode(map[string]interface{}{
"code": -1121,
"msg": "Invalid symbol",
})
return
}
respBody = map[string]interface{}{
"symbol": symbol,
"price": price,
}
// Mock ExchangeInfo - /fapi/v3/exchangeInfo
case path == "/fapi/v3/exchangeInfo":
respBody = map[string]interface{}{
"symbols": []map[string]interface{}{
{
"symbol": "BTCUSDT",
"pricePrecision": 1,
"quantityPrecision": 3,
"baseAssetPrecision": 8,
"quotePrecision": 8,
"filters": []map[string]interface{}{
{
"filterType": "PRICE_FILTER",
"tickSize": "0.1",
},
{
"filterType": "LOT_SIZE",
"stepSize": "0.001",
},
},
},
{
"symbol": "ETHUSDT",
"pricePrecision": 2,
"quantityPrecision": 3,
"baseAssetPrecision": 8,
"quotePrecision": 8,
"filters": []map[string]interface{}{
{
"filterType": "PRICE_FILTER",
"tickSize": "0.01",
},
{
"filterType": "LOT_SIZE",
"stepSize": "0.001",
},
},
},
},
}
// Mock CreateOrder - /fapi/v1/order and /fapi/v3/order
case (path == "/fapi/v1/order" || path == "/fapi/v3/order") && r.Method == "POST":
// 从请求中解析参数以确定symbol
bodyBytes, _ := io.ReadAll(r.Body)
var orderParams map[string]interface{}
json.Unmarshal(bodyBytes, &orderParams)
symbol := "BTCUSDT"
if s, ok := orderParams["symbol"].(string); ok {
symbol = s
}
respBody = map[string]interface{}{
"orderId": 123456,
"symbol": symbol,
"status": "FILLED",
"side": orderParams["side"],
"type": orderParams["type"],
}
// Mock CancelOrder - /fapi/v1/order (DELETE)
case path == "/fapi/v1/order" && r.Method == "DELETE":
respBody = map[string]interface{}{
"orderId": 123456,
"symbol": "BTCUSDT",
"status": "CANCELED",
}
// Mock ListOpenOrders - /fapi/v1/openOrders and /fapi/v3/openOrders
case path == "/fapi/v1/openOrders" || path == "/fapi/v3/openOrders":
respBody = []map[string]interface{}{}
// Mock SetLeverage - /fapi/v1/leverage
case path == "/fapi/v1/leverage":
respBody = map[string]interface{}{
"leverage": 10,
"symbol": "BTCUSDT",
}
// Mock SetMarginMode - /fapi/v1/marginType
case path == "/fapi/v1/marginType":
respBody = map[string]interface{}{
"code": 200,
"msg": "success",
}
// Default: empty response
default:
respBody = map[string]interface{}{}
}
// 序列化响应
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(respBody)
}))
// 生成一个测试用的私钥
privateKey, _ := crypto.GenerateKey()
// 创建 mock trader，使用 mock server 的 URL
trader := &AsterTrader{
ctx: context.Background(),
user: "0x1234567890123456789012345678901234567890",
signer: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
privateKey: privateKey,
client: mockServer.Client(),
baseURL: mockServer.URL, // 使用 mock server 的 URL
symbolPrecision: make(map[string]SymbolPrecision),
}
// 创建基础套件
baseSuite := NewTraderTestSuite(t, trader)
return &AsterTraderTestSuite{
TraderTestSuite: baseSuite,
mockServer: mockServer,
}
}
// Cleanup 清理资源
func (s *AsterTraderTestSuite) Cleanup() {
if s.mockServer != nil {
s.mockServer.Close()
}
s.TraderTestSuite.Cleanup()
}
// ============================================================
// 二、使用 AsterTraderTestSuite 运行通用测试
// ============================================================
// TestAsterTrader_InterfaceCompliance 测试接口兼容性
func TestAsterTrader_InterfaceCompliance(t *testing.T) {
var _ Trader = (*AsterTrader)(nil)
}
// TestAsterTrader_CommonInterface 使用测试套件运行所有通用接口测试
func TestAsterTrader_CommonInterface(t *testing.T) {
// 创建测试套件
suite := NewAsterTraderTestSuite(t)
defer suite.Cleanup()
// 运行所有通用接口测试
suite.RunAllTests()
}
// ============================================================
// 三、Aster 特定功能的单元测试
// ============================================================
// TestNewAsterTrader 测试创建 Aster 交易器
func TestNewAsterTrader(t *testing.T) {
tests := []struct {
name string
user string
signer string
privateKeyHex string
wantError bool
errorContains string
}{
{
name: "成功创建",
user: "0x1234567890123456789012345678901234567890",
signer: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
privateKeyHex: "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
wantError: false,
},
{
name: "无效私钥格式",
user: "0x1234567890123456789012345678901234567890",
signer: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
privateKeyHex: "invalid_key",
wantError: true,
errorContains: "解析私钥失败",
},
{
name: "带0x前缀的私钥",
user: "0x1234567890123456789012345678901234567890",
signer: "0xabcdefabcdefabcdefabcdefabcdefabcdefabcd",
privateKeyHex: "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
wantError: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
trader, err := NewAsterTrader(tt.user, tt.signer, tt.privateKeyHex)
if tt.wantError {
assert.Error(t, err)
if tt.errorContains != "" {
assert.Contains(t, err.Error(), tt.errorContains)
}
assert.Nil(t, trader)
} else {
assert.NoError(t, err)
assert.NotNil(t, trader)
if trader != nil {
assert.Equal(t, tt.user, trader.user)
assert.Equal(t, tt.signer, trader.signer)
assert.NotNil(t, trader.privateKey)
}
}
})
}
}

227
trader/auto_trader.go
View File

@@ -97,16 +97,16 @@ type AutoTrader struct {
lastResetTime time.Time
stopUntil time.Time
isRunning bool
startTime time.Time // 系统启动时间
callCount int // AI调用次数
positionFirstSeenTime map[string]int64 // 持仓首次出现时间 (symbol_side -> timestamp毫秒)
stopMonitorCh chan struct{} // 用于停止监控goroutine
monitorWg sync.WaitGroup // 用于等待监控goroutine结束
peakPnLCache map[string]float64 // 最高收益缓存 (symbol -> 峰值盈亏百分比)
peakPnLCacheMutex sync.RWMutex // 缓存读写锁
lastBalanceSyncTime time.Time // 上次余额同步时间
database interface{} // 数据库引用（用于自动更新余额）
userID string // 用户ID
startTime time.Time // 系统启动时间
callCount int // AI调用次数
positionFirstSeenTime map[string]int64 // 持仓首次出现时间 (symbol_side -> timestamp毫秒)
stopMonitorCh chan struct{} // 用于停止监控goroutine
monitorWg sync.WaitGroup // 用于等待监控goroutine结束
peakPnLCache map[string]float64 // 最高收益缓存 (symbol -> 峰值盈亏百分比)
peakPnLCacheMutex sync.RWMutex // 缓存读写锁
lastBalanceSyncTime time.Time // 上次余额同步时间
database interface{} // 数据库引用（用于自动更新余额）
userID string // 用户ID
}
// NewAutoTrader 创建自动交易器
@@ -175,7 +175,7 @@ func NewAutoTrader(config AutoTraderConfig, database interface{}, userID string)
switch config.Exchange {
case "binance":
log.Printf("🏦 [%s] 使用币安合约交易", config.Name)
trader = NewFuturesTrader(config.BinanceAPIKey, config.BinanceSecretKey)
trader = NewFuturesTrader(config.BinanceAPIKey, config.BinanceSecretKey, userID)
case "hyperliquid":
log.Printf("🏦 [%s] 使用Hyperliquid交易", config.Name)
trader, err = NewHyperliquidTrader(config.HyperliquidPrivateKey, config.HyperliquidWalletAddr, config.HyperliquidTestnet)
@@ -239,10 +239,15 @@ func NewAutoTrader(config AutoTraderConfig, database interface{}, userID string)
// Run 运行自动交易主循环
func (at *AutoTrader) Run() error {
at.isRunning = true
at.stopMonitorCh = make(chan struct{})
at.startTime = time.Now()
log.Println("🚀 AI驱动自动交易系统启动")
log.Printf("💰 初始余额: %.2f USDT", at.initialBalance)
log.Printf("⚙️ 扫描间隔: %v", at.config.ScanInterval)
log.Println("🤖 AI将全权决定杠杆、仓位大小、止损止盈等参数")
at.monitorWg.Add(1)
defer at.monitorWg.Done()
// 启动回撤监控
at.startDrawdownMonitor()
@@ -261,6 +266,9 @@ func (at *AutoTrader) Run() error {
if err := at.runCycle(); err != nil {
log.Printf("❌ 执行失败: %v", err)
}
case <-at.stopMonitorCh:
log.Printf("[%s] ⏹ 收到停止信号，退出自动交易主循环", at.name)
return nil
}
}
@@ -269,6 +277,9 @@ func (at *AutoTrader) Run() error {
// Stop 停止自动交易
func (at *AutoTrader) Stop() {
if !at.isRunning {
return
}
at.isRunning = false
close(at.stopMonitorCh) // 通知监控goroutine停止
at.monitorWg.Wait() // 等待监控goroutine结束
@@ -436,7 +447,7 @@ func (at *AutoTrader) runCycle() error {
})
}
log.Print(strings.Repeat("=", 70))
log.Print(strings.Repeat("=", 70))
for _, coin := range ctx.CandidateCoins {
record.CandidateCoins = append(record.CandidateCoins, coin.Symbol)
}
@@ -448,6 +459,13 @@ func (at *AutoTrader) runCycle() error {
log.Printf("🤖 正在请求AI分析并决策... [模板: %s]", at.systemPromptTemplate)
decision, err := decision.GetFullDecisionWithCustomPrompt(ctx, at.mcpClient, at.customPrompt, at.overrideBasePrompt, at.systemPromptTemplate)
if decision != nil && decision.AIRequestDurationMs > 0 {
record.AIRequestDurationMs = decision.AIRequestDurationMs
log.Printf("⏱️ AI调用耗时: %.2f 秒", float64(record.AIRequestDurationMs)/1000)
record.ExecutionLog = append(record.ExecutionLog,
fmt.Sprintf("AI调用耗时: %d ms", record.AIRequestDurationMs))
}
// 即使有错误，也保存思维链、决策和输入prompt（用于debug）
if decision != nil {
record.SystemPrompt = decision.SystemPrompt // 保存系统提示词
@@ -465,11 +483,11 @@ func (at *AutoTrader) runCycle() error {
// 打印系统提示词和AI思维链（即使有错误，也要输出以便调试）
if decision != nil {
log.Print("\n" + strings.Repeat("=", 70) + "\n")
log.Printf("📋 系统提示词 [模板: %s] (错误情况)", at.systemPromptTemplate)
log.Println(strings.Repeat("=", 70))
log.Println(decision.SystemPrompt)
log.Println(strings.Repeat("=", 70))
log.Print("\n" + strings.Repeat("=", 70) + "\n")
log.Printf("📋 系统提示词 [模板: %s] (错误情况)", at.systemPromptTemplate)
log.Println(strings.Repeat("=", 70))
log.Println(decision.SystemPrompt)
log.Println(strings.Repeat("=", 70))
if decision.CoTTrace != "" {
log.Print("\n" + strings.Repeat("-", 70) + "\n")
@@ -508,9 +526,9 @@ func (at *AutoTrader) runCycle() error {
// }
// }
log.Println()
log.Print(strings.Repeat("-", 70))
log.Print(strings.Repeat("-", 70))
// 8. 对决策排序：确保先平仓后开仓（防止仓位叠加超限）
log.Print(strings.Repeat("-", 70))
log.Print(strings.Repeat("-", 70))
// 8. 对决策排序：确保先平仓后开仓（防止仓位叠加超限）
sortedDecisions := sortDecisionsByPriority(decision.Decisions)
@@ -611,14 +629,6 @@ func (at *AutoTrader) buildTradingContext() (*decision.Context, error) {
unrealizedPnl := pos["unRealizedProfit"].(float64)
liquidationPrice := pos["liquidationPrice"].(float64)
// 计算盈亏百分比
pnlPct := 0.0
if side == "long" {
pnlPct = ((markPrice - entryPrice) / entryPrice) * 100
} else {
pnlPct = ((entryPrice - markPrice) / entryPrice) * 100
}
// 计算占用保证金（估算）
leverage := 10 // 默认值，实际应该从持仓信息获取
if lev, ok := pos["leverage"].(float64); ok {
@@ -627,6 +637,9 @@ func (at *AutoTrader) buildTradingContext() (*decision.Context, error) {
marginUsed := (quantity * markPrice) / float64(leverage)
totalMarginUsed += marginUsed
// 计算盈亏百分比（基于保证金，考虑杠杆）
pnlPct := calculatePnLPercentage(unrealizedPnl, marginUsed)
// 跟踪持仓首次出现时间
posKey := symbol + "_" + side
currentPositionKeys[posKey] = true
@@ -636,6 +649,11 @@ func (at *AutoTrader) buildTradingContext() (*decision.Context, error) {
}
updateTime := at.positionFirstSeenTime[posKey]
// 获取该持仓的历史最高收益率
at.peakPnLCacheMutex.RLock()
peakPnlPct := at.peakPnLCache[symbol]
at.peakPnLCacheMutex.RUnlock()
positionInfos = append(positionInfos, decision.PositionInfo{
Symbol: symbol,
Side: side,
@@ -645,6 +663,7 @@ func (at *AutoTrader) buildTradingContext() (*decision.Context, error) {
Leverage: leverage,
UnrealizedPnL: unrealizedPnl,
UnrealizedPnLPct: pnlPct,
PeakPnLPct: peakPnlPct,
LiquidationPrice: liquidationPrice,
MarginUsed: marginUsed,
UpdateTime: updateTime,
@@ -991,8 +1010,30 @@ func (at *AutoTrader) executeUpdateStopLossWithRecord(decision *decision.Decisio
return fmt.Errorf("空单止损必须高于当前价格 (当前: %.2f, 新止损: %.2f)", marketData.CurrentPrice, decision.NewStopLoss)
}
// 取消旧的止损单（避免多个止损单共存）
if err := at.trader.CancelStopOrders(decision.Symbol); err != nil {
// ⚠️ 防御性检查：检测是否存在双向持仓（不应该出现，但提供保护）
var hasOppositePosition bool
oppositeSide := ""
for _, pos := range positions {
symbol, _ := pos["symbol"].(string)
posSide, _ := pos["side"].(string)
posAmt, _ := pos["positionAmt"].(float64)
if symbol == decision.Symbol && posAmt != 0 && strings.ToUpper(posSide) != positionSide {
hasOppositePosition = true
oppositeSide = strings.ToUpper(posSide)
break
}
}
if hasOppositePosition {
log.Printf(" 🚨 警告：检测到 %s 存在双向持仓（%s + %s），这违反了策略规则",
decision.Symbol, positionSide, oppositeSide)
log.Printf(" 🚨 取消止损单将影响两个方向的订单，请检查是否为用户手动操作导致")
log.Printf(" 🚨 建议：手动平掉其中一个方向的持仓，或检查系统是否有BUG")
}
// 取消旧的止损单（只删除止损单，不影响止盈单）
// 注意：如果存在双向持仓，这会删除两个方向的止损单
if err := at.trader.CancelStopLossOrders(decision.Symbol); err != nil {
log.Printf(" ⚠ 取消旧止损单失败: %v", err)
// 不中断执行，继续设置新止损
}
@@ -1053,8 +1094,30 @@ func (at *AutoTrader) executeUpdateTakeProfitWithRecord(decision *decision.Decis
return fmt.Errorf("空单止盈必须低于当前价格 (当前: %.2f, 新止盈: %.2f)", marketData.CurrentPrice, decision.NewTakeProfit)
}
// 取消旧的止盈单（避免多个止盈单共存）
if err := at.trader.CancelStopOrders(decision.Symbol); err != nil {
// ⚠️ 防御性检查：检测是否存在双向持仓（不应该出现，但提供保护）
var hasOppositePosition bool
oppositeSide := ""
for _, pos := range positions {
symbol, _ := pos["symbol"].(string)
posSide, _ := pos["side"].(string)
posAmt, _ := pos["positionAmt"].(float64)
if symbol == decision.Symbol && posAmt != 0 && strings.ToUpper(posSide) != positionSide {
hasOppositePosition = true
oppositeSide = strings.ToUpper(posSide)
break
}
}
if hasOppositePosition {
log.Printf(" 🚨 警告：检测到 %s 存在双向持仓（%s + %s），这违反了策略规则",
decision.Symbol, positionSide, oppositeSide)
log.Printf(" 🚨 取消止盈单将影响两个方向的订单，请检查是否为用户手动操作导致")
log.Printf(" 🚨 建议：手动平掉其中一个方向的持仓，或检查系统是否有BUG")
}
// 取消旧的止盈单（只删除止盈单，不影响止损单）
// 注意：如果存在双向持仓，这会删除两个方向的止盈单
if err := at.trader.CancelTakeProfitOrders(decision.Symbol); err != nil {
log.Printf(" ⚠ 取消旧止盈单失败: %v", err)
// 不中断执行，继续设置新止盈
}
@@ -1117,6 +1180,37 @@ func (at *AutoTrader) executePartialCloseWithRecord(decision *decision.Decision,
closeQuantity := totalQuantity * (decision.ClosePercentage / 100.0)
actionRecord.Quantity = closeQuantity
// ✅ Layer 2: 最小仓位检查（防止产生小额剩余）
markPrice, ok := targetPosition["markPrice"].(float64)
if !ok || markPrice <= 0 {
return fmt.Errorf("无法解析当前价格，无法执行最小仓位检查")
}
currentPositionValue := totalQuantity * markPrice
remainingQuantity := totalQuantity - closeQuantity
remainingValue := remainingQuantity * markPrice
const MIN_POSITION_VALUE = 10.0 // 最小持仓价值 10 USDT（對齊交易所底线，小仓位建议直接全平）
if remainingValue > 0 && remainingValue <= MIN_POSITION_VALUE {
log.Printf("⚠️ 检测到 partial_close 后剩余仓位 %.2f USDT < %.0f USDT",
remainingValue, MIN_POSITION_VALUE)
log.Printf(" → 当前仓位价值: %.2f USDT, 平仓 %.1f%%, 剩余: %.2f USDT",
currentPositionValue, decision.ClosePercentage, remainingValue)
log.Printf(" → 自动修正为全部平仓，避免产生无法平仓的小额剩余")
// 🔄 自动修正为全部平仓
if positionSide == "LONG" {
decision.Action = "close_long"
log.Printf(" ✓ 已修正为: close_long")
return at.executeCloseLongWithRecord(decision, actionRecord)
} else {
decision.Action = "close_short"
log.Printf(" ✓ 已修正为: close_short")
return at.executeCloseShortWithRecord(decision, actionRecord)
}
}
// 执行平仓
var order map[string]interface{}
if positionSide == "LONG" {
@@ -1134,10 +1228,35 @@ func (at *AutoTrader) executePartialCloseWithRecord(decision *decision.Decision,
actionRecord.OrderID = orderID
}
remainingQuantity := totalQuantity - closeQuantity
log.Printf(" ✓ 部分平仓成功: 平仓 %.4f (%.1f%%), 剩余 %.4f",
closeQuantity, decision.ClosePercentage, remainingQuantity)
// ✅ Step 4: 恢复止盈止损（防止剩余仓位裸奔）
// 重要：币安等交易所在部分平仓后会自动取消原有的 TP/SL 订单（因为数量不匹配）
// 如果 AI 提供了新的止损止盈价格，则为剩余仓位重新设置保护
if decision.NewStopLoss > 0 {
log.Printf(" → 为剩余仓位 %.4f 恢复止损单: %.2f", remainingQuantity, decision.NewStopLoss)
err = at.trader.SetStopLoss(decision.Symbol, positionSide, remainingQuantity, decision.NewStopLoss)
if err != nil {
log.Printf(" ⚠️ 恢复止损失败: %v（不影响平仓结果）", err)
}
}
if decision.NewTakeProfit > 0 {
log.Printf(" → 为剩余仓位 %.4f 恢复止盈单: %.2f", remainingQuantity, decision.NewTakeProfit)
err = at.trader.SetTakeProfit(decision.Symbol, positionSide, remainingQuantity, decision.NewTakeProfit)
if err != nil {
log.Printf(" ⚠️ 恢复止盈失败: %v（不影响平仓结果）", err)
}
}
// 如果 AI 没有提供新的止盈止损，记录警告
if decision.NewStopLoss <= 0 && decision.NewTakeProfit <= 0 {
log.Printf(" ⚠️⚠️⚠️ 警告: 部分平仓后AI未提供新的止盈止损价格")
log.Printf(" → 剩余仓位 %.4f (价值 %.2f USDT) 目前没有止盈止损保护", remainingQuantity, remainingValue)
log.Printf(" → 建议: 在 partial_close 决策中包含 new_stop_loss 和 new_take_profit 字段")
}
return nil
}
@@ -1321,11 +1440,7 @@ func (at *AutoTrader) GetPositions() ([]map[string]interface{}, error) {
marginUsed := (quantity * markPrice) / float64(leverage)
// 计算盈亏百分比（基于保证金）
// 收益率 = 未实现盈亏 / 保证金 × 100%
pnlPct := 0.0
if marginUsed > 0 {
pnlPct = (unrealizedPnl / marginUsed) * 100
}
pnlPct := calculatePnLPercentage(unrealizedPnl, marginUsed)
result = append(result, map[string]interface{}{
"symbol": symbol,
@@ -1344,6 +1459,15 @@ func (at *AutoTrader) GetPositions() ([]map[string]interface{}, error) {
return result, nil
}
// calculatePnLPercentage 计算盈亏百分比（基于保证金，自动考虑杠杆）
// 收益率 = 未实现盈亏 / 保证金 × 100%
func calculatePnLPercentage(unrealizedPnl, marginUsed float64) float64 {
if marginUsed > 0 {
return (unrealizedPnl / marginUsed) * 100
}
return 0.0
}
// sortDecisionsByPriority 对决策排序：先平仓，再开仓，最后hold/wait
// 这样可以避免换仓时仓位叠加超限
func sortDecisionsByPriority(decisions []decision.Decision) []decision.Decision {
@@ -1509,18 +1633,21 @@ func (at *AutoTrader) checkPositionDrawdown() {
currentPnLPct = ((entryPrice - markPrice) / entryPrice) * float64(leverage) * 100
}
// 构造持仓唯一标识（区分多空）
posKey := symbol + "_" + side
// 获取该持仓的历史最高收益
at.peakPnLCacheMutex.RLock()
peakPnLPct, exists := at.peakPnLCache[symbol]
peakPnLPct, exists := at.peakPnLCache[posKey]
at.peakPnLCacheMutex.RUnlock()
if !exists {
// 如果没有历史最高记录，使用当前盈亏作为初始值
peakPnLPct = currentPnLPct
at.UpdatePeakPnL(symbol, currentPnLPct)
at.UpdatePeakPnL(symbol, side, currentPnLPct)
} else {
// 更新峰值缓存
at.UpdatePeakPnL(symbol, currentPnLPct)
at.UpdatePeakPnL(symbol, side, currentPnLPct)
}
// 计算回撤（从最高点下跌的幅度）
@@ -1539,8 +1666,8 @@ func (at *AutoTrader) checkPositionDrawdown() {
log.Printf("❌ 回撤平仓失败 (%s %s): %v", symbol, side, err)
} else {
log.Printf("✅ 回撤平仓成功: %s %s", symbol, side)
// 平仓后清理该symbol的缓存
at.ClearPeakPnLCache(symbol)
// 平仓后清理该持仓的缓存
at.ClearPeakPnLCache(symbol, side)
}
} else if currentPnLPct > 5.0 {
// 记录接近平仓条件的情况（用于调试）
@@ -1586,25 +1713,27 @@ func (at *AutoTrader) GetPeakPnLCache() map[string]float64 {
}
// UpdatePeakPnL 更新最高收益缓存
func (at *AutoTrader) UpdatePeakPnL(symbol string, currentPnLPct float64) {
func (at *AutoTrader) UpdatePeakPnL(symbol, side string, currentPnLPct float64) {
at.peakPnLCacheMutex.Lock()
defer at.peakPnLCacheMutex.Unlock()
if peak, exists := at.peakPnLCache[symbol]; exists {
posKey := symbol + "_" + side
if peak, exists := at.peakPnLCache[posKey]; exists {
// 更新峰值（如果是多头，取较大值；如果是空头，currentPnLPct为负，也要比较）
if currentPnLPct > peak {
at.peakPnLCache[symbol] = currentPnLPct
at.peakPnLCache[posKey] = currentPnLPct
}
} else {
// 首次记录
at.peakPnLCache[symbol] = currentPnLPct
at.peakPnLCache[posKey] = currentPnLPct
}
}
// ClearPeakPnLCache 清除指定symbol的峰值缓存
func (at *AutoTrader) ClearPeakPnLCache(symbol string) {
// ClearPeakPnLCache 清除指定持仓的峰值缓存
func (at *AutoTrader) ClearPeakPnLCache(symbol, side string) {
at.peakPnLCacheMutex.Lock()
defer at.peakPnLCacheMutex.Unlock()
delete(at.peakPnLCache, symbol)
posKey := symbol + "_" + side
delete(at.peakPnLCache, posKey)
}

1212
trader/auto_trader_test.go Normal file
View File

File diff suppressed because it is too large Load Diff

93
trader/binance_futures.go
View File

@@ -2,8 +2,11 @@ package trader
import (
"context"
"crypto/rand"
"encoding/hex"
"fmt"
"log"
"nofx/hook"
"strconv"
"strings"
"sync"
@@ -12,6 +15,34 @@ import (
"github.com/adshao/go-binance/v2/futures"
)
// getBrOrderID 生成唯一订单ID（合约专用）
// 格式: x-{BR_ID}{TIMESTAMP}{RANDOM}
// 合约限制32字符，统一使用此限制以保持一致性
// 使用纳秒时间戳+随机数确保全局唯一性（冲突概率 < 10^-20）
func getBrOrderID() string {
brID := "KzrpZaP9" // 合约br ID
// 计算可用空间: 32 - len("x-KzrpZaP9") = 32 - 11 = 21字符
// 分配: 13位时间戳 + 8位随机数 = 21字符（完美利用）
timestamp := time.Now().UnixNano() % 10000000000000 // 13位纳秒时间戳
// 生成4字节随机数（8位十六进制）
randomBytes := make([]byte, 4)
rand.Read(randomBytes)
randomHex := hex.EncodeToString(randomBytes)
// 格式: x-KzrpZaP9{13位时间戳}{8位随机}
// 示例: x-KzrpZaP91234567890123abcdef12 (正好31字符)
orderID := fmt.Sprintf("x-%s%d%s", brID, timestamp, randomHex)
// 确保不超过32字符限制（理论上正好31字符）
if len(orderID) > 32 {
orderID = orderID[:32]
}
return orderID
}
// FuturesTrader 币安合约交易器
type FuturesTrader struct {
client *futures.Client
@@ -31,8 +62,14 @@ type FuturesTrader struct {
}
// NewFuturesTrader 创建合约交易器
func NewFuturesTrader(apiKey, secretKey string) *FuturesTrader {
func NewFuturesTrader(apiKey, secretKey string, userId string) *FuturesTrader {
client := futures.NewClient(apiKey, secretKey)
hookRes := hook.HookExec[hook.NewBinanceTraderResult](hook.NEW_BINANCE_TRADER, userId, client)
if hookRes != nil && hookRes.GetResult() != nil {
client = hookRes.GetResult()
}
// 同步时间，避免 Timestamp ahead 错误
syncBinanceServerTime(client)
trader := &FuturesTrader{
@@ -298,7 +335,7 @@ func (t *FuturesTrader) OpenLong(symbol string, quantity float64, leverage int)
// ✅ 检查格式化后的数量是否为 0（防止四舍五入导致的错误）
quantityFloat, parseErr := strconv.ParseFloat(quantityStr, 64)
if parseErr != nil || quantityFloat <= 0 {
return nil, fmt.Errorf("开倉數量過小，格式化後為 0 (原始: %.8f → 格式化: %s)。建議增加開倉金額或選擇價格更低的幣種", quantity, quantityStr)
return nil, fmt.Errorf("开仓数量过小，格式化后为 0 (原始: %.8f → 格式化: %s)。建议增加开仓金额或选择价格更低的币种", quantity, quantityStr)
}
// ✅ 检查最小名义价值（Binance 要求至少 10 USDT）
@@ -306,13 +343,14 @@ func (t *FuturesTrader) OpenLong(symbol string, quantity float64, leverage int)
return nil, err
}
// 创建市价买入订单
// 创建市价买入订单（使用br ID）
order, err := t.client.NewCreateOrderService().
Symbol(symbol).
Side(futures.SideTypeBuy).
PositionSide(futures.PositionSideTypeLong).
Type(futures.OrderTypeMarket).
Quantity(quantityStr).
NewClientOrderID(getBrOrderID()).
Do(context.Background())
if err != nil {
@@ -352,7 +390,7 @@ func (t *FuturesTrader) OpenShort(symbol string, quantity float64, leverage int)
// ✅ 检查格式化后的数量是否为 0（防止四舍五入导致的错误）
quantityFloat, parseErr := strconv.ParseFloat(quantityStr, 64)
if parseErr != nil || quantityFloat <= 0 {
return nil, fmt.Errorf("开倉數量過小，格式化後為 0 (原始: %.8f → 格式化: %s)。建議增加開倉金額或選擇價格更低的幣種", quantity, quantityStr)
return nil, fmt.Errorf("开仓数量过小，格式化后为 0 (原始: %.8f → 格式化: %s)。建议增加开仓金额或选择价格更低的币种", quantity, quantityStr)
}
// ✅ 检查最小名义价值（Binance 要求至少 10 USDT）
@@ -360,13 +398,14 @@ func (t *FuturesTrader) OpenShort(symbol string, quantity float64, leverage int)
return nil, err
}
// 创建市价卖出订单
// 创建市价卖出订单（使用br ID）
order, err := t.client.NewCreateOrderService().
Symbol(symbol).
Side(futures.SideTypeSell).
PositionSide(futures.PositionSideTypeShort).
Type(futures.OrderTypeMarket).
Quantity(quantityStr).
NewClientOrderID(getBrOrderID()).
Do(context.Background())
if err != nil {
@@ -410,13 +449,14 @@ func (t *FuturesTrader) CloseLong(symbol string, quantity float64) (map[string]i
return nil, err
}
// 创建市价卖出订单（平多）
// 创建市价卖出订单（平多，使用br ID）
order, err := t.client.NewCreateOrderService().
Symbol(symbol).
Side(futures.SideTypeSell).
PositionSide(futures.PositionSideTypeLong).
Type(futures.OrderTypeMarket).
Quantity(quantityStr).
NewClientOrderID(getBrOrderID()).
Do(context.Background())
if err != nil {
@@ -464,13 +504,14 @@ func (t *FuturesTrader) CloseShort(symbol string, quantity float64) (map[string]
return nil, err
}
// 创建市价买入订单（平空）
// 创建市价买入订单（平空，使用br ID）
order, err := t.client.NewCreateOrderService().
Symbol(symbol).
Side(futures.SideTypeBuy).
PositionSide(futures.PositionSideTypeShort).
Type(futures.OrderTypeMarket).
Quantity(quantityStr).
NewClientOrderID(getBrOrderID()).
Do(context.Background())
if err != nil {
@@ -491,8 +532,6 @@ func (t *FuturesTrader) CloseShort(symbol string, quantity float64) (map[string]
return result, nil
}
// CancelStopLossOrders 仅取消止损单（不影响止盈单）
func (t *FuturesTrader) CancelStopLossOrders(symbol string) error {
// 获取该币种的所有未完成订单
@@ -504,8 +543,9 @@ func (t *FuturesTrader) CancelStopLossOrders(symbol string) error {
return fmt.Errorf("获取未完成订单失败: %w", err)
}
// 过滤出止损单并取消
// 过滤出止损单并取消（取消所有方向的止损单，包括LONG和SHORT）
canceledCount := 0
var cancelErrors []error
for _, order := range orders {
orderType := order.Type
@@ -517,21 +557,28 @@ func (t *FuturesTrader) CancelStopLossOrders(symbol string) error {
Do(context.Background())
if err != nil {
log.Printf(" ⚠ 取消止损单 %d 失败: %v", order.OrderID, err)
errMsg := fmt.Sprintf("订单ID %d: %v", order.OrderID, err)
cancelErrors = append(cancelErrors, fmt.Errorf("%s", errMsg))
log.Printf(" ⚠ 取消止损单失败: %s", errMsg)
continue
}
canceledCount++
log.Printf(" ✓ 已取消止损单 (订单ID: %d, 类型: %s)", order.OrderID, orderType)
log.Printf(" ✓ 已取消止损单 (订单ID: %d, 类型: %s, 方向: %s)", order.OrderID, orderType, order.PositionSide)
}
}
if canceledCount == 0 {
if canceledCount == 0 && len(cancelErrors) == 0 {
log.Printf(" ℹ %s 没有止损单需要取消", symbol)
} else {
} else if canceledCount > 0 {
log.Printf(" ✓ 已取消 %s 的 %d 个止损单", symbol, canceledCount)
}
// 如果所有取消都失败了，返回错误
if len(cancelErrors) > 0 && canceledCount == 0 {
return fmt.Errorf("取消止损单失败: %v", cancelErrors)
}
return nil
}
@@ -546,8 +593,9 @@ func (t *FuturesTrader) CancelTakeProfitOrders(symbol string) error {
return fmt.Errorf("获取未完成订单失败: %w", err)
}
// 过滤出止盈单并取消
// 过滤出止盈单并取消（取消所有方向的止盈单，包括LONG和SHORT）
canceledCount := 0
var cancelErrors []error
for _, order := range orders {
orderType := order.Type
@@ -559,21 +607,28 @@ func (t *FuturesTrader) CancelTakeProfitOrders(symbol string) error {
Do(context.Background())
if err != nil {
log.Printf(" ⚠ 取消止盈单 %d 失败: %v", order.OrderID, err)
errMsg := fmt.Sprintf("订单ID %d: %v", order.OrderID, err)
cancelErrors = append(cancelErrors, fmt.Errorf("%s", errMsg))
log.Printf(" ⚠ 取消止盈单失败: %s", errMsg)
continue
}
canceledCount++
log.Printf(" ✓ 已取消止盈单 (订单ID: %d, 类型: %s)", order.OrderID, orderType)
log.Printf(" ✓ 已取消止盈单 (订单ID: %d, 类型: %s, 方向: %s)", order.OrderID, orderType, order.PositionSide)
}
}
if canceledCount == 0 {
if canceledCount == 0 && len(cancelErrors) == 0 {
log.Printf(" ℹ %s 没有止盈单需要取消", symbol)
} else {
} else if canceledCount > 0 {
log.Printf(" ✓ 已取消 %s 的 %d 个止盈单", symbol, canceledCount)
}
// 如果所有取消都失败了，返回错误
if len(cancelErrors) > 0 && canceledCount == 0 {
return fmt.Errorf("取消止盈单失败: %v", cancelErrors)
}
return nil
}

420
trader/binance_futures_test.go Normal file
View File

@@ -0,0 +1,420 @@
package trader
import (
"encoding/json"
"fmt"
"net/http"
"net/http/httptest"
"strings"
"testing"
"time"
"github.com/adshao/go-binance/v2/futures"
"github.com/stretchr/testify/assert"
)
// ============================================================
// 一、BinanceFuturesTestSuite - 继承 base test suite
// ============================================================
// BinanceFuturesTestSuite 币安合约交易器测试套件
// 继承 TraderTestSuite 并添加 Binance Futures 特定的 mock 逻辑
type BinanceFuturesTestSuite struct {
*TraderTestSuite // 嵌入基础测试套件
mockServer *httptest.Server
}
// NewBinanceFuturesTestSuite 创建币安合约测试套件
func NewBinanceFuturesTestSuite(t *testing.T) *BinanceFuturesTestSuite {
// 创建 mock HTTP 服务器
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// 根据不同的 URL 路径返回不同的 mock 响应
path := r.URL.Path
var respBody interface{}
switch {
// Mock GetBalance - /fapi/v2/balance
case path == "/fapi/v2/balance":
respBody = []map[string]interface{}{
{
"accountAlias": "test",
"asset": "USDT",
"balance": "10000.00",
"crossWalletBalance": "10000.00",
"crossUnPnl": "100.50",
"availableBalance": "8000.00",
"maxWithdrawAmount": "8000.00",
},
}
// Mock GetAccount - /fapi/v2/account
case path == "/fapi/v2/account":
respBody = map[string]interface{}{
"totalWalletBalance": "10000.00",
"availableBalance": "8000.00",
"totalUnrealizedProfit": "100.50",
"assets": []map[string]interface{}{
{
"asset": "USDT",
"walletBalance": "10000.00",
"unrealizedProfit": "100.50",
"marginBalance": "10100.50",
"maintMargin": "200.00",
"initialMargin": "2000.00",
"positionInitialMargin": "2000.00",
"openOrderInitialMargin": "0.00",
"crossWalletBalance": "10000.00",
"crossUnPnl": "100.50",
"availableBalance": "8000.00",
"maxWithdrawAmount": "8000.00",
},
},
}
// Mock GetPositions - /fapi/v2/positionRisk
case path == "/fapi/v2/positionRisk":
respBody = []map[string]interface{}{
{
"symbol": "BTCUSDT",
"positionAmt": "0.5",
"entryPrice": "50000.00",
"markPrice": "50500.00",
"unRealizedProfit": "250.00",
"liquidationPrice": "45000.00",
"leverage": "10",
"positionSide": "LONG",
},
}
// Mock GetMarketPrice - /fapi/v1/ticker/price and /fapi/v2/ticker/price
case path == "/fapi/v1/ticker/price" || path == "/fapi/v2/ticker/price":
symbol := r.URL.Query().Get("symbol")
if symbol == "" {
// 返回所有价格
respBody = []map[string]interface{}{
{"Symbol": "BTCUSDT", "Price": "50000.00", "Time": 1234567890},
{"Symbol": "ETHUSDT", "Price": "3000.00", "Time": 1234567890},
}
} else if symbol == "INVALIDUSDT" {
// 返回错误
w.WriteHeader(http.StatusBadRequest)
json.NewEncoder(w).Encode(map[string]interface{}{
"code": -1121,
"msg": "Invalid symbol.",
})
return
} else {
// 返回单个价格（注意：即使有 symbol 参数，也要返回数组）
price := "50000.00"
if symbol == "ETHUSDT" {
price = "3000.00"
}
respBody = []map[string]interface{}{
{
"Symbol": symbol,
"Price": price,
"Time": 1234567890,
},
}
}
// Mock ExchangeInfo - /fapi/v1/exchangeInfo
case path == "/fapi/v1/exchangeInfo":
respBody = map[string]interface{}{
"symbols": []map[string]interface{}{
{
"symbol": "BTCUSDT",
"status": "TRADING",
"baseAsset": "BTC",
"quoteAsset": "USDT",
"pricePrecision": 2,
"quantityPrecision": 3,
"baseAssetPrecision": 8,
"quotePrecision": 8,
"filters": []map[string]interface{}{
{
"filterType": "PRICE_FILTER",
"minPrice": "0.01",
"maxPrice": "1000000",
"tickSize": "0.01",
},
{
"filterType": "LOT_SIZE",
"minQty": "0.001",
"maxQty": "10000",
"stepSize": "0.001",
},
},
},
{
"symbol": "ETHUSDT",
"status": "TRADING",
"baseAsset": "ETH",
"quoteAsset": "USDT",
"pricePrecision": 2,
"quantityPrecision": 3,
"baseAssetPrecision": 8,
"quotePrecision": 8,
"filters": []map[string]interface{}{
{
"filterType": "PRICE_FILTER",
"minPrice": "0.01",
"maxPrice": "100000",
"tickSize": "0.01",
},
{
"filterType": "LOT_SIZE",
"minQty": "0.001",
"maxQty": "10000",
"stepSize": "0.001",
},
},
},
},
}
// Mock CreateOrder - /fapi/v1/order (POST)
case path == "/fapi/v1/order" && r.Method == "POST":
symbol := r.FormValue("symbol")
if symbol == "" {
symbol = "BTCUSDT"
}
respBody = map[string]interface{}{
"orderId": 123456,
"symbol": symbol,
"status": "FILLED",
"clientOrderId": r.FormValue("newClientOrderId"),
"price": r.FormValue("price"),
"avgPrice": r.FormValue("price"),
"origQty": r.FormValue("quantity"),
"executedQty": r.FormValue("quantity"),
"cumQty": r.FormValue("quantity"),
"cumQuote": "1000.00",
"timeInForce": r.FormValue("timeInForce"),
"type": r.FormValue("type"),
"reduceOnly": r.FormValue("reduceOnly") == "true",
"side": r.FormValue("side"),
"positionSide": r.FormValue("positionSide"),
"stopPrice": r.FormValue("stopPrice"),
"workingType": r.FormValue("workingType"),
}
// Mock CancelOrder - /fapi/v1/order (DELETE)
case path == "/fapi/v1/order" && r.Method == "DELETE":
respBody = map[string]interface{}{
"orderId": 123456,
"symbol": r.URL.Query().Get("symbol"),
"status": "CANCELED",
}
// Mock ListOpenOrders - /fapi/v1/openOrders
case path == "/fapi/v1/openOrders":
respBody = []map[string]interface{}{}
// Mock CancelAllOrders - /fapi/v1/allOpenOrders (DELETE)
case path == "/fapi/v1/allOpenOrders" && r.Method == "DELETE":
respBody = map[string]interface{}{
"code": 200,
"msg": "The operation of cancel all open order is done.",
}
// Mock SetLeverage - /fapi/v1/leverage
case path == "/fapi/v1/leverage":
// 将字符串转换为整数
leverageStr := r.FormValue("leverage")
leverage := 10 // 默认值
if leverageStr != "" {
// 注意：这里我们直接返回整数，而不是字符串
fmt.Sscanf(leverageStr, "%d", &leverage)
}
respBody = map[string]interface{}{
"leverage": leverage,
"maxNotionalValue": "1000000",
"symbol": r.FormValue("symbol"),
}
// Mock SetMarginType - /fapi/v1/marginType
case path == "/fapi/v1/marginType":
respBody = map[string]interface{}{
"code": 200,
"msg": "success",
}
// Mock ChangePositionMode - /fapi/v1/positionSide/dual
case path == "/fapi/v1/positionSide/dual":
respBody = map[string]interface{}{
"code": 200,
"msg": "success",
}
// Mock ServerTime - /fapi/v1/time
case path == "/fapi/v1/time":
respBody = map[string]interface{}{
"serverTime": 1234567890000,
}
// Default: empty response
default:
respBody = map[string]interface{}{}
}
// 序列化响应
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(respBody)
}))
// 创建 futures.Client 并设置为使用 mock 服务器
client := futures.NewClient("test_api_key", "test_secret_key")
client.BaseURL = mockServer.URL
client.HTTPClient = mockServer.Client()
// 创建 FuturesTrader
trader := &FuturesTrader{
client: client,
cacheDuration: 0, // 禁用缓存以便测试
}
// 创建基础套件
baseSuite := NewTraderTestSuite(t, trader)
return &BinanceFuturesTestSuite{
TraderTestSuite: baseSuite,
mockServer: mockServer,
}
}
// Cleanup 清理资源
func (s *BinanceFuturesTestSuite) Cleanup() {
if s.mockServer != nil {
s.mockServer.Close()
}
s.TraderTestSuite.Cleanup()
}
// ============================================================
// 二、使用 BinanceFuturesTestSuite 运行通用测试
// ============================================================
// TestFuturesTrader_InterfaceCompliance 测试接口兼容性
func TestFuturesTrader_InterfaceCompliance(t *testing.T) {
var _ Trader = (*FuturesTrader)(nil)
}
// TestFuturesTrader_CommonInterface 使用测试套件运行所有通用接口测试
func TestFuturesTrader_CommonInterface(t *testing.T) {
// 创建测试套件
suite := NewBinanceFuturesTestSuite(t)
defer suite.Cleanup()
// 运行所有通用接口测试
suite.RunAllTests()
}
// ============================================================
// 三、币安合约特定功能的单元测试
// ============================================================
// TestNewFuturesTrader 测试创建币安合约交易器
func TestNewFuturesTrader(t *testing.T) {
// 创建 mock HTTP 服务器
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
path := r.URL.Path
var respBody interface{}
switch path {
case "/fapi/v1/time":
respBody = map[string]interface{}{
"serverTime": 1234567890000,
}
case "/fapi/v1/positionSide/dual":
respBody = map[string]interface{}{
"code": 200,
"msg": "success",
}
default:
respBody = map[string]interface{}{}
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(respBody)
}))
defer mockServer.Close()
// 测试成功创建
trader := NewFuturesTrader("test_api_key", "test_secret_key", "test_user")
// 修改 client 使用 mock server
trader.client.BaseURL = mockServer.URL
trader.client.HTTPClient = mockServer.Client()
assert.NotNil(t, trader)
assert.NotNil(t, trader.client)
assert.Equal(t, 15*time.Second, trader.cacheDuration)
}
// TestCalculatePositionSize 测试仓位计算
func TestCalculatePositionSize(t *testing.T) {
trader := &FuturesTrader{}
tests := []struct {
name string
balance float64
riskPercent float64
price float64
leverage int
wantQuantity float64
}{
{
name: "正常计算",
balance: 10000,
riskPercent: 2,
price: 50000,
leverage: 10,
wantQuantity: 0.04, // (10000 * 0.02 * 10) / 50000 = 0.04
},
{
name: "高杠杆",
balance: 10000,
riskPercent: 1,
price: 3000,
leverage: 20,
wantQuantity: 0.6667, // (10000 * 0.01 * 20) / 3000 = 0.6667
},
{
name: "低风险",
balance: 5000,
riskPercent: 0.5,
price: 50000,
leverage: 5,
wantQuantity: 0.0025, // (5000 * 0.005 * 5) / 50000 = 0.0025
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
quantity := trader.CalculatePositionSize(tt.balance, tt.riskPercent, tt.price, tt.leverage)
assert.InDelta(t, tt.wantQuantity, quantity, 0.0001, "计算的仓位数量不正确")
})
}
}
// TestGetBrOrderID 测试订单ID生成
func TestGetBrOrderID(t *testing.T) {
// 测试3次，确保每次生成的ID都不同
ids := make(map[string]bool)
for i := 0; i < 3; i++ {
id := getBrOrderID()
// 检查格式
assert.True(t, strings.HasPrefix(id, "x-KzrpZaP9"), "订单ID应以x-KzrpZaP9开头")
// 检查长度（应该 <= 32）
assert.LessOrEqual(t, len(id), 32, "订单ID长度不应超过32字符")
// 检查唯一性
assert.False(t, ids[id], "订单ID应该唯一")
ids[id] = true
}
}

123
trader/hyperliquid_trader.go
View File

@@ -8,6 +8,7 @@ import (
"log"
"strconv"
"strings"
"sync"
"github.com/ethereum/go-ethereum/crypto"
"github.com/sonirico/go-hyperliquid"
@@ -19,6 +20,7 @@ type HyperliquidTrader struct {
ctx context.Context
walletAddr string
meta *hyperliquid.Meta // 缓存meta信息（包含精度等）
metaMutex sync.RWMutex // 保护meta字段的并发访问
isCrossMargin bool // 是否为全仓模式
}
@@ -39,17 +41,29 @@ func NewHyperliquidTrader(privateKeyHex string, walletAddr string, testnet bool)
apiURL = hyperliquid.TestnetAPIURL
}
// 从私钥生成钱包地址（如果未提供）
// Security enhancement: Implement Agent Wallet best practices
// Reference: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/nonces-and-api-wallets
agentAddr := crypto.PubkeyToAddress(*privateKey.Public().(*ecdsa.PublicKey)).Hex()
if walletAddr == "" {
pubKey := privateKey.Public()
publicKeyECDSA, ok := pubKey.(*ecdsa.PublicKey)
if !ok {
return nil, fmt.Errorf("无法转换公钥")
}
walletAddr = crypto.PubkeyToAddress(*publicKeyECDSA).Hex()
log.Printf("✓ 从私钥自动生成钱包地址: %s", walletAddr)
return nil, fmt.Errorf("❌ Configuration error: Main wallet address (hyperliquid_wallet_addr) not provided\n" +
"🔐 Correct configuration pattern:\n" +
" 1. hyperliquid_private_key = Agent Private Key (for signing only, balance should be ~0)\n" +
" 2. hyperliquid_wallet_addr = Main Wallet Address (holds funds, never expose private key)\n" +
"💡 Please create an Agent Wallet on Hyperliquid official website and authorize it before configuration:\n" +
" https://app.hyperliquid.xyz/ → Settings → API Wallets")
}
// Check if user accidentally uses main wallet private key (security risk)
if strings.EqualFold(walletAddr, agentAddr) {
log.Printf("⚠️⚠️⚠️ WARNING: Main wallet address (%s) matches Agent wallet address!", walletAddr)
log.Printf(" This indicates you may be using your main wallet private key, which poses extremely high security risks!")
log.Printf(" Recommendation: Immediately create a separate Agent Wallet on Hyperliquid official website")
log.Printf(" Reference: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/nonces-and-api-wallets")
} else {
log.Printf("✓ 使用提供的钱包地址: %s", walletAddr)
log.Printf("✓ Using Agent Wallet mode (secure)")
log.Printf(" └─ Agent wallet address: %s (for signing)", agentAddr)
log.Printf(" └─ Main wallet address: %s (holds funds)", walletAddr)
}
ctx := context.Background()
@@ -73,6 +87,39 @@ func NewHyperliquidTrader(privateKeyHex string, walletAddr string, testnet bool)
return nil, fmt.Errorf("获取meta信息失败: %w", err)
}
// 🔍 Security check: Validate Agent wallet balance (should be close to 0)
// Only check if using separate Agent wallet (not when main wallet is used as agent)
if !strings.EqualFold(walletAddr, agentAddr) {
agentState, err := exchange.Info().UserState(ctx, agentAddr)
if err == nil && agentState != nil && agentState.CrossMarginSummary.AccountValue != "" {
// Parse Agent wallet balance
agentBalance, _ := strconv.ParseFloat(agentState.CrossMarginSummary.AccountValue, 64)
if agentBalance > 100 {
// Critical: Agent wallet holds too much funds
log.Printf("🚨🚨🚨 CRITICAL SECURITY WARNING 🚨🚨🚨")
log.Printf(" Agent wallet balance: %.2f USDC (exceeds safe threshold of 100 USDC)", agentBalance)
log.Printf(" Agent wallet address: %s", agentAddr)
log.Printf(" ⚠️ Agent wallets should only be used for signing and hold minimal/zero balance")
log.Printf(" ⚠️ High balance in Agent wallet poses security risks")
log.Printf(" 📖 Reference: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/nonces-and-api-wallets")
log.Printf(" 💡 Recommendation: Transfer funds to main wallet and keep Agent wallet balance near 0")
return nil, fmt.Errorf("security check failed: Agent wallet balance too high (%.2f USDC), exceeds 100 USDC threshold", agentBalance)
} else if agentBalance > 10 {
// Warning: Agent wallet has some balance (acceptable but not ideal)
log.Printf("⚠️ Notice: Agent wallet address (%s) has some balance: %.2f USDC", agentAddr, agentBalance)
log.Printf(" While not critical, it's recommended to keep Agent wallet balance near 0 for security")
} else {
// OK: Agent wallet balance is safe
log.Printf("✓ Agent wallet balance is safe: %.2f USDC (near zero as recommended)", agentBalance)
}
} else if err != nil {
// Failed to query agent balance - log warning but don't block initialization
log.Printf("⚠️ Could not verify Agent wallet balance (query failed): %v", err)
log.Printf(" Proceeding with initialization, but please manually verify Agent wallet balance is near 0")
}
}
return &HyperliquidTrader{
exchange: exchange,
ctx: ctx,
@@ -170,15 +217,15 @@ func (t *HyperliquidTrader) GetBalance() (map[string]interface{}, error) {
}
}
// ✅ Step 5: 正確處理 Spot + Perpetuals 余额
// 重要：Spot 只加到總資產，不加到可用餘額
// 原因：Spot 和 Perpetuals 是獨立帳戶，需手動 ClassTransfer 才能轉帳
// ✅ Step 5: 正确处理 Spot + Perpetuals 余额
// 重要：Spot 只加到总资产，不加到可用余额
// 原因：Spot 和 Perpetuals 是独立帐户，需手动 ClassTransfer 才能转账
totalWalletBalance := walletBalanceWithoutUnrealized + spotUSDCBalance
result["totalWalletBalance"] = totalWalletBalance // 總資產（Perp + Spot）
result["availableBalance"] = availableBalance // 可用餘額（僅 Perpetuals，不含 Spot）
result["totalUnrealizedProfit"] = totalUnrealizedPnl // 未實現盈虧（僅來自 Perpetuals）
result["spotBalance"] = spotUSDCBalance // Spot 現貨餘額（單獨返回）
result["totalWalletBalance"] = totalWalletBalance // 总资产（Perp + Spot）
result["availableBalance"] = availableBalance // 可用余额（仅 Perpetuals，不含 Spot）
result["totalUnrealizedProfit"] = totalUnrealizedPnl // 未实现盈亏（仅来自 Perpetuals）
result["spotBalance"] = spotUSDCBalance // Spot 现货余额（单独返回）
log.Printf("✓ Hyperliquid 完整账户:")
log.Printf(" • Spot 现货余额: %.2f USDC （需手动转账到 Perpetuals 才能开仓）", spotUSDCBalance)
@@ -186,9 +233,9 @@ func (t *HyperliquidTrader) GetBalance() (map[string]interface{}, error) {
accountValue,
walletBalanceWithoutUnrealized,
totalUnrealizedPnl)
log.Printf(" • Perpetuals 可用余额: %.2f USDC （可直接用於開倉）", availableBalance)
log.Printf(" • Perpetuals 可用余额: %.2f USDC （可直接用于开仓）", availableBalance)
log.Printf(" • 保证金占用: %.2f USDC", totalMarginUsed)
log.Printf(" • 總資產 (Perp+Spot): %.2f USDC", totalWalletBalance)
log.Printf(" • 总资产 (Perp+Spot): %.2f USDC", totalWalletBalance)
log.Printf(" ⭐ 总资产: %.2f USDC | Perp 可用: %.2f USDC | Spot 余额: %.2f USDC",
totalWalletBalance, availableBalance, spotUSDCBalance)
@@ -289,6 +336,41 @@ func (t *HyperliquidTrader) SetLeverage(symbol string, leverage int) error {
return nil
}
// refreshMetaIfNeeded 当 Meta 信息失效时刷新（Asset ID 为 0 时触发）
func (t *HyperliquidTrader) refreshMetaIfNeeded(coin string) error {
assetID := t.exchange.Info().NameToAsset(coin)
if assetID != 0 {
return nil // Meta 正常，无需刷新
}
log.Printf("⚠️ %s 的 Asset ID 为 0，尝试刷新 Meta 信息...", coin)
// 刷新 Meta 信息
meta, err := t.exchange.Info().Meta(t.ctx)
if err != nil {
return fmt.Errorf("刷新 Meta 信息失败: %w", err)
}
// ✅ 并发安全：使用写锁保护 meta 字段更新
t.metaMutex.Lock()
t.meta = meta
t.metaMutex.Unlock()
log.Printf("✅ Meta 信息已刷新，包含 %d 个资产", len(meta.Universe))
// 验证刷新后的 Asset ID
assetID = t.exchange.Info().NameToAsset(coin)
if assetID == 0 {
return fmt.Errorf("❌ 即使在刷新 Meta 后，资产 %s 的 Asset ID 仍为 0。可能原因：\n"+
" 1. 该币种未在 Hyperliquid 上市\n"+
" 2. 币种名称错误（应为 BTC 而非 BTCUSDT）\n"+
" 3. API 连接问题", coin)
}
log.Printf("✅ 刷新后 Asset ID 检查通过: %s -> %d", coin, assetID)
return nil
}
// OpenLong 开多仓
func (t *HyperliquidTrader) OpenLong(symbol string, quantity float64, leverage int) (map[string]interface{}, error) {
// 先取消该币种的所有委托单
@@ -551,7 +633,6 @@ func (t *HyperliquidTrader) CloseShort(symbol string, quantity float64) (map[str
// CancelStopOrders 取消该币种的止盈/止
// CancelStopLossOrders 仅取消止损单（Hyperliquid 暂无法区分止损和止盈，取消所有）
func (t *HyperliquidTrader) CancelStopLossOrders(symbol string) error {
// Hyperliquid SDK 的 OpenOrder 结构不暴露 trigger 字段
@@ -734,6 +815,10 @@ func (t *HyperliquidTrader) FormatQuantity(symbol string, quantity float64) (str
// getSzDecimals 获取币种的数量精度
func (t *HyperliquidTrader) getSzDecimals(coin string) int {
// ✅ 并发安全：使用读锁保护 meta 字段访问
t.metaMutex.RLock()
defer t.metaMutex.RUnlock()
if t.meta == nil {
log.Printf("⚠️ meta信息为空，使用默认精度4")
return 4 // 默认精度

192
trader/hyperliquid_trader_race_test.go Normal file
View File

@@ -0,0 +1,192 @@
package trader
import (
"context"
"sync"
"testing"
"github.com/sonirico/go-hyperliquid"
)
// TestMetaConcurrentAccess tests that concurrent access to meta field is safe
func TestMetaConcurrentAccess(t *testing.T) {
// Create a HyperliquidTrader instance with meta initialized
trader := &HyperliquidTrader{
ctx: context.Background(),
meta: &hyperliquid.Meta{
Universe: []hyperliquid.AssetInfo{
{Name: "BTC", SzDecimals: 5},
{Name: "ETH", SzDecimals: 4},
},
},
metaMutex: sync.RWMutex{},
}
// Number of concurrent goroutines
concurrency := 100
var wg sync.WaitGroup
// Test concurrent reads (getSzDecimals)
for i := 0; i < concurrency; i++ {
wg.Add(1)
go func() {
defer wg.Done()
// This should not cause race conditions
decimals := trader.getSzDecimals("BTC")
if decimals != 5 {
t.Errorf("Expected decimals 5, got %d", decimals)
}
}()
}
wg.Wait()
}
// TestMetaConcurrentReadWrite tests concurrent reads and writes to meta field
func TestMetaConcurrentReadWrite(t *testing.T) {
trader := &HyperliquidTrader{
ctx: context.Background(),
meta: &hyperliquid.Meta{
Universe: []hyperliquid.AssetInfo{
{Name: "BTC", SzDecimals: 5},
},
},
metaMutex: sync.RWMutex{},
}
var wg sync.WaitGroup
concurrency := 50
// Concurrent readers
for i := 0; i < concurrency; i++ {
wg.Add(1)
go func() {
defer wg.Done()
trader.getSzDecimals("BTC")
}()
}
// Concurrent writers (simulating meta refresh)
for i := 0; i < 10; i++ {
wg.Add(1)
go func(iteration int) {
defer wg.Done()
// Simulate meta update
trader.metaMutex.Lock()
trader.meta = &hyperliquid.Meta{
Universe: []hyperliquid.AssetInfo{
{Name: "BTC", SzDecimals: 5 + iteration%3},
{Name: "ETH", SzDecimals: 4},
},
}
trader.metaMutex.Unlock()
}(i)
}
wg.Wait()
// Verify meta is not nil after all operations
trader.metaMutex.RLock()
if trader.meta == nil {
t.Error("Meta should not be nil after concurrent operations")
}
trader.metaMutex.RUnlock()
}
// TestGetSzDecimals_NilMeta tests getSzDecimals with nil meta
func TestGetSzDecimals_NilMeta(t *testing.T) {
trader := &HyperliquidTrader{
meta: nil,
metaMutex: sync.RWMutex{},
}
// Should return default value 4 when meta is nil
decimals := trader.getSzDecimals("BTC")
expectedDecimals := 4
if decimals != expectedDecimals {
t.Errorf("Expected default decimals %d for nil meta, got %d", expectedDecimals, decimals)
}
}
// TestGetSzDecimals_ValidMeta tests getSzDecimals with valid meta
func TestGetSzDecimals_ValidMeta(t *testing.T) {
trader := &HyperliquidTrader{
meta: &hyperliquid.Meta{
Universe: []hyperliquid.AssetInfo{
{Name: "BTC", SzDecimals: 5},
{Name: "ETH", SzDecimals: 4},
{Name: "SOL", SzDecimals: 3},
},
},
metaMutex: sync.RWMutex{},
}
tests := []struct {
coin string
expectedDecimals int
}{
{"BTC", 5},
{"ETH", 4},
{"SOL", 3},
}
for _, tt := range tests {
t.Run(tt.coin, func(t *testing.T) {
decimals := trader.getSzDecimals(tt.coin)
if decimals != tt.expectedDecimals {
t.Errorf("For coin %s, expected decimals %d, got %d", tt.coin, tt.expectedDecimals, decimals)
}
})
}
}
// TestMetaMutex_NoRaceCondition tests that using -race detector finds no issues
// Run with: go test -race -run TestMetaMutex_NoRaceCondition
func TestMetaMutex_NoRaceCondition(t *testing.T) {
trader := &HyperliquidTrader{
ctx: context.Background(),
meta: &hyperliquid.Meta{
Universe: []hyperliquid.AssetInfo{
{Name: "BTC", SzDecimals: 5},
{Name: "ETH", SzDecimals: 4},
},
},
metaMutex: sync.RWMutex{},
}
var wg sync.WaitGroup
iterations := 1000
// Massive concurrent reads
for i := 0; i < iterations; i++ {
wg.Add(1)
go func() {
defer wg.Done()
trader.getSzDecimals("BTC")
trader.getSzDecimals("ETH")
}()
}
// Concurrent writes
for i := 0; i < 100; i++ {
wg.Add(1)
go func(idx int) {
defer wg.Done()
trader.metaMutex.Lock()
trader.meta = &hyperliquid.Meta{
Universe: []hyperliquid.AssetInfo{
{Name: "BTC", SzDecimals: 5},
{Name: "ETH", SzDecimals: 4},
{Name: "SOL", SzDecimals: 3},
},
}
trader.metaMutex.Unlock()
}(i)
}
wg.Wait()
// If we reach here without race detector errors, the test passes
t.Log("No race conditions detected in concurrent meta access")
}

646
trader/hyperliquid_trader_test.go Normal file
View File

@@ -0,0 +1,646 @@
package trader
import (
"context"
"crypto/ecdsa"
"encoding/json"
"net/http"
"net/http/httptest"
"testing"
"github.com/ethereum/go-ethereum/crypto"
"github.com/sonirico/go-hyperliquid"
"github.com/stretchr/testify/assert"
)
// ============================================================
// 一、HyperliquidTestSuite - 继承 base test suite
// ============================================================
// HyperliquidTestSuite Hyperliquid 交易器测试套件
// 继承 TraderTestSuite 并添加 Hyperliquid 特定的 mock 逻辑
type HyperliquidTestSuite struct {
*TraderTestSuite // 嵌入基础测试套件
mockServer *httptest.Server
privateKey *ecdsa.PrivateKey
}
// NewHyperliquidTestSuite 创建 Hyperliquid 测试套件
func NewHyperliquidTestSuite(t *testing.T) *HyperliquidTestSuite {
// 创建测试用私钥
privateKey, err := crypto.HexToECDSA("0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef")
if err != nil {
t.Fatalf("创建测试私钥失败: %v", err)
}
// 创建 mock HTTP 服务器
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
// 根据不同的请求路径返回不同的 mock 响应
var respBody interface{}
// Hyperliquid API 使用 POST 请求，请求体是 JSON
// 我们需要根据请求体中的 "type" 字段来区分不同的请求
var reqBody map[string]interface{}
if r.Method == "POST" {
json.NewDecoder(r.Body).Decode(&reqBody)
}
// Try to get type from top level first, then from action object
reqType, _ := reqBody["type"].(string)
if reqType == "" && reqBody["action"] != nil {
if action, ok := reqBody["action"].(map[string]interface{}); ok {
reqType, _ = action["type"].(string)
}
}
switch reqType {
// Mock Meta - 获取市场元数据
case "meta":
respBody = map[string]interface{}{
"universe": []map[string]interface{}{
{
"name": "BTC",
"szDecimals": 4,
"maxLeverage": 50,
"onlyIsolated": false,
"isDelisted": false,
"marginTableId": 0,
},
{
"name": "ETH",
"szDecimals": 3,
"maxLeverage": 50,
"onlyIsolated": false,
"isDelisted": false,
"marginTableId": 0,
},
},
"marginTables": []interface{}{},
}
// Mock UserState - 获取用户账户状态（用于 GetBalance 和 GetPositions）
case "clearinghouseState":
user, _ := reqBody["user"].(string)
// 检查是否是查询 Agent 钱包余额（用于安全检查）
agentAddr := crypto.PubkeyToAddress(privateKey.PublicKey).Hex()
if user == agentAddr {
// Agent 钱包余额应该很低
respBody = map[string]interface{}{
"crossMarginSummary": map[string]interface{}{
"accountValue": "5.00",
"totalMarginUsed": "0.00",
},
"withdrawable": "5.00",
"assetPositions": []interface{}{},
}
} else {
// 主钱包账户状态
respBody = map[string]interface{}{
"crossMarginSummary": map[string]interface{}{
"accountValue": "10000.00",
"totalMarginUsed": "2000.00",
},
"withdrawable": "8000.00",
"assetPositions": []map[string]interface{}{
{
"position": map[string]interface{}{
"coin": "BTC",
"szi": "0.5",
"entryPx": "50000.00",
"liquidationPx": "45000.00",
"positionValue": "25000.00",
"unrealizedPnl": "100.50",
"leverage": map[string]interface{}{
"type": "cross",
"value": 10,
},
},
},
},
}
}
// Mock SpotUserState - 获取现货账户状态
case "spotClearinghouseState":
respBody = map[string]interface{}{
"balances": []map[string]interface{}{
{
"coin": "USDC",
"total": "500.00",
},
},
}
// Mock SpotMeta - 获取现货市场元数据
case "spotMeta":
respBody = map[string]interface{}{
"universe": []map[string]interface{}{},
"tokens": []map[string]interface{}{},
}
// Mock AllMids - 获取所有市场价格
case "allMids":
respBody = map[string]string{
"BTC": "50000.00",
"ETH": "3000.00",
}
// Mock OpenOrders - 获取挂单列表
case "openOrders":
respBody = []interface{}{}
// Mock Order - 创建订单（开仓、平仓、止损、止盈）
case "order":
respBody = map[string]interface{}{
"status": "ok",
"response": map[string]interface{}{
"type": "order",
"data": map[string]interface{}{
"statuses": []map[string]interface{}{
{
"filled": map[string]interface{}{
"totalSz": "0.01",
"avgPx": "50000.00",
},
},
},
},
},
}
// Mock UpdateLeverage - 设置杠杆
case "updateLeverage":
respBody = map[string]interface{}{
"status": "ok",
}
// Mock Cancel - 取消订单
case "cancel":
respBody = map[string]interface{}{
"status": "ok",
}
default:
// 默认返回成功响应
respBody = map[string]interface{}{
"status": "ok",
}
}
// 序列化响应
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(respBody)
}))
// 创建 HyperliquidTrader，使用 mock 服务器 URL
walletAddr := "0x9999999999999999999999999999999999999999"
ctx := context.Background()
// 创建 Exchange 客户端，指向 mock 服务器
exchange := hyperliquid.NewExchange(
ctx,
privateKey,
mockServer.URL, // 使用 mock 服务器 URL
nil,
"",
walletAddr,
nil,
)
// 创建 meta（模拟获取成功）
meta := &hyperliquid.Meta{
Universe: []hyperliquid.AssetInfo{
{Name: "BTC", SzDecimals: 4},
{Name: "ETH", SzDecimals: 3},
},
}
trader := &HyperliquidTrader{
exchange: exchange,
ctx: ctx,
walletAddr: walletAddr,
meta: meta,
isCrossMargin: true,
}
// 创建基础套件
baseSuite := NewTraderTestSuite(t, trader)
return &HyperliquidTestSuite{
TraderTestSuite: baseSuite,
mockServer: mockServer,
privateKey: privateKey,
}
}
// Cleanup 清理资源
func (s *HyperliquidTestSuite) Cleanup() {
if s.mockServer != nil {
s.mockServer.Close()
}
s.TraderTestSuite.Cleanup()
}
// ============================================================
// 二、使用 HyperliquidTestSuite 运行通用测试
// ============================================================
// TestHyperliquidTrader_InterfaceCompliance 测试接口兼容性
func TestHyperliquidTrader_InterfaceCompliance(t *testing.T) {
var _ Trader = (*HyperliquidTrader)(nil)
}
// TestHyperliquidTrader_CommonInterface 使用测试套件运行所有通用接口测试
func TestHyperliquidTrader_CommonInterface(t *testing.T) {
// 创建测试套件
suite := NewHyperliquidTestSuite(t)
defer suite.Cleanup()
// 运行所有通用接口测试
suite.RunAllTests()
}
// ============================================================
// 三、Hyperliquid 特定功能的单元测试
// ============================================================
// TestNewHyperliquidTrader 测试创建 Hyperliquid 交易器
func TestNewHyperliquidTrader(t *testing.T) {
tests := []struct {
name string
privateKeyHex string
walletAddr string
testnet bool
wantError bool
errorContains string
}{
{
name: "无效私钥格式",
privateKeyHex: "invalid_key",
walletAddr: "0x1234567890123456789012345678901234567890",
testnet: true,
wantError: true,
errorContains: "解析私钥失败",
},
{
name: "钱包地址为空",
privateKeyHex: "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
walletAddr: "",
testnet: true,
wantError: true,
errorContains: "Configuration error",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
trader, err := NewHyperliquidTrader(tt.privateKeyHex, tt.walletAddr, tt.testnet)
if tt.wantError {
assert.Error(t, err)
if tt.errorContains != "" {
assert.Contains(t, err.Error(), tt.errorContains)
}
assert.Nil(t, trader)
} else {
assert.NoError(t, err)
assert.NotNil(t, trader)
if trader != nil {
assert.Equal(t, tt.walletAddr, trader.walletAddr)
assert.NotNil(t, trader.exchange)
}
}
})
}
}
// TestNewHyperliquidTrader_Success 测试成功创建交易器（需要 mock HTTP）
func TestNewHyperliquidTrader_Success(t *testing.T) {
// 创建测试用私钥
privateKey, _ := crypto.HexToECDSA("0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef")
agentAddr := crypto.PubkeyToAddress(privateKey.PublicKey).Hex()
// 创建 mock HTTP 服务器
mockServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
var reqBody map[string]interface{}
json.NewDecoder(r.Body).Decode(&reqBody)
reqType, _ := reqBody["type"].(string)
var respBody interface{}
switch reqType {
case "meta":
respBody = map[string]interface{}{
"universe": []map[string]interface{}{
{
"name": "BTC",
"szDecimals": 4,
"maxLeverage": 50,
"onlyIsolated": false,
"isDelisted": false,
"marginTableId": 0,
},
},
"marginTables": []interface{}{},
}
case "clearinghouseState":
user, _ := reqBody["user"].(string)
if user == agentAddr {
// Agent 钱包余额低
respBody = map[string]interface{}{
"crossMarginSummary": map[string]interface{}{
"accountValue": "5.00",
},
"assetPositions": []interface{}{},
}
} else {
// 主钱包
respBody = map[string]interface{}{
"crossMarginSummary": map[string]interface{}{
"accountValue": "10000.00",
},
"assetPositions": []interface{}{},
}
}
default:
respBody = map[string]interface{}{"status": "ok"}
}
w.Header().Set("Content-Type", "application/json")
json.NewEncoder(w).Encode(respBody)
}))
defer mockServer.Close()
// 注意：这个测试会真正调用 NewHyperliquidTrader，但会失败
// 因为 hyperliquid SDK 不允许我们在构造函数中注入自定义 URL
// 所以这个测试仅用于验证参数处理逻辑
t.Skip("跳过此测试：hyperliquid SDK 在构造时会调用真实 API，无法注入 mock URL")
}
// ============================================================
// 四、工具函数单元测试（Hyperliquid 特有）
// ============================================================
// TestConvertSymbolToHyperliquid 测试 symbol 转换函数
func TestConvertSymbolToHyperliquid(t *testing.T) {
tests := []struct {
name string
symbol string
expected string
}{
{
name: "BTCUSDT转换",
symbol: "BTCUSDT",
expected: "BTC",
},
{
name: "ETHUSDT转换",
symbol: "ETHUSDT",
expected: "ETH",
},
{
name: "无USDT后缀",
symbol: "BTC",
expected: "BTC",
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := convertSymbolToHyperliquid(tt.symbol)
assert.Equal(t, tt.expected, result)
})
}
}
// TestAbsFloat 测试绝对值函数
func TestAbsFloat(t *testing.T) {
tests := []struct {
name string
input float64
expected float64
}{
{
name: "正数",
input: 10.5,
expected: 10.5,
},
{
name: "负数",
input: -10.5,
expected: 10.5,
},
{
name: "零",
input: 0,
expected: 0,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := absFloat(tt.input)
assert.Equal(t, tt.expected, result)
})
}
}
// TestHyperliquidTrader_RoundToSzDecimals 测试数量精度处理
func TestHyperliquidTrader_RoundToSzDecimals(t *testing.T) {
trader := &HyperliquidTrader{
meta: &hyperliquid.Meta{
Universe: []hyperliquid.AssetInfo{
{Name: "BTC", SzDecimals: 4},
{Name: "ETH", SzDecimals: 3},
},
},
}
tests := []struct {
name string
coin string
quantity float64
expected float64
}{
{
name: "BTC_四舍五入到4位",
coin: "BTC",
quantity: 1.23456789,
expected: 1.2346,
},
{
name: "ETH_四舍五入到3位",
coin: "ETH",
quantity: 10.12345,
expected: 10.123,
},
{
name: "未知币种_使用默认精度4位",
coin: "UNKNOWN",
quantity: 1.23456789,
expected: 1.2346,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := trader.roundToSzDecimals(tt.coin, tt.quantity)
assert.InDelta(t, tt.expected, result, 0.0001)
})
}
}
// TestHyperliquidTrader_RoundPriceToSigfigs 测试价格有效数字处理
func TestHyperliquidTrader_RoundPriceToSigfigs(t *testing.T) {
trader := &HyperliquidTrader{}
tests := []struct {
name string
price float64
expected float64
}{
{
name: "BTC价格_5位有效数字",
price: 50123.456789,
expected: 50123.0,
},
{
name: "小数价格_5位有效数字",
price: 0.0012345678,
expected: 0.0012346,
},
{
name: "零价格",
price: 0,
expected: 0,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result := trader.roundPriceToSigfigs(tt.price)
assert.InDelta(t, tt.expected, result, tt.expected*0.001)
})
}
}
// TestHyperliquidTrader_GetSzDecimals 测试获取精度
func TestHyperliquidTrader_GetSzDecimals(t *testing.T) {
tests := []struct {
name string
meta *hyperliquid.Meta
coin string
expected int
}{
{
name: "meta为nil_返回默认精度",
meta: nil,
coin: "BTC",
expected: 4,
},
{
name: "找到BTC_返回正确精度",
meta: &hyperliquid.Meta{
Universe: []hyperliquid.AssetInfo{
{Name: "BTC", SzDecimals: 5},
},
},
coin: "BTC",
expected: 5,
},
{
name: "未找到币种_返回默认精度",
meta: &hyperliquid.Meta{
Universe: []hyperliquid.AssetInfo{
{Name: "ETH", SzDecimals: 3},
},
},
coin: "BTC",
expected: 4,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
trader := &HyperliquidTrader{meta: tt.meta}
result := trader.getSzDecimals(tt.coin)
assert.Equal(t, tt.expected, result)
})
}
}
// TestHyperliquidTrader_SetMarginMode 测试设置保证金模式
func TestHyperliquidTrader_SetMarginMode(t *testing.T) {
trader := &HyperliquidTrader{
ctx: context.Background(),
isCrossMargin: true,
}
tests := []struct {
name string
symbol string
isCrossMargin bool
wantError bool
}{
{
name: "设置为全仓模式",
symbol: "BTCUSDT",
isCrossMargin: true,
wantError: false,
},
{
name: "设置为逐仓模式",
symbol: "ETHUSDT",
isCrossMargin: false,
wantError: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := trader.SetMarginMode(tt.symbol, tt.isCrossMargin)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
assert.Equal(t, tt.isCrossMargin, trader.isCrossMargin)
}
})
}
}
// TestNewHyperliquidTrader_PrivateKeyProcessing 测试私钥处理
func TestNewHyperliquidTrader_PrivateKeyProcessing(t *testing.T) {
tests := []struct {
name string
privateKeyHex string
shouldStripOx bool
expectedLength int
}{
{
name: "带0x前缀的私钥",
privateKeyHex: "0x0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
shouldStripOx: true,
expectedLength: 64,
},
{
name: "无前缀的私钥",
privateKeyHex: "0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef",
shouldStripOx: false,
expectedLength: 64,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// 测试私钥前缀处理逻辑（不实际创建 trader）
processed := tt.privateKeyHex
if len(processed) > 2 && (processed[:2] == "0x" || processed[:2] == "0X") {
processed = processed[2:]
}
assert.Equal(t, tt.expectedLength, len(processed))
})
}
}

393
trader/partial_close_test.go Normal file
View File

@@ -0,0 +1,393 @@
package trader
import (
"fmt"
"nofx/decision"
"nofx/logger"
"testing"
)
// MockPartialCloseTrader 用於測試 partial close 邏輯
type MockPartialCloseTrader struct {
positions []map[string]interface{}
closePartialCalled bool
closeLongCalled bool
closeShortCalled bool
stopLossCalled bool
takeProfitCalled bool
lastStopLoss float64
lastTakeProfit float64
}
func (m *MockPartialCloseTrader) GetPositions() ([]map[string]interface{}, error) {
return m.positions, nil
}
func (m *MockPartialCloseTrader) ClosePartialLong(symbol string, quantity float64) (map[string]interface{}, error) {
m.closePartialCalled = true
return map[string]interface{}{"orderId": "12345"}, nil
}
func (m *MockPartialCloseTrader) ClosePartialShort(symbol string, quantity float64) (map[string]interface{}, error) {
m.closePartialCalled = true
return map[string]interface{}{"orderId": "12345"}, nil
}
func (m *MockPartialCloseTrader) CloseLong(symbol string, quantity float64) (map[string]interface{}, error) {
m.closeLongCalled = true
return map[string]interface{}{"orderId": "12346"}, nil
}
func (m *MockPartialCloseTrader) CloseShort(symbol string, quantity float64) (map[string]interface{}, error) {
m.closeShortCalled = true
return map[string]interface{}{"orderId": "12346"}, nil
}
func (m *MockPartialCloseTrader) SetStopLoss(symbol, side string, quantity, price float64) error {
m.stopLossCalled = true
m.lastStopLoss = price
return nil
}
func (m *MockPartialCloseTrader) SetTakeProfit(symbol, side string, quantity, price float64) error {
m.takeProfitCalled = true
m.lastTakeProfit = price
return nil
}
// TestPartialCloseMinPositionCheck 測試最小倉位檢查邏輯
func TestPartialCloseMinPositionCheck(t *testing.T) {
tests := []struct {
name string
totalQuantity float64
markPrice float64
closePercentage float64
expectFullClose bool // 是否應該觸發全平邏輯
expectRemainValue float64
}{
{
name: "正常部分平倉_剩餘價值充足",
totalQuantity: 1.0,
markPrice: 100.0,
closePercentage: 50.0,
expectFullClose: false,
expectRemainValue: 50.0, // 剩餘 0.5 * 100 = 50 USDT
},
{
name: "部分平倉_剩餘價值小於10USDT_應該全平",
totalQuantity: 0.2,
markPrice: 100.0,
closePercentage: 95.0, // 平倉 95%，剩餘 1 USDT (0.2 * 5% * 100)
expectFullClose: true,
expectRemainValue: 1.0,
},
{
name: "部分平倉_剩餘價值剛好10USDT_應該全平",
totalQuantity: 1.0,
markPrice: 100.0,
closePercentage: 90.0, // 剩餘 10 USDT (1.0 * 10% * 100)，邊界測試 (<=)
expectFullClose: true,
expectRemainValue: 10.0,
},
{
name: "部分平倉_剩餘價值11USDT_不應全平",
totalQuantity: 1.1,
markPrice: 100.0,
closePercentage: 90.0, // 剩餘 11 USDT (1.1 * 10% * 100)
expectFullClose: false,
expectRemainValue: 11.0,
},
{
name: "大倉位部分平倉_剩餘價值遠大於10USDT",
totalQuantity: 10.0,
markPrice: 1000.0,
closePercentage: 80.0,
expectFullClose: false,
expectRemainValue: 2000.0, // 剩餘 2 * 1000 = 2000 USDT
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// 計算剩餘價值
closeQuantity := tt.totalQuantity * (tt.closePercentage / 100.0)
remainingQuantity := tt.totalQuantity - closeQuantity
remainingValue := remainingQuantity * tt.markPrice
// 驗證計算（使用浮點數比較允許微小誤差）
const epsilon = 0.001
if remainingValue-tt.expectRemainValue > epsilon || tt.expectRemainValue-remainingValue > epsilon {
t.Errorf("計算錯誤: 剩餘價值 = %.2f, 期望 = %.2f",
remainingValue, tt.expectRemainValue)
}
// 驗證最小倉位檢查邏輯
const MIN_POSITION_VALUE = 10.0
shouldFullClose := remainingValue > 0 && remainingValue <= MIN_POSITION_VALUE
if shouldFullClose != tt.expectFullClose {
t.Errorf("最小倉位檢查失敗: shouldFullClose = %v, 期望 = %v (剩餘價值 = %.2f USDT)",
shouldFullClose, tt.expectFullClose, remainingValue)
}
})
}
}
// TestPartialCloseWithStopLossTakeProfitRecovery 測試止盈止損恢復邏輯
func TestPartialCloseWithStopLossTakeProfitRecovery(t *testing.T) {
tests := []struct {
name string
newStopLoss float64
newTakeProfit float64
expectStopLoss bool
expectTakeProfit bool
}{
{
name: "有新止損和止盈_應該恢復兩者",
newStopLoss: 95.0,
newTakeProfit: 110.0,
expectStopLoss: true,
expectTakeProfit: true,
},
{
name: "只有新止損_僅恢復止損",
newStopLoss: 95.0,
newTakeProfit: 0,
expectStopLoss: true,
expectTakeProfit: false,
},
{
name: "只有新止盈_僅恢復止盈",
newStopLoss: 0,
newTakeProfit: 110.0,
expectStopLoss: false,
expectTakeProfit: true,
},
{
name: "沒有新止損止盈_不恢復",
newStopLoss: 0,
newTakeProfit: 0,
expectStopLoss: false,
expectTakeProfit: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// 模擬止盈止損恢復邏輯
stopLossRecovered := tt.newStopLoss > 0
takeProfitRecovered := tt.newTakeProfit > 0
if stopLossRecovered != tt.expectStopLoss {
t.Errorf("止損恢復邏輯錯誤: recovered = %v, 期望 = %v",
stopLossRecovered, tt.expectStopLoss)
}
if takeProfitRecovered != tt.expectTakeProfit {
t.Errorf("止盈恢復邏輯錯誤: recovered = %v, 期望 = %v",
takeProfitRecovered, tt.expectTakeProfit)
}
})
}
}
// TestPartialCloseEdgeCases 測試邊界情況
func TestPartialCloseEdgeCases(t *testing.T) {
tests := []struct {
name string
closePercentage float64
totalQuantity float64
markPrice float64
expectError bool
errorContains string
}{
{
name: "平倉百分比為0_應該報錯",
closePercentage: 0,
totalQuantity: 1.0,
markPrice: 100.0,
expectError: true,
errorContains: "0-100",
},
{
name: "平倉百分比超過100_應該報錯",
closePercentage: 101.0,
totalQuantity: 1.0,
markPrice: 100.0,
expectError: true,
errorContains: "0-100",
},
{
name: "平倉百分比為負數_應該報錯",
closePercentage: -10.0,
totalQuantity: 1.0,
markPrice: 100.0,
expectError: true,
errorContains: "0-100",
},
{
name: "正常範圍_不應報錯",
closePercentage: 50.0,
totalQuantity: 1.0,
markPrice: 100.0,
expectError: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// 模擬百分比驗證邏輯
var err error
if tt.closePercentage <= 0 || tt.closePercentage > 100 {
err = fmt.Errorf("平仓百分比必须在 0-100 之间，当前: %.1f", tt.closePercentage)
}
if tt.expectError {
if err == nil {
t.Errorf("期望報錯但沒有報錯")
}
} else {
if err != nil {
t.Errorf("不應報錯但報錯了: %v", err)
}
}
})
}
}
// TestPartialCloseIntegration 整合測試（使用 mock trader）
func TestPartialCloseIntegration(t *testing.T) {
tests := []struct {
name string
symbol string
side string
totalQuantity float64
markPrice float64
closePercentage float64
newStopLoss float64
newTakeProfit float64
expectFullClose bool
expectStopLossCall bool
expectTakeProfitCall bool
}{
{
name: "LONG倉_正常部分平倉_有止盈止損",
symbol: "BTCUSDT",
side: "LONG",
totalQuantity: 1.0,
markPrice: 50000.0,
closePercentage: 50.0,
newStopLoss: 48000.0,
newTakeProfit: 52000.0,
expectFullClose: false,
expectStopLossCall: true,
expectTakeProfitCall: true,
},
{
name: "SHORT倉_剩餘價值過小_應自動全平",
symbol: "ETHUSDT",
side: "SHORT",
totalQuantity: 0.02,
markPrice: 3000.0, // 總價值 60 USDT
closePercentage: 95.0, // 剩餘 3 USDT < 10 USDT
newStopLoss: 3100.0,
newTakeProfit: 2900.0,
expectFullClose: true,
expectStopLossCall: false, // 全平不需要恢復止盈止損
expectTakeProfitCall: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// 創建 mock trader
mockTrader := &MockPartialCloseTrader{
positions: []map[string]interface{}{
{
"symbol": tt.symbol,
"side": tt.side,
"quantity": tt.totalQuantity,
"markPrice": tt.markPrice,
},
},
}
// 創建決策
dec := &decision.Decision{
Symbol: tt.symbol,
Action: "partial_close",
ClosePercentage: tt.closePercentage,
NewStopLoss: tt.newStopLoss,
NewTakeProfit: tt.newTakeProfit,
}
// 創建 actionRecord
actionRecord := &logger.DecisionAction{}
// 計算剩餘價值
closeQuantity := tt.totalQuantity * (tt.closePercentage / 100.0)
remainingQuantity := tt.totalQuantity - closeQuantity
remainingValue := remainingQuantity * tt.markPrice
// 驗證最小倉位檢查
const MIN_POSITION_VALUE = 10.0
shouldFullClose := remainingValue > 0 && remainingValue <= MIN_POSITION_VALUE
if shouldFullClose != tt.expectFullClose {
t.Errorf("最小倉位檢查不符: shouldFullClose = %v, 期望 = %v (剩餘 %.2f USDT)",
shouldFullClose, tt.expectFullClose, remainingValue)
}
// 模擬執行邏輯
if shouldFullClose {
// 應該轉為全平
if tt.side == "LONG" {
mockTrader.CloseLong(tt.symbol, tt.totalQuantity)
} else {
mockTrader.CloseShort(tt.symbol, tt.totalQuantity)
}
} else {
// 正常部分平倉
if tt.side == "LONG" {
mockTrader.ClosePartialLong(tt.symbol, closeQuantity)
} else {
mockTrader.ClosePartialShort(tt.symbol, closeQuantity)
}
// 恢復止盈止損
if dec.NewStopLoss > 0 {
mockTrader.SetStopLoss(tt.symbol, tt.side, remainingQuantity, dec.NewStopLoss)
}
if dec.NewTakeProfit > 0 {
mockTrader.SetTakeProfit(tt.symbol, tt.side, remainingQuantity, dec.NewTakeProfit)
}
}
// 驗證調用
if tt.expectFullClose {
if !mockTrader.closeLongCalled && !mockTrader.closeShortCalled {
t.Error("期望調用全平但沒有調用")
}
if mockTrader.closePartialCalled {
t.Error("不應該調用部分平倉")
}
} else {
if !mockTrader.closePartialCalled {
t.Error("期望調用部分平倉但沒有調用")
}
}
if mockTrader.stopLossCalled != tt.expectStopLossCall {
t.Errorf("止損調用不符: called = %v, 期望 = %v",
mockTrader.stopLossCalled, tt.expectStopLossCall)
}
if mockTrader.takeProfitCalled != tt.expectTakeProfitCall {
t.Errorf("止盈調用不符: called = %v, 期望 = %v",
mockTrader.takeProfitCalled, tt.expectTakeProfitCall)
}
_ = actionRecord // 避免未使用警告
})
}
}

664
trader/trader_test_suite.go Normal file
View File

@@ -0,0 +1,664 @@
package trader
import (
"testing"
"github.com/agiledragon/gomonkey/v2"
"github.com/stretchr/testify/assert"
)
// TraderTestSuite 通用的 Trader 接口测试套件（基础套件）
// 用于黑盒测试任何实现了 Trader 接口的交易器
//
// 使用方式：
// 1. 创建具体的测试套件结构体，嵌入 TraderTestSuite
// 2. 实现 SetupMocks() 方法来配置 gomonkey mock
// 3. 调用 RunAllTests() 运行所有通用测试
type TraderTestSuite struct {
T *testing.T
Trader Trader
Patches *gomonkey.Patches
}
// NewTraderTestSuite 创建新的基础测试套件
func NewTraderTestSuite(t *testing.T, trader Trader) *TraderTestSuite {
return &TraderTestSuite{
T: t,
Trader: trader,
Patches: gomonkey.NewPatches(),
}
}
// Cleanup 清理 mock patches
func (s *TraderTestSuite) Cleanup() {
if s.Patches != nil {
s.Patches.Reset()
}
}
// RunAllTests 运行所有通用接口测试
// 注意：调用此方法前，请先通过 SetupMocks 设置好所需的 mock
func (s *TraderTestSuite) RunAllTests() {
// 基础查询方法
s.T.Run("GetBalance", func(t *testing.T) { s.TestGetBalance() })
s.T.Run("GetPositions", func(t *testing.T) { s.TestGetPositions() })
s.T.Run("GetMarketPrice", func(t *testing.T) { s.TestGetMarketPrice() })
// 配置方法
s.T.Run("SetLeverage", func(t *testing.T) { s.TestSetLeverage() })
s.T.Run("SetMarginMode", func(t *testing.T) { s.TestSetMarginMode() })
s.T.Run("FormatQuantity", func(t *testing.T) { s.TestFormatQuantity() })
// 核心交易方法
s.T.Run("OpenLong", func(t *testing.T) { s.TestOpenLong() })
s.T.Run("OpenShort", func(t *testing.T) { s.TestOpenShort() })
s.T.Run("CloseLong", func(t *testing.T) { s.TestCloseLong() })
s.T.Run("CloseShort", func(t *testing.T) { s.TestCloseShort() })
// 止损止盈
s.T.Run("SetStopLoss", func(t *testing.T) { s.TestSetStopLoss() })
s.T.Run("SetTakeProfit", func(t *testing.T) { s.TestSetTakeProfit() })
// 订单管理
s.T.Run("CancelAllOrders", func(t *testing.T) { s.TestCancelAllOrders() })
s.T.Run("CancelStopOrders", func(t *testing.T) { s.TestCancelStopOrders() })
s.T.Run("CancelStopLossOrders", func(t *testing.T) { s.TestCancelStopLossOrders() })
s.T.Run("CancelTakeProfitOrders", func(t *testing.T) { s.TestCancelTakeProfitOrders() })
}
// TestGetBalance 测试获取账户余额
func (s *TraderTestSuite) TestGetBalance() {
tests := []struct {
name string
wantError bool
validate func(*testing.T, map[string]interface{})
}{
{
name: "成功获取余额",
wantError: false,
validate: func(t *testing.T, result map[string]interface{}) {
assert.NotNil(t, result)
assert.Contains(t, result, "totalWalletBalance")
assert.Contains(t, result, "availableBalance")
},
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
result, err := s.Trader.GetBalance()
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
if tt.validate != nil {
tt.validate(t, result)
}
}
})
}
}
// TestGetPositions 测试获取持仓
func (s *TraderTestSuite) TestGetPositions() {
tests := []struct {
name string
wantError bool
validate func(*testing.T, []map[string]interface{})
}{
{
name: "成功获取持仓列表",
wantError: false,
validate: func(t *testing.T, positions []map[string]interface{}) {
assert.NotNil(t, positions)
// 持仓可以为空数组
for _, pos := range positions {
assert.Contains(t, pos, "symbol")
assert.Contains(t, pos, "side")
assert.Contains(t, pos, "positionAmt")
}
},
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
result, err := s.Trader.GetPositions()
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
if tt.validate != nil {
tt.validate(t, result)
}
}
})
}
}
// TestGetMarketPrice 测试获取市场价格
func (s *TraderTestSuite) TestGetMarketPrice() {
tests := []struct {
name string
symbol string
wantError bool
validate func(*testing.T, float64)
}{
{
name: "成功获取BTC价格",
symbol: "BTCUSDT",
wantError: false,
validate: func(t *testing.T, price float64) {
assert.Greater(t, price, 0.0)
},
},
{
name: "无效交易对返回错误",
symbol: "INVALIDUSDT",
wantError: true,
validate: nil,
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
price, err := s.Trader.GetMarketPrice(tt.symbol)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
if tt.validate != nil {
tt.validate(t, price)
}
}
})
}
}
// TestSetLeverage 测试设置杠杆
func (s *TraderTestSuite) TestSetLeverage() {
tests := []struct {
name string
symbol string
leverage int
wantError bool
}{
{
name: "设置10倍杠杆",
symbol: "BTCUSDT",
leverage: 10,
wantError: false,
},
{
name: "设置1倍杠杆",
symbol: "ETHUSDT",
leverage: 1,
wantError: false,
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
err := s.Trader.SetLeverage(tt.symbol, tt.leverage)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
}
})
}
}
// TestSetMarginMode 测试设置仓位模式
func (s *TraderTestSuite) TestSetMarginMode() {
tests := []struct {
name string
symbol string
isCrossMargin bool
wantError bool
}{
{
name: "设置全仓模式",
symbol: "BTCUSDT",
isCrossMargin: true,
wantError: false,
},
{
name: "设置逐仓模式",
symbol: "ETHUSDT",
isCrossMargin: false,
wantError: false,
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
err := s.Trader.SetMarginMode(tt.symbol, tt.isCrossMargin)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
}
})
}
}
// TestFormatQuantity 测试数量格式化
func (s *TraderTestSuite) TestFormatQuantity() {
tests := []struct {
name string
symbol string
quantity float64
wantError bool
validate func(*testing.T, string)
}{
{
name: "格式化BTC数量",
symbol: "BTCUSDT",
quantity: 1.23456789,
wantError: false,
validate: func(t *testing.T, result string) {
assert.NotEmpty(t, result)
},
},
{
name: "格式化小数量",
symbol: "ETHUSDT",
quantity: 0.001,
wantError: false,
validate: func(t *testing.T, result string) {
assert.NotEmpty(t, result)
},
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
result, err := s.Trader.FormatQuantity(tt.symbol, tt.quantity)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
if tt.validate != nil {
tt.validate(t, result)
}
}
})
}
}
// TestCancelAllOrders 测试取消所有订单
func (s *TraderTestSuite) TestCancelAllOrders() {
tests := []struct {
name string
symbol string
wantError bool
}{
{
name: "取消BTC所有订单",
symbol: "BTCUSDT",
wantError: false,
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
err := s.Trader.CancelAllOrders(tt.symbol)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
}
})
}
}
// ============================================================
// 核心交易方法测试
// ============================================================
// TestOpenLong 测试开多仓
func (s *TraderTestSuite) TestOpenLong() {
tests := []struct {
name string
symbol string
quantity float64
leverage int
wantError bool
validate func(*testing.T, map[string]interface{})
}{
{
name: "成功开多仓",
symbol: "BTCUSDT",
quantity: 0.01,
leverage: 10,
wantError: false,
validate: func(t *testing.T, result map[string]interface{}) {
assert.NotNil(t, result)
assert.Contains(t, result, "symbol")
assert.Equal(t, "BTCUSDT", result["symbol"])
},
},
{
name: "小数量开仓",
symbol: "ETHUSDT",
quantity: 0.004, // 增加到 0.004 以满足 Binance Futures 的 10 USDT 最小订单金额要求 (0.004 * 3000 = 12 USDT)
leverage: 5,
wantError: false,
validate: func(t *testing.T, result map[string]interface{}) {
assert.NotNil(t, result)
},
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
result, err := s.Trader.OpenLong(tt.symbol, tt.quantity, tt.leverage)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
if tt.validate != nil {
tt.validate(t, result)
}
}
})
}
}
// TestOpenShort 测试开空仓
func (s *TraderTestSuite) TestOpenShort() {
tests := []struct {
name string
symbol string
quantity float64
leverage int
wantError bool
validate func(*testing.T, map[string]interface{})
}{
{
name: "成功开空仓",
symbol: "BTCUSDT",
quantity: 0.01,
leverage: 10,
wantError: false,
validate: func(t *testing.T, result map[string]interface{}) {
assert.NotNil(t, result)
assert.Contains(t, result, "symbol")
assert.Equal(t, "BTCUSDT", result["symbol"])
},
},
{
name: "小数量开空仓",
symbol: "ETHUSDT",
quantity: 0.004, // 增加到 0.004 以满足 Binance Futures 的 10 USDT 最小订单金额要求 (0.004 * 3000 = 12 USDT)
leverage: 5,
wantError: false,
validate: func(t *testing.T, result map[string]interface{}) {
assert.NotNil(t, result)
},
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
result, err := s.Trader.OpenShort(tt.symbol, tt.quantity, tt.leverage)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
if tt.validate != nil {
tt.validate(t, result)
}
}
})
}
}
// TestCloseLong 测试平多仓
func (s *TraderTestSuite) TestCloseLong() {
tests := []struct {
name string
symbol string
quantity float64
wantError bool
validate func(*testing.T, map[string]interface{})
}{
{
name: "平指定数量",
symbol: "BTCUSDT",
quantity: 0.01,
wantError: false,
validate: func(t *testing.T, result map[string]interface{}) {
assert.NotNil(t, result)
assert.Contains(t, result, "symbol")
},
},
{
name: "全部平仓_quantity为0_无持仓返回错误",
symbol: "ETHUSDT",
quantity: 0,
wantError: true, // 当没有持仓时，quantity=0 应该返回错误
validate: nil,
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
result, err := s.Trader.CloseLong(tt.symbol, tt.quantity)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
if tt.validate != nil {
tt.validate(t, result)
}
}
})
}
}
// TestCloseShort 测试平空仓
func (s *TraderTestSuite) TestCloseShort() {
tests := []struct {
name string
symbol string
quantity float64
wantError bool
validate func(*testing.T, map[string]interface{})
}{
{
name: "平指定数量",
symbol: "BTCUSDT",
quantity: 0.01,
wantError: false,
validate: func(t *testing.T, result map[string]interface{}) {
assert.NotNil(t, result)
assert.Contains(t, result, "symbol")
},
},
{
name: "全部平仓_quantity为0_无持仓返回错误",
symbol: "ETHUSDT",
quantity: 0,
wantError: true, // 当没有持仓时，quantity=0 应该返回错误
validate: nil,
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
result, err := s.Trader.CloseShort(tt.symbol, tt.quantity)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
if tt.validate != nil {
tt.validate(t, result)
}
}
})
}
}
// ============================================================
// 止损止盈测试
// ============================================================
// TestSetStopLoss 测试设置止损
func (s *TraderTestSuite) TestSetStopLoss() {
tests := []struct {
name string
symbol string
positionSide string
quantity float64
stopPrice float64
wantError bool
}{
{
name: "多头止损",
symbol: "BTCUSDT",
positionSide: "LONG",
quantity: 0.01,
stopPrice: 45000.0,
wantError: false,
},
{
name: "空头止损",
symbol: "ETHUSDT",
positionSide: "SHORT",
quantity: 0.1,
stopPrice: 3200.0,
wantError: false,
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
err := s.Trader.SetStopLoss(tt.symbol, tt.positionSide, tt.quantity, tt.stopPrice)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
}
})
}
}
// TestSetTakeProfit 测试设置止盈
func (s *TraderTestSuite) TestSetTakeProfit() {
tests := []struct {
name string
symbol string
positionSide string
quantity float64
takeProfitPrice float64
wantError bool
}{
{
name: "多头止盈",
symbol: "BTCUSDT",
positionSide: "LONG",
quantity: 0.01,
takeProfitPrice: 55000.0,
wantError: false,
},
{
name: "空头止盈",
symbol: "ETHUSDT",
positionSide: "SHORT",
quantity: 0.1,
takeProfitPrice: 2800.0,
wantError: false,
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
err := s.Trader.SetTakeProfit(tt.symbol, tt.positionSide, tt.quantity, tt.takeProfitPrice)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
}
})
}
}
// TestCancelStopOrders 测试取消止盈止损单
func (s *TraderTestSuite) TestCancelStopOrders() {
tests := []struct {
name string
symbol string
wantError bool
}{
{
name: "取消BTC止盈止损单",
symbol: "BTCUSDT",
wantError: false,
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
err := s.Trader.CancelStopOrders(tt.symbol)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
}
})
}
}
// TestCancelStopLossOrders 测试取消止损单
func (s *TraderTestSuite) TestCancelStopLossOrders() {
tests := []struct {
name string
symbol string
wantError bool
}{
{
name: "取消BTC止损单",
symbol: "BTCUSDT",
wantError: false,
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
err := s.Trader.CancelStopLossOrders(tt.symbol)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
}
})
}
}
// TestCancelTakeProfitOrders 测试取消止盈单
func (s *TraderTestSuite) TestCancelTakeProfitOrders() {
tests := []struct {
name string
symbol string
wantError bool
}{
{
name: "取消BTC止盈单",
symbol: "BTCUSDT",
wantError: false,
},
}
for _, tt := range tests {
s.T.Run(tt.name, func(t *testing.T) {
err := s.Trader.CancelTakeProfitOrders(tt.symbol)
if tt.wantError {
assert.Error(t, err)
} else {
assert.NoError(t, err)
}
})
}
}

3997
web/package-lock.json generated
View File

File diff suppressed because it is too large Load Diff

13
web/package.json
View File

@@ -10,9 +10,11 @@
"lint:fix": "eslint . --ext ts,tsx --fix",
"format": "prettier --write \"src/**/*.{ts,tsx,css,json}\"",
"format:check": "prettier --check \"src/**/*.{ts,tsx,css,json}\"",
"prepare": "husky"
"prepare": "husky",
"test": "vitest run"
},
"dependencies": {
"@radix-ui/react-alert-dialog": "^1.1.15",
"@radix-ui/react-slot": "^1.2.3",
"class-variance-authority": "^0.7.1",
"clsx": "^2.1.1",
@@ -21,13 +23,18 @@
"lucide-react": "^0.552.0",
"react": "^18.3.1",
"react-dom": "^18.3.1",
"react-password-checklist": "^1.8.1",
"react-router-dom": "^7.9.5",
"recharts": "^2.15.2",
"sonner": "^1.5.0",
"swr": "^2.2.5",
"tailwind-merge": "^3.3.1",
"zustand": "^5.0.2"
},
"devDependencies": {
"@eslint/js": "^9.39.1",
"@testing-library/jest-dom": "^6.9.1",
"@testing-library/react": "^16.3.0",
"@types/react": "^18.3.17",
"@types/react-dom": "^18.3.5",
"@typescript-eslint/eslint-plugin": "^8.46.3",
@@ -41,12 +48,14 @@
"eslint-plugin-react-hooks": "^7.0.1",
"eslint-plugin-react-refresh": "^0.4.24",
"husky": "^9.1.7",
"jsdom": "^25.0.1",
"lint-staged": "^16.2.6",
"postcss": "^8.4.49",
"prettier": "^3.6.2",
"tailwindcss": "^3.4.17",
"typescript": "^5.8.3",
"vite": "^6.0.7"
"vite": "^6.0.7",
"vitest": "^2.1.9"
},
"lint-staged": {
"*.{ts,tsx}": [

1141
web/src/App.tsx
View File

File diff suppressed because it is too large Load Diff

9
web/src/components/AILearning.tsx
View File

@@ -1,6 +1,7 @@
import useSWR from 'swr'
import { useLanguage } from '../contexts/LanguageContext'
import { t } from '../i18n/translations'
import { stripLeadingIcons } from '../lib/text'
import { api } from '../lib/api'
import {
Brain,
@@ -78,7 +79,9 @@ export default function AILearning({ traderId }: AILearningProps) {
className="rounded p-6"
style={{ background: '#1E2329', border: '1px solid #2B3139' }}
>
<div style={{ color: '#F6465D' }}>{t('loadingError', language)}</div>
<div style={{ color: '#F6465D' }}>
{stripLeadingIcons(t('loadingError', language))}
</div>
</div>
)
}
@@ -695,7 +698,7 @@ export default function AILearning({ traderId }: AILearningProps) {
style={{ color: '#E0E7FF' }}
>
<BarChart3 className="w-5 h-5" />{' '}
{t('symbolPerformance', language)}
{stripLeadingIcons(t('symbolPerformance', language))}
</h3>
</div>
<div
@@ -1084,7 +1087,7 @@ export default function AILearning({ traderId }: AILearningProps) {
className="font-bold mb-3 text-base"
style={{ color: '#FCD34D' }}
>
{t('howAILearns', language)}
{stripLeadingIcons(t('howAILearns', language))}
</h3>
<div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-4 gap-4 text-sm">
<div className="flex items-start gap-2">

2262
web/src/components/AITradersPage.tsx
View File

File diff suppressed because it is too large Load Diff

329
web/src/components/CompetitionPage.test.tsx Normal file
View File

@@ -0,0 +1,329 @@
import { describe, it, expect } from 'vitest'
/**
* PR #678 測試: 修復 CompetitionPage 中 NaN 和缺失數據的顯示問題
*
* 問題：當 total_pnl_pct 為 null/undefined/NaN 時，會顯示 "NaN%" 或 "0.00%"
* 修復：檢查數據有效性，顯示 "—" 表示缺失數據
*/
describe('CompetitionPage - Data Validation Logic (PR #678)', () => {
/**
* 測試數據有效性檢查邏輯
* 這是 PR #678 引入的核心邏輯
*/
describe('hasValidData check', () => {
it('should return true for valid numbers', () => {
const trader1 = { total_pnl_pct: 10.5 }
const trader2 = { total_pnl_pct: -5.2 }
const hasValidData =
trader1.total_pnl_pct != null &&
trader2.total_pnl_pct != null &&
!isNaN(trader1.total_pnl_pct) &&
!isNaN(trader2.total_pnl_pct)
expect(hasValidData).toBe(true)
})
it('should return false when trader1 has null value', () => {
const trader1 = { total_pnl_pct: null }
const trader2 = { total_pnl_pct: 10.5 }
const hasValidData =
trader1.total_pnl_pct != null &&
trader2.total_pnl_pct != null &&
!isNaN(trader1.total_pnl_pct!) &&
!isNaN(trader2.total_pnl_pct)
expect(hasValidData).toBe(false)
})
it('should return false when trader2 has undefined value', () => {
const trader1 = { total_pnl_pct: 10.5 }
const trader2 = { total_pnl_pct: undefined }
const hasValidData =
trader1.total_pnl_pct != null &&
trader2.total_pnl_pct != null &&
!isNaN(trader1.total_pnl_pct) &&
!isNaN(trader2.total_pnl_pct!)
expect(hasValidData).toBe(false)
})
it('should return false when trader1 has NaN value', () => {
const trader1 = { total_pnl_pct: NaN }
const trader2 = { total_pnl_pct: 10.5 }
const hasValidData =
trader1.total_pnl_pct != null &&
trader2.total_pnl_pct != null &&
!isNaN(trader1.total_pnl_pct) &&
!isNaN(trader2.total_pnl_pct)
expect(hasValidData).toBe(false)
})
it('should return false when both traders have invalid data', () => {
const trader1 = { total_pnl_pct: null }
const trader2 = { total_pnl_pct: NaN }
const hasValidData =
trader1.total_pnl_pct != null &&
trader2.total_pnl_pct != null &&
!isNaN(trader1.total_pnl_pct!) &&
!isNaN(trader2.total_pnl_pct)
expect(hasValidData).toBe(false)
})
it('should handle zero as valid data', () => {
const trader1 = { total_pnl_pct: 0 }
const trader2 = { total_pnl_pct: 10.5 }
const hasValidData =
trader1.total_pnl_pct != null &&
trader2.total_pnl_pct != null &&
!isNaN(trader1.total_pnl_pct) &&
!isNaN(trader2.total_pnl_pct)
expect(hasValidData).toBe(true)
})
it('should handle negative numbers as valid data', () => {
const trader1 = { total_pnl_pct: -15.5 }
const trader2 = { total_pnl_pct: -8.2 }
const hasValidData =
trader1.total_pnl_pct != null &&
trader2.total_pnl_pct != null &&
!isNaN(trader1.total_pnl_pct) &&
!isNaN(trader2.total_pnl_pct)
expect(hasValidData).toBe(true)
})
})
/**
* 測試 gap 計算邏輯
* gap 應該只在數據有效時計算
*/
describe('gap calculation', () => {
it('should calculate gap correctly for valid data', () => {
const trader1 = { total_pnl_pct: 15.5 }
const trader2 = { total_pnl_pct: 10.2 }
const hasValidData =
trader1.total_pnl_pct != null &&
trader2.total_pnl_pct != null &&
!isNaN(trader1.total_pnl_pct) &&
!isNaN(trader2.total_pnl_pct)
const gap = hasValidData
? trader1.total_pnl_pct - trader2.total_pnl_pct
: NaN
expect(gap).toBeCloseTo(5.3, 1) // Allow floating point precision
expect(isNaN(gap)).toBe(false)
})
it('should return NaN for invalid data', () => {
const trader1 = { total_pnl_pct: null }
const trader2 = { total_pnl_pct: 10.2 }
const hasValidData =
trader1.total_pnl_pct != null &&
trader2.total_pnl_pct != null &&
!isNaN(trader1.total_pnl_pct!) &&
!isNaN(trader2.total_pnl_pct)
const gap = hasValidData
? trader1.total_pnl_pct! - trader2.total_pnl_pct
: NaN
expect(isNaN(gap)).toBe(true)
})
it('should handle negative gap correctly', () => {
const trader1 = { total_pnl_pct: 5.0 }
const trader2 = { total_pnl_pct: 12.0 }
const hasValidData =
trader1.total_pnl_pct != null &&
trader2.total_pnl_pct != null &&
!isNaN(trader1.total_pnl_pct) &&
!isNaN(trader2.total_pnl_pct)
const gap = hasValidData
? trader1.total_pnl_pct - trader2.total_pnl_pct
: NaN
expect(gap).toBe(-7.0)
})
})
/**
* 測試顯示邏輯
* 修復後應顯示「—」而非「NaN%」或「0.00%」
*/
describe('display formatting', () => {
it('should format valid positive percentage correctly', () => {
const total_pnl_pct = 15.567
const display =
total_pnl_pct != null && !isNaN(total_pnl_pct)
? `${total_pnl_pct >= 0 ? '+' : ''}${total_pnl_pct.toFixed(2)}%`
: '—'
expect(display).toBe('+15.57%')
})
it('should format valid negative percentage correctly', () => {
const total_pnl_pct = -8.234
const display =
total_pnl_pct != null && !isNaN(total_pnl_pct)
? `${total_pnl_pct >= 0 ? '+' : ''}${total_pnl_pct.toFixed(2)}%`
: '—'
expect(display).toBe('-8.23%')
})
it('should display "—" for null value', () => {
const total_pnl_pct = null
const display =
total_pnl_pct != null && !isNaN(total_pnl_pct)
? `${total_pnl_pct >= 0 ? '+' : ''}${total_pnl_pct.toFixed(2)}%`
: '—'
expect(display).toBe('—')
})
it('should display "—" for undefined value', () => {
const total_pnl_pct = undefined
const display =
total_pnl_pct != null && !isNaN(total_pnl_pct)
? `${total_pnl_pct >= 0 ? '+' : ''}${total_pnl_pct.toFixed(2)}%`
: '—'
expect(display).toBe('—')
})
it('should display "—" for NaN value', () => {
const total_pnl_pct = NaN
const display =
total_pnl_pct != null && !isNaN(total_pnl_pct)
? `${total_pnl_pct >= 0 ? '+' : ''}${total_pnl_pct.toFixed(2)}%`
: '—'
expect(display).toBe('—')
})
it('should format zero correctly', () => {
const total_pnl_pct = 0
const display =
total_pnl_pct != null && !isNaN(total_pnl_pct)
? `${total_pnl_pct >= 0 ? '+' : ''}${total_pnl_pct.toFixed(2)}%`
: '—'
expect(display).toBe('+0.00%')
})
})
/**
* 測試領先/落後訊息顯示邏輯
* 只有在數據有效時才顯示 "領先" 或 "落後" 訊息
*/
describe('leading/trailing message display', () => {
it('should show leading message when winning with positive gap', () => {
const isWinning = true
const gap = 5.2
const hasValidData = true
const shouldShowLeading = hasValidData && isWinning && gap > 0
expect(shouldShowLeading).toBe(true)
})
it('should not show leading message when data is invalid', () => {
const isWinning = true
const gap = NaN
const hasValidData = false
const shouldShowLeading = hasValidData && isWinning && gap > 0
expect(shouldShowLeading).toBe(false)
})
it('should show trailing message when losing with negative gap', () => {
const isWinning = false
const gap = -3.5
const hasValidData = true
const shouldShowTrailing = hasValidData && !isWinning && gap < 0
expect(shouldShowTrailing).toBe(true)
})
it('should not show trailing message when data is invalid', () => {
const isWinning = false
const gap = NaN
const hasValidData = false
const shouldShowTrailing = hasValidData && !isWinning && gap < 0
expect(shouldShowTrailing).toBe(false)
})
it('should show fallback "—" when data is invalid', () => {
const hasValidData = false
const shouldShowFallback = !hasValidData
expect(shouldShowFallback).toBe(true)
})
})
/**
* 測試邊界情況
*/
describe('edge cases', () => {
it('should handle very small positive numbers', () => {
const total_pnl_pct = 0.001
const hasValidData = total_pnl_pct != null && !isNaN(total_pnl_pct)
expect(hasValidData).toBe(true)
})
it('should handle very large numbers', () => {
const total_pnl_pct = 9999.99
const hasValidData = total_pnl_pct != null && !isNaN(total_pnl_pct)
expect(hasValidData).toBe(true)
})
it('should handle Infinity as invalid (produces NaN in calculations)', () => {
const total_pnl_pct = Infinity
// Infinity 本身不是 NaN，但在減法運算中可能導致問題
const hasValidData = total_pnl_pct != null && isFinite(total_pnl_pct)
expect(hasValidData).toBe(false)
})
it('should handle -Infinity as invalid', () => {
const total_pnl_pct = -Infinity
const hasValidData = total_pnl_pct != null && isFinite(total_pnl_pct)
expect(hasValidData).toBe(false)
})
})
})

30
web/src/components/CompetitionPage.tsx
View File

@@ -392,7 +392,17 @@ export function CompetitionPage() {
{sortedTraders.map((trader, index) => {
const isWinning = index === 0
const opponent = sortedTraders[1 - index]
const gap = trader.total_pnl_pct - opponent.total_pnl_pct
// Check if both values are valid numbers
const hasValidData =
trader.total_pnl_pct != null &&
opponent.total_pnl_pct != null &&
!isNaN(trader.total_pnl_pct) &&
!isNaN(opponent.total_pnl_pct)
const gap = hasValidData
? trader.total_pnl_pct - opponent.total_pnl_pct
: NaN
return (
<div
@@ -429,10 +439,12 @@ export function CompetitionPage() {
(trader.total_pnl ?? 0) >= 0 ? '#0ECB81' : '#F6465D',
}}
>
{(trader.total_pnl ?? 0) >= 0 ? '+' : ''}
{trader.total_pnl_pct?.toFixed(2) || '0.00'}%
{trader.total_pnl_pct != null &&
!isNaN(trader.total_pnl_pct)
? `${trader.total_pnl_pct >= 0 ? '+' : ''}${trader.total_pnl_pct.toFixed(2)}%`
: '—'}
</div>
{isWinning && gap > 0 && (
{hasValidData && isWinning && gap > 0 && (
<div
className="text-xs font-semibold"
style={{ color: '#0ECB81' }}
@@ -440,7 +452,7 @@ export function CompetitionPage() {
{t('leadingBy', language, { gap: gap.toFixed(2) })}
</div>
)}
{!isWinning && gap < 0 && (
{hasValidData && !isWinning && gap < 0 && (
<div
className="text-xs font-semibold"
style={{ color: '#F6465D' }}
@@ -450,6 +462,14 @@ export function CompetitionPage() {
})}
</div>
)}
{!hasValidData && (
<div
className="text-xs font-semibold"
style={{ color: '#848E9C' }}
>
—
</div>
)}
</div>
</div>
)

123
web/src/components/ConfirmDialog.tsx Normal file
View File

@@ -0,0 +1,123 @@
import React, {
createContext,
useContext,
useState,
useCallback,
useEffect,
} from 'react'
import {
AlertDialog,
AlertDialogAction,
AlertDialogCancel,
AlertDialogContent,
AlertDialogDescription,
AlertDialogFooter,
AlertDialogTitle,
} from './ui/alert-dialog'
import { setGlobalConfirm } from '../lib/notify'
interface ConfirmOptions {
title?: string
message: string
okText?: string
cancelText?: string
}
interface ConfirmDialogContextType {
confirm: (options: ConfirmOptions) => Promise<boolean>
}
const ConfirmDialogContext = createContext<
ConfirmDialogContextType | undefined
>(undefined)
export function useConfirmDialog() {
const context = useContext(ConfirmDialogContext)
if (!context) {
throw new Error(
'useConfirmDialog must be used within ConfirmDialogProvider'
)
}
return context
}
interface ConfirmState {
isOpen: boolean
title?: string
message: string
okText: string
cancelText: string
resolve?: (value: boolean) => void
}
export function ConfirmDialogProvider({
children,
}: {
children: React.ReactNode
}) {
const [state, setState] = useState<ConfirmState>({
isOpen: false,
message: '',
okText: '确认',
cancelText: '取消',
})
const confirm = useCallback((options: ConfirmOptions): Promise<boolean> => {
return new Promise((resolve) => {
setState({
isOpen: true,
title: options.title,
message: options.message,
okText: options.okText || '确认',
cancelText: options.cancelText || '取消',
resolve,
})
})
}, [])
// 注册全局 confirm 函数
useEffect(() => {
setGlobalConfirm(confirm)
}, [confirm])
const handleClose = useCallback((result: boolean) => {
setState((prev) => {
prev.resolve?.(result)
return {
...prev,
isOpen: false,
}
})
}, [])
return (
<ConfirmDialogContext.Provider value={{ confirm }}>
{children}
<AlertDialog
open={state.isOpen}
onOpenChange={(open) => !open && handleClose(false)}
>
<AlertDialogContent>
<div className="flex flex-col gap-5 text-center">
{state.title && (
<AlertDialogTitle className="text-xl">
{state.title}
</AlertDialogTitle>
)}
<AlertDialogDescription className="text-[var(--text-primary)] text-base font-medium">
{state.message}
</AlertDialogDescription>
</div>
<AlertDialogFooter>
<AlertDialogCancel onClick={() => handleClose(false)}>
{state.cancelText}
</AlertDialogCancel>
<AlertDialogAction onClick={() => handleClose(true)}>
{state.okText}
</AlertDialogAction>
</AlertDialogFooter>
</AlertDialogContent>
</AlertDialog>
</ConfirmDialogContext.Provider>
)
}

40
web/src/components/Container.tsx Normal file
View File

@@ -0,0 +1,40 @@
import { ReactNode, CSSProperties } from 'react'
interface ContainerProps {
children: ReactNode
className?: string
as?: 'div' | 'main' | 'header' | 'section'
style?: CSSProperties
/** 是否充满宽度（取消 max-width） */
fluid?: boolean
/** 是否取消水平内边距 */
noPadding?: boolean
/** 自定义最大宽度类（默认 max-w-[1920px]） */
maxWidthClass?: string
}
/**
* 统一的容器组件，确保所有页面元素使用一致的最大宽度和内边距
* - max-width: 1920px
* - padding: 24px (mobile) -> 32px (tablet) -> 48px (desktop)
*/
export function Container({
children,
className = '',
as: Component = 'div',
style,
fluid = false,
noPadding = false,
maxWidthClass = 'max-w-[1920px]',
}: ContainerProps) {
const maxWidth = fluid ? 'w-full' : maxWidthClass
const padding = noPadding ? 'px-0' : 'px-6 sm:px-8 lg:px-12'
return (
<Component
className={`${maxWidth} mx-auto ${padding} ${className}`}
style={style}
>
{children}
</Component>
)
}

116
web/src/components/DevToastController.tsx Normal file
View File

@@ -0,0 +1,116 @@
/// <reference types="vite/client" />
import { useState } from 'react'
import { confirmToast, notify } from '../lib/notify'
const toastOptions = [
'message',
'success',
'info',
'warning',
'error',
'custom',
] as const
type ToastType = (typeof toastOptions)[number]
const customRenderer = () => (
<div className="dev-custom-toast">
<p className="dev-custom-title">Sonner 自定义通知</p>
<p className="dev-custom-body">
这是一个通过 `notify.custom` 渲染的测试 Toast
</p>
</div>
)
export function DevToastController() {
const [type, setType] = useState<ToastType>('success')
const [message, setMessage] = useState('来自 Dev 控制器的测试通知')
const [duration, setDuration] = useState(2200)
if (!import.meta.env.DEV) {
return null
}
const triggerToast = async () => {
switch (type) {
case 'message':
notify.message(message, { duration })
break
case 'success':
notify.success(message, { duration })
break
case 'info':
notify.info(message, { duration })
break
case 'warning':
notify.warning(message, { duration })
break
case 'error':
notify.error(message, { duration })
break
case 'custom':
notify.custom(() => customRenderer(), { duration })
break
}
}
const triggerConfirm = async () => {
const confirmed = await confirmToast(message, {
okText: '继续',
cancelText: '取消',
})
if (confirmed) {
notify.success('确认按钮已点击', { duration: 2000 })
} else {
notify.message('已取消确认逻辑', { duration: 2000 })
}
}
return (
<div className="dev-toast-controller">
<div className="dev-toast-controller__header">
<span>Dev Sonner 控制器</span>
<small>仅在 dev 模式可见</small>
</div>
<div className="dev-toast-controller__content">
<label className="dev-toast-controller__label">
类型
<select
value={type}
onChange={(event) => setType(event.target.value as ToastType)}
>
{toastOptions.map((option) => (
<option key={option} value={option}>
{option}
</option>
))}
</select>
</label>
<label className="dev-toast-controller__label">
文案
<input
value={message}
onChange={(event) => setMessage(event.target.value)}
placeholder="输入通知/确认文案"
/>
</label>
<label className="dev-toast-controller__label">
持续(ms)
<input
type="number"
min={600}
value={duration}
onChange={(event) => setDuration(Number(event.target.value))}
/>
</label>
<div className="dev-toast-controller__actions">
<button onClick={triggerToast}>触发通知</button>
<button onClick={triggerConfirm}>触发确认</button>
</div>
</div>
</div>
)
}
export default DevToastController

15
web/src/components/EquityChart.tsx
View File

@@ -12,6 +12,7 @@ import {
import useSWR from 'swr'
import { api } from '../lib/api'
import { useLanguage } from '../contexts/LanguageContext'
import { useAuth } from '../contexts/AuthContext'
import { t } from '../i18n/translations'
import {
AlertTriangle,
@@ -36,10 +37,11 @@ interface EquityChartProps {
export function EquityChart({ traderId }: EquityChartProps) {
const { language } = useLanguage()
const { user, token } = useAuth()
const [displayMode, setDisplayMode] = useState<'dollar' | 'percent'>('dollar')
const { data: history, error } = useSWR<EquityPoint[]>(
traderId ? `equity-history-${traderId}` : 'equity-history',
user && token && traderId ? `equity-history-${traderId}` : null,
() => api.getEquityHistory(traderId),
{
refreshInterval: 30000, // 30秒刷新（历史数据更新频率较低）
@@ -49,7 +51,7 @@ export function EquityChart({ traderId }: EquityChartProps) {
)
const { data: account } = useSWR(
traderId ? `account-${traderId}` : 'account',
user && token && traderId ? `account-${traderId}` : null,
() => api.getAccount(traderId),
{
refreshInterval: 15000, // 15秒刷新（配合后端缓存）
@@ -113,9 +115,12 @@ export function EquityChart({ traderId }: EquityChartProps) {
: validHistory
// 计算初始余额（优先从 account 获取配置的初始余额，备选从历史数据反推）
const initialBalance = account?.initial_balance // 从交易员配置读取真实初始余额
|| (validHistory[0] ? validHistory[0].total_equity - validHistory[0].pnl : undefined) // 备选：淨值 - 盈亏
|| 1000; // 默认值（与创建交易员时的默认配置一致）
const initialBalance =
account?.initial_balance || // 从交易员配置读取真实初始余额
(validHistory[0]
? validHistory[0].total_equity - validHistory[0].pnl
: undefined) || // 备选：淨值 - 盈亏
1000 // 默认值（与创建交易员时的默认配置一致）
// 转换数据格式
const chartData = displayHistory.map((point) => {

Some files were not shown because too many files have changed in this diff Show More