laoxong/nofx
1
0
Fork 0
mirror of https://github.com/laoxong/nofx.git synced 2026-06-04 09:58:22 +08:00
Code Issues Packages Projects Releases Wiki Activity

Merge from beta

Browse Source
This commit is contained in:
Icy
2025-11-13 23:05:57 +08:00
parent 9927ede8fd b43315d9fc
commit d787b72d75
210 changed files with 46931 additions and 7541 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.claude/commands/20-code-review.md
+329
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 规则检查硬编码端点、路径格式、必需认证头/凭证的使用一致性。
.env.example
+1
View File
@@ -11,3 +11,4 @@ NOFX_FRONTEND_PORT=3000
# Timezone Setting
# System timezone for container time synchronization
NOFX_TIMEZONE=Asia/Shanghai
.github/CODEOWNERS
+135
View File
@@ -0,0 +1,135 @@
# CODEOWNERS
#
# This file defines code ownership and automatic reviewer assignment.
# When a PR touches files matching these patterns, the listed users/teams
# will be automatically requested for review.
#
# 此文件定义代码所有权和自动 reviewer 分配。
# 当 PR 涉及匹配这些模式的文件时，列出的用户/团队将自动被请求审查。
#
# Syntax | 语法:
# pattern @username @org/team-name
#
# More specific patterns override less specific ones
# 更具体的模式会覆盖不太具体的模式
#
# Documentation: https://docs.github.com/en/repositories/managing-your-repositorys-settings-and-features/customizing-your-repository/about-code-owners
# =============================================================================
# Global Owners | 全局所有者
# These users will be requested for review on ALL pull requests
# 这些用户将被请求审查所有 PR
# =============================================================================
* @hzb1115 @Icyoung @tangmengqiu @xqliu @SkywalkerJi
# =============================================================================
# Specific Component Owners | 特定组件所有者
# Additional reviewers based on file paths (in addition to global owners)
# 基于文件路径的额外 reviewers（在全局 owners 之外）
# =============================================================================
# Backend / Go Code | 后端 / Go 代码
# Go files and backend logic
*.go @xqliu @SkywalkerJi @hzb1115 @Icyoung @tangmengqiu
go.mod @xqliu @SkywalkerJi @hzb1115 @Icyoung @tangmengqiu
go.sum @xqliu @SkywalkerJi @hzb1115 @Icyoung @tangmengqiu
# Frontend / Web | 前端 / Web
# React/TypeScript frontend code
/web/ @0xEmberZz @hzb1115 @xqliu @tangmengqiu
/web/src/ @0xEmberZz @hzb1115 @xqliu @tangmengqiu
*.tsx @0xEmberZz @hzb1115 @xqliu @tangmengqiu
*.ts @0xEmberZz @hzb1115 @xqliu @tangmengqiu (frontend TypeScript only)
*.jsx @0xEmberZz @hzb1115 @xqliu @tangmengqiu
*.css @0xEmberZz @hzb1115 @xqliu @tangmengqiu
*.scss @0xEmberZz @hzb1115 @xqliu @tangmengqiu
# Configuration Files | 配置文件
*.json @0xEmberZz @hzb1115 @xqliu @tangmengqiu
*.yaml @0xEmberZz @hzb1115 @xqliu @tangmengqiu
*.yml @0xEmberZz @hzb1115 @xqliu @tangmengqiu
*.toml @0xEmberZz @hzb1115 @xqliu @tangmengqiu
*.ini @0xEmberZz @hzb1115 @xqliu @tangmengqiu
# Documentation | 文档
# Markdown and documentation files
*.md @hzb1115 @tangmengqiu
/docs/ @hzb1115 @tangmengqiu
README.md @hzb1115 @tangmengqiu
# GitHub Workflows & Actions | GitHub 工作流和 Actions
# CI/CD configuration and automation
/.github/ @hzb1115
/.github/workflows/ @hzb1115
/.github/workflows/*.yml @hzb1115
# Docker | Docker 配置
Dockerfile @tangmengqiu
docker-compose.yml @tangmengqiu
.dockerignore @tangmengqiu
# Database | 数据库
# Database migrations and schemas
/migrations/ @SkywalkerJi @hzb1115 @Icyoung @tangmengqiu
/db/ @SkywalkerJi @hzb1115 @Icyoung @tangmengqiu
*.sql @SkywalkerJi @hzb1115 @Icyoung @tangmengqiu
# Scripts | 脚本
/scripts/ @hzb1115 @xqliu @tangmengqiu
*.sh @hzb1115 @xqliu @tangmengqiu
*.bash @hzb1115 @tangmengqiu
*.py @hzb1115 @tangmengqiu (if Python scripts exist)
# Tests | 测试
# Test files require review from component owners
*_test.go @xqliu @SkywalkerJi @heronsbillC
/tests/ @xqliu @SkywalkerJi @Icyoung @heronsbillC
/web/tests/ @Icyoung @hzb1115 @heronsbillC
# Security & Dependencies | 安全和依赖
# Security-sensitive files require extra attention
.env.example @hzb1115 @tangmengqiu
.gitignore @hzb1115 @tangmengqiu
go.sum @xqliu @hzb1115 @tangmengqiu
package-lock.json @Icyoung @hzb1115 @tangmengqiu
yarn.lock @Icyoung @hzb1115 @tangmengqiu
# Build Configuration | 构建配置
Makefile @hzb1115 @xqliu @tangmengqiu
/build/ @hzb1115 @xqliu @tangmengqiu
/dist/ @hzb1115 @tangmengqiu
# License & Legal | 许可证和法律文件
LICENSE @hzb1115
COPYING @hzb1115
# =============================================================================
# Notes | 注意事项
# =============================================================================
#
# 1. All PRs will be assigned to the 5 global owners
# 所有 PR 都会分配给这 5 个全局 owners
#
# 2. Specific paths may add additional reviewers
# 特定路径可能会添加额外的 reviewers
#
# 3. PR author will NOT be requested for review (GitHub handles this)
# PR 作者不会被请求审查（GitHub 自动处理）
#
# 4. You can adjust patterns and owners as needed
# 你可以根据需要调整模式和 owners
#
# 5. To require multiple approvals, configure branch protection rules
# 要求多个批准，请配置分支保护规则
#
# ⚠️ IMPORTANT - Permission Requirements | 重要 - 权限要求:
# - Users listed here will ONLY be auto-requested if they have Write+ permission
# 这里列出的用户只有在拥有 Write 或以上权限时才会被自动请求
# - GitHub will silently skip users without proper permissions
# GitHub 会静默跳过没有适当权限的用户
# - See CODEOWNERS_PERMISSIONS.md for details
# 详见 CODEOWNERS_PERMISSIONS.md
#
# =============================================================================
.github/ISSUE_TEMPLATE/bounty_claim.md
+1 -1
View File
@@ -82,7 +82,7 @@ By claiming this bounty, I acknowledge that:
- [ ] I have read the [Contributing Guide](../../CONTRIBUTING.md)
- [ ] I will follow the [Code of Conduct](../../CODE_OF_CONDUCT.md)
- [ ] I understand the acceptance criteria
- [ ] My contribution will be licensed under MIT License
- [ ] My contribution will be licensed under AGPL-3.0 License
- [ ] Payment is subject to successful PR merge
---
.github/PULL_REQUEST_TEMPLATE.md
+43 -227
View File
@@ -1,33 +1,44 @@
# Pull Request | PR 提交
> **💡 提示 Tip:** 推荐 PR 标题格式 Recommended PR title format: `type(scope): description`
> 例如 Examples: `feat(trader): add new strategy` | `fix(api): resolve auth issue`
> 详情 Details: [PR Title Guide](./PR_TITLE_GUIDE.md)
> **📋 选择专用模板 | Choose Specialized Template**
>
> 我们现在提供了针对不同类型PR的专用模板，帮助你更快速地填写PR信息：
> We now offer specialized templates for different types of PRs to help you fill out the information faster:
>
> - 🔧 **[Backend PR Template](./PULL_REQUEST_TEMPLATE/backend.md)** | 后端PR模板 - For Go/API/Trading changes
> - 🎨 **[Frontend PR Template](./PULL_REQUEST_TEMPLATE/frontend.md)** | 前端PR模板 - For UI/UX changes
> - 📝 **[Documentation PR Template](./PULL_REQUEST_TEMPLATE/docs.md)** | 文档PR模板 - For documentation updates
> - 📦 **[General PR Template](./PULL_REQUEST_TEMPLATE/general.md)** | 通用PR模板 - For mixed or other changes
>
> **如何使用？| How to use?**
> - 创建PR时，在URL中添加 `?template=backend.md` 或其他模板名称
> - When creating a PR, add `?template=backend.md` or other template name to the URL
> - 或者直接复制粘贴对应模板的内容
> - Or simply copy and paste the content from the corresponding template
---
> **💡 提示 Tip:** 推荐 PR 标题格式 `type(scope): description`
> 例如: `feat(trader): add new strategy` | `fix(api): resolve auth issue`
---
## 📝 Description | 描述
<!-- Provide a brief summary of your changes -->
<!-- 简要描述你的变更 -->
**English:** ｜ **中文：**
**English:**
**中文：**
---
## 🎯 Type of Change | 变更类型
<!-- Mark the relevant option with an "x" -->
<!-- 在相关选项上打"x" -->
- [ ] 🐛 Bug fix | 修复 Bug（不影响现有功能的修复）
- [ ] ✨ New feature | 新功能（不影响现有功能的新增）
- [ ] 💥 Breaking change | 破坏性变更（会导致现有功能无法正常工作的修复或功能）
- [ ] 🐛 Bug fix | 修复 Bug
- [ ] ✨ New feature | 新功能
- [ ] 💥 Breaking change | 破坏性变更
- [ ] 📝 Documentation update | 文档更新
- [ ] 🎨 Code style update | 代码样式更新（格式化、重命名等）
- [ ] ♻️ Refactoring | 重构（无功能变更）
- [ ] 🎨 Code style update | 代码样式更新
- [ ] ♻️ Refactoring | 重构
- [ ] ⚡ Performance improvement | 性能优化
- [ ] ✅ Test update | 测试更新
- [ ] 🔧 Build/config change | 构建/配置变更
@@ -37,9 +48,6 @@
## 🔗 Related Issues | 相关 Issue
<!-- Link related issues below. Use "Closes #123" to auto-close issues when PR is merged -->
<!-- 在下方关联相关 issue。使用 "Closes #123" 可以在 PR 合并时自动关闭 issue -->
- Closes # | 关闭 #
- Related to # | 相关 #
@@ -47,242 +55,50 @@
## 📋 Changes Made | 具体变更
<!-- List the specific changes you made -->
<!-- 列出你做的具体变更 -->
**English:**
- Change 1
- Change 2
- Change 3
**中文：**
- 变更 1
- 变更 2
- 变更 3
**English:** ｜ **中文：**
-
-
---
## 🧪 Testing | 测试
### Manual Testing | 手动测试
<!-- Describe how you tested your changes -->
<!-- 描述你如何测试你的变更 -->
- [ ] Tested locally | 本地测试通过
- [ ] Tested on testnet | 测试网测试通过（交易所集成相关）
- [ ] Tested with different configurations | 测试了不同配置
- [ ] Tests pass | 测试通过
- [ ] Verified no existing functionality broke | 确认没有破坏现有功能
### Test Environment | 测试环境
- **OS | 操作系统:** [e.g. macOS, Ubuntu, Windows]
- **Go Version | Go 版本:** [e.g. 1.21.5]
- **Node Version | Node 版本:** [e.g. 18.x] (if applicable | 如适用)
- **Exchange | 交易所:** [if applicable | 如适用]
### Test Results | 测试结果
<!-- Paste relevant test output or describe results -->
<!-- 粘贴相关测试输出或描述结果 -->
```
Test output here | 测试输出
```
---
## 📸 Screenshots / Demo | 截图/演示
<!-- If applicable, add screenshots or video demo -->
<!-- 如适用，添加截图或视频演示 -->
<!-- For UI changes, include before/after screenshots -->
<!-- 对于 UI 变更，包含变更前后的截图 -->
**Before | 变更前:**
**After | 变更后:**
---
## ✅ Checklist | 检查清单
<!-- Mark completed items with an "x" -->
<!-- 在已完成的项目上打"x" -->
### Code Quality | 代码质量
- [ ] My code follows the project's code style | 我的代码遵循项目代码风格 ([Contributing Guide](../CONTRIBUTING.md))
- [ ] I have performed a self-review of my code | 我已进行代码自查
- [ ] I have commented my code, particularly in hard-to-understand areas | 我已添加代码注释，特别是难以理解的部分
- [ ] My changes generate no new warnings or errors | 我的变更没有产生新的警告或错误
- [ ] Code compiles successfully | 代码编译成功 (`go build` / `npm run build`)
- [ ] I have run `go fmt` (for Go code) | 我已运行 `go fmt`（Go 代码）
- [ ] I have run `npm run lint` (for frontend code) | 我已运行 `npm run lint`（前端代码）
### Testing | 测试
- [ ] I have added tests that prove my fix is effective or that my feature works | 我已添加证明修复有效或功能正常的测试
- [ ] New and existing unit tests pass locally | 新旧单元测试在本地通过
- [ ] I have tested on testnet (for trading/exchange changes) | 我已在测试网测试（交易/交易所变更）
- [ ] Integration tests pass | 集成测试通过
- [ ] Code follows project style | 代码遵循项目风格
- [ ] Self-review completed | 已完成代码自查
- [ ] Comments added for complex logic | 已添加必要注释
### Documentation | 文档
- [ ] I have updated the documentation accordingly | 我已相应更新文档
- [ ] I have updated the README if needed | 我已更新 README（如需要）
- [ ] I have added inline code comments where necessary | 我已在必要处添加代码注释
- [ ] I have updated type definitions (for TypeScript changes) | 我已更新类型定义（TypeScript 变更）
- [ ] I have updated API documentation (if applicable) | 我已更新 API 文档（如适用）
- [ ] Updated relevant documentation | 已更新相关文档
### Git
- [ ] My commits follow the conventional commits format | 我的提交遵循 Conventional Commits 格式 (`feat:`, `fix:`, etc.)
- [ ] I have rebased my branch on the latest `dev` branch | 我已将分支 rebase 到最新的 `dev` 分支
- [ ] There are no merge conflicts | 没有合并冲突
- [ ] Commit messages are clear and descriptive | 提交信息清晰明确
---
## 🔒 Security Considerations | 安全考虑
<!-- Answer these questions for security-sensitive changes -->
<!-- 对于安全敏感的变更，请回答以下问题 -->
- [ ] No API keys or secrets are hardcoded | 没有硬编码 API 密钥或密钥
- [ ] User inputs are properly validated | 用户输入已正确验证
- [ ] No SQL injection vulnerabilities introduced | 未引入 SQL 注入漏洞
- [ ] No XSS vulnerabilities introduced | 未引入 XSS 漏洞
- [ ] Authentication/authorization properly handled | 认证/授权已正确处理
- [ ] Sensitive data is encrypted | 敏感数据已加密
- [ ] N/A (not security-related) | 不适用（非安全相关）
---
## ⚡ Performance Impact | 性能影响
<!-- Describe any performance implications -->
<!-- 描述任何性能影响 -->
- [ ] No significant performance impact | 无显著性能影响
- [ ] Performance improved | 性能提升
- [ ] Performance may be impacted (explain below) | 性能可能受影响（请在下方说明）
<!-- If performance impacted, explain: -->
<!-- 如果性能受影响，请说明： -->
**English:**
**中文：**
---
## 🌐 Internationalization | 国际化
<!-- For UI/documentation changes -->
<!-- 对于 UI/文档变更 -->
- [ ] All user-facing text supports i18n | 所有面向用户的文本支持国际化
- [ ] Both English and Chinese versions provided | 提供了中英文版本
- [ ] N/A | 不适用
- [ ] Commits follow conventional format | 提交遵循 Conventional Commits 格式
- [ ] Rebased on latest `dev` branch | 已 rebase 到最新 `dev` 分支
- [ ] No merge conflicts | 无合并冲突
---
## 📚 Additional Notes | 补充说明
<!-- Any additional information for reviewers -->
<!-- 给审查者的任何补充信息 -->
**English:** ｜ **中文：**
**English:**
**中文：**
---
## 💰 For Bounty Claims | 赏金申请
**By submitting this PR, I confirm | 提交此 PR，我确认：**
<!-- Fill this section only if claiming a bounty -->
<!-- 仅在申请赏金时填写此部分 -->
- [ ] This PR is for bounty issue # | 此 PR 用于赏金 issue #
- [ ] All acceptance criteria from the bounty issue are met | 满足赏金 issue 的所有验收标准
- [ ] I have included a demo video/screenshots | 我已包含演示视频/截图
- [ ] I am ready for payment upon merge | 我准备好在合并后接收付款
**Payment Details | 付款详情:** <!-- Discuss privately with maintainers | 与维护者私下讨论 -->
- [ ] I have read the [Contributing Guidelines](../CONTRIBUTING.md) | 已阅读贡献指南
- [ ] I agree to the [Code of Conduct](../CODE_OF_CONDUCT.md) | 同意行为准则
- [ ] My contribution is licensed under AGPL-3.0 | 贡献遵循 AGPL-3.0 许可证
---
## 🙏 Reviewer Notes | 审查者注意事项
<!-- Optional: anything specific you want reviewers to focus on? -->
<!-- 可选：你希望审查者关注的特定内容？ -->
**English:**
**中文：**
---
## 📋 PR Size Estimate | PR 大小估计
<!-- This helps reviewers plan their time -->
<!-- 这有助于审查者安排时间 -->
- [ ] 🟢 Small (< 100 lines) | 小（< 100 行）
- [ ] 🟡 Medium (100-500 lines) | 中（100-500 行）
- [ ] 🔴 Large (> 500 lines) | 大（> 500 行）
<!-- For large PRs, consider: -->
<!-- 对于大型 PR，考虑： -->
<!-- - Breaking into smaller, focused PRs | 拆分为更小、更专注的 PR -->
<!-- - Providing a detailed explanation | 提供详细说明 -->
<!-- - Highlighting the most important changes | 突出最重要的变更 -->
---
## 🎯 Review Focus Areas | 审查重点
<!-- Help reviewers know where to focus their attention -->
<!-- 帮助审查者了解重点关注的地方 -->
Please pay special attention to:
请特别注意：
- [ ] Logic changes | 逻辑变更
- [ ] Security implications | 安全影响
- [ ] Performance optimization | 性能优化
- [ ] API changes | API 变更
- [ ] Database schema changes | 数据库架构变更
- [ ] UI/UX changes | UI/UX 变更
---
**By submitting this PR, I confirm that:**
**提交此 PR，我确认：**
- [ ] I have read the [Contributing Guidelines](../CONTRIBUTING.md) | 我已阅读[贡献指南](../CONTRIBUTING.md)
- [ ] I agree to the [Code of Conduct](../CODE_OF_CONDUCT.md) | 我同意[行为准则](../CODE_OF_CONDUCT.md)
- [ ] My contribution is licensed under the MIT License | 我的贡献遵循 MIT 许可证
- [ ] I understand this is a voluntary contribution | 我理解这是自愿贡献
- [ ] I have the right to submit this code | 我有权提交此代码
---
<!--
🌟 感谢你的贡献！Thank you for your contribution!
贡献者来自世界各地，我们重视每一份贡献。
Contributors come from all around the world, and we value every contribution.
如果你是首次贡献，欢迎加入我们的社区！
If this is your first contribution, welcome to our community!
💬 需要帮助？Feel free to ask questions in:
- GitHub Discussions
- Discord: [链接 Link]
- Telegram: [链接 Link]
-->
🌟 **Thank you for your contribution! | 感谢你的贡献！**
.github/PULL_REQUEST_TEMPLATE/README.md
+213
View File
@@ -0,0 +1,213 @@
# PR Templates | PR 模板
## 📋 模板概述 | Template Overview
我们提供了4种针对不同类型PR的专用模板，帮助贡献者快速填写PR信息：
We offer 4 specialized templates for different types of PRs to help contributors quickly fill out PR information:
### 1. 🔧 Backend Template | 后端模板
**文件:** `backend.md`
**适用于 | Use for:**
- Go代码变更 | Go code changes
- API端点开发 | API endpoint development
- 交易逻辑实现 | Trading logic implementation
- 后端性能优化 | Backend performance optimization
- 数据库相关改动 | Database-related changes
**包含 | Includes:**
- Go测试环境配置 | Go test environment
- 安全考虑检查 | Security considerations
- 性能影响评估 | Performance impact assessment
- `go fmt` 和 `go build` 检查 | `go fmt` and `go build` checks
### 2. 🎨 Frontend Template | 前端模板
**文件:** `frontend.md`
**适用于 | Use for:**
- UI/UX变更 | UI/UX changes
- React/Vue组件开发 | React/Vue component development
- 前端样式更新 | Frontend styling updates
- 浏览器兼容性修复 | Browser compatibility fixes
- 前端性能优化 | Frontend performance optimization
**包含 | Includes:**
- 截图/演示要求 | Screenshots/demo requirements
- 浏览器测试清单 | Browser testing checklist
- 国际化检查 | Internationalization checks
- 响应式设计验证 | Responsive design verification
- `npm run lint` 和 `npm run build` 检查 | Linting and build checks
### 3. 📝 Documentation Template | 文档模板
**文件:** `docs.md`
**适用于 | Use for:**
- README更新 | README updates
- API文档编写 | API documentation
- 教程和指南 | Tutorials and guides
- 代码注释改进 | Code comment improvements
- 翻译工作 | Translation work
**包含 | Includes:**
- 文档类型分类 | Documentation type classification
- 内容质量检查 | Content quality checks
- 双语要求（中英文）| Bilingual requirements (EN/CN)
- 链接有效性验证 | Link validity verification
### 4. 📦 General Template | 通用模板
**文件:** `general.md`
**适用于 | Use for:**
- 混合类型变更 | Mixed-type changes
- 跨多个领域的PR | Cross-domain PRs
- 构建配置变更 | Build configuration changes
- 依赖更新 | Dependency updates
- 不确定使用哪个模板时 | When unsure which template to use
## 🤖 自动模板建议 | Automatic Template Suggestion
我们的GitHub Action会自动分析你的PR并建议最合适的模板：
Our GitHub Action automatically analyzes your PR and suggests the most suitable template:
### 工作原理 | How it works:
1. **文件分析 | File Analysis**
- 检测PR中所有变更的文件类型
- Detects all changed file types in the PR
2. **智能判断 | Smart Detection**
- 如果 >50% 是 `.go` 文件 → 建议**后端模板**
- If >50% are `.go` files → Suggests **Backend template**
- 如果 >50% 是 `.js/.ts/.tsx/.vue` 文件 → 建议**前端模板**
- If >50% are `.js/.ts/.tsx/.vue` files → Suggests **Frontend template**
- 如果 >70% 是 `.md` 文件 → 建议**文档模板**
- If >70% are `.md` files → Suggests **Documentation template**
3. **自动评论 | Auto-comment**
- 如果检测到你使用了默认模板，但应该用专用模板
- If it detects you're using the default template but should use a specialized one
- 会自动添加友好的评论建议
- It will automatically add a friendly comment suggestion
4. **自动标签 | Auto-labeling**
- 自动添加对应的标签：`backend`、`frontend`、`documentation`
- Automatically adds corresponding labels: `backend`, `frontend`, `documentation`
## 📖 使用方法 | How to Use
### 方法1: URL参数（推荐） | Method 1: URL Parameter (Recommended)
创建PR时，在URL末尾添加模板参数：
When creating a PR, add the template parameter to the URL:
```
https://github.com/YOUR_ORG/nofx/compare/dev...YOUR_BRANCH?template=backend.md
```
替换 `backend.md` 为：
Replace `backend.md` with:
- `backend.md` - 后端模板 | Backend template
- `frontend.md` - 前端模板 | Frontend template
- `docs.md` - 文档模板 | Documentation template
- `general.md` - 通用模板 | General template
### 方法2: 手动选择 | Method 2: Manual Selection
1. 创建PR时，默认模板会显示
When creating a PR, the default template will be shown
2. 根据顶部的指引链接，点击查看对应的模板
Follow the guidance links at the top to view the corresponding template
3. 复制模板内容到PR描述中
Copy the template content into the PR description
### 方法3: 跟随自动建议 | Method 3: Follow Auto-suggestion
1. 使用任何模板创建PR
Create a PR with any template
2. GitHub Action会自动分析并评论建议
GitHub Action will automatically analyze and comment with a suggestion
3. 根据建议更新PR描述
Update the PR description based on the suggestion
## 🎯 最佳实践 | Best Practices
1. **提前选择 | Choose in Advance**
- 在创建PR前确定变更类型
- Determine the change type before creating the PR
2. **完整填写 | Complete Filling**
- 不要跳过必填项（标记为 required）
- Don't skip required items
3. **保持简洁 | Keep it Concise**
- 描述清晰但简洁
- Keep descriptions clear but concise
4. **添加截图 | Add Screenshots**
- 对于UI变更，务必添加截图
- For UI changes, always add screenshots
5. **测试证明 | Test Evidence**
- 提供测试通过的证据
- Provide evidence that tests pass
## 🔧 自定义 | Customization
如果需要修改模板或自动检测逻辑：
If you need to modify templates or auto-detection logic:
1. **修改模板** | **Modify Templates**
- 编辑 `.github/PULL_REQUEST_TEMPLATE/*.md` 文件
- Edit `.github/PULL_REQUEST_TEMPLATE/*.md` files
2. **调整检测阈值** | **Adjust Detection Threshold**
- 编辑 `.github/workflows/pr-template-suggester.yml`
- Edit `.github/workflows/pr-template-suggester.yml`
- 修改文件类型占比阈值（当前：50%后端，50%前端，70%文档）
- Modify file type percentage thresholds (current: 50% backend, 50% frontend, 70% docs)
3. **添加新模板** | **Add New Template**
- 在 `PULL_REQUEST_TEMPLATE/` 目录创建新的 `.md` 文件
- Create a new `.md` file in the `PULL_REQUEST_TEMPLATE/` directory
- 更新工作流以支持新的文件类型检测
- Update the workflow to support new file type detection
## ❓ FAQ
**Q: 我的PR既有前端又有后端代码，用哪个模板？**
**Q: My PR has both frontend and backend code, which template should I use?**
A: 使用**通用模板**（`general.md`），或选择主要变更类型的模板。
A: Use the **General template** (`general.md`), or choose the template for the primary change type.
---
**Q: 自动建议的模板不合适怎么办？**
**Q: What if the automatically suggested template is not suitable?**
A: 你可以忽略建议，继续使用当前模板。自动建议仅供参考。
A: You can ignore the suggestion and continue using the current template. Auto-suggestions are for reference only.
---
**Q: 可以不使用任何模板吗？**
**Q: Can I not use any template?**
A: 不推荐。模板帮助确保PR包含必要信息，加快审查速度。
A: Not recommended. Templates help ensure PRs contain necessary information and speed up reviews.
---
**Q: 如何禁用自动模板建议？**
**Q: How to disable automatic template suggestions?**
A: 删除或禁用 `.github/workflows/pr-template-suggester.yml` 文件。
A: Delete or disable the `.github/workflows/pr-template-suggester.yml` file.
---
🌟 **感谢使用我们的PR模板系统！| Thank you for using our PR template system!**
.github/PULL_REQUEST_TEMPLATE/backend.md
+121
View File
@@ -0,0 +1,121 @@
# Pull Request - Backend | 后端 PR
> **💡 提示 Tip:** 推荐 PR 标题格式 `type(scope): description`
> 例如: `feat(trader): add new strategy` | `fix(api): resolve auth issue`
---
## 📝 Description | 描述
**English:** ｜ **中文：**
---
## 🎯 Type of Change | 变更类型
- [ ] 🐛 Bug fix | 修复 Bug
- [ ] ✨ New feature | 新功能
- [ ] 💥 Breaking change | 破坏性变更
- [ ] ♻️ Refactoring | 重构
- [ ] ⚡ Performance improvement | 性能优化
- [ ] 🔒 Security fix | 安全修复
- [ ] 🔧 Build/config change | 构建/配置变更
---
## 🔗 Related Issues | 相关 Issue
- Closes # | 关闭 #
- Related to # | 相关 #
---
## 📋 Changes Made | 具体变更
**English:** ｜ **中文：**
-
-
---
## 🧪 Testing | 测试
### Test Environment | 测试环境
- **OS | 操作系统:**
- **Go Version | Go 版本:**
- **Exchange | 交易所:** [if applicable | 如适用]
### Manual Testing | 手动测试
- [ ] Tested locally | 本地测试通过
- [ ] Tested on testnet | 测试网测试通过（交易所集成相关）
- [ ] Unit tests pass | 单元测试通过
- [ ] Verified no existing functionality broke | 确认没有破坏现有功能
### Test Results | 测试结果
```
Test output here | 测试输出
```
---
## 🔒 Security Considerations | 安全考虑
- [ ] No API keys or secrets hardcoded | 没有硬编码 API 密钥
- [ ] User inputs properly validated | 用户输入已正确验证
- [ ] No SQL injection vulnerabilities | 无 SQL 注入漏洞
- [ ] Authentication/authorization properly handled | 认证/授权正确处理
- [ ] Sensitive data is encrypted | 敏感数据已加密
- [ ] N/A (not security-related) | 不适用
---
## ⚡ Performance Impact | 性能影响
- [ ] No significant performance impact | 无显著性能影响
- [ ] Performance improved | 性能提升
- [ ] Performance may be impacted (explain below) | 性能可能受影响
**If impacted, explain | 如果受影响，请说明：**
---
## ✅ Checklist | 检查清单
### Code Quality | 代码质量
- [ ] Code follows project style | 代码遵循项目风格
- [ ] Self-review completed | 已完成代码自查
- [ ] Comments added for complex logic | 已添加必要注释
- [ ] Code compiles successfully | 代码编译成功 (`go build`)
- [ ] Ran `go fmt` | 已运行 `go fmt`
### Documentation | 文档
- [ ] Updated relevant documentation | 已更新相关文档
- [ ] Added inline comments where necessary | 已添加必要的代码注释
- [ ] Updated API documentation (if applicable) | 已更新 API 文档
### Git
- [ ] Commits follow conventional format | 提交遵循 Conventional Commits 格式
- [ ] Rebased on latest `dev` branch | 已 rebase 到最新 `dev` 分支
- [ ] No merge conflicts | 无合并冲突
---
## 📚 Additional Notes | 补充说明
**English:** ｜ **中文：**
---
**By submitting this PR, I confirm | 提交此 PR，我确认：**
- [ ] I have read the [Contributing Guidelines](../../CONTRIBUTING.md) | 已阅读贡献指南
- [ ] I agree to the [Code of Conduct](../../CODE_OF_CONDUCT.md) | 同意行为准则
- [ ] My contribution is licensed under AGPL-3.0 | 贡献遵循 AGPL-3.0 许可证
---
🌟 **Thank you for your contribution! | 感谢你的贡献！**
.github/PULL_REQUEST_TEMPLATE/docs.md
+97
View File
@@ -0,0 +1,97 @@
# Pull Request - Documentation | 文档 PR
> **💡 提示 Tip:** 推荐 PR 标题格式 `docs(scope): description`
> 例如: `docs(api): update trading endpoints` | `docs(readme): add setup guide`
---
## 📝 Description | 描述
**English:** ｜ **中文：**
---
## 📚 Type of Documentation | 文档类型
- [ ] 📖 README update | README 更新
- [ ] 📋 API documentation | API 文档
- [ ] 🎓 Tutorial/Guide | 教程/指南
- [ ] 📝 Code comments | 代码注释
- [ ] 🔧 Configuration docs | 配置文档
- [ ] 🐛 Fix typo/error | 修复拼写/错误
- [ ] 🌍 Translation | 翻译
---
## 🔗 Related Issues | 相关 Issue
- Closes # | 关闭 #
- Related to # | 相关 #
---
## 📋 Changes Made | 具体变更
**English:** ｜ **中文：**
-
-
---
## 📸 Screenshots (if applicable) | 截图（如适用）
<!-- For documentation with images, diagrams, or UI examples -->
<!-- 用于包含图片、图表或 UI 示例的文档 -->
---
## 🌐 Internationalization | 国际化
- [ ] English version complete | 英文版本完整
- [ ] Chinese version complete | 中文版本完整
- [ ] Both versions are consistent | 两个版本内容一致
- [ ] N/A (only one language needed) | 不适用（只需要一种语言）
---
## ✅ Checklist | 检查清单
### Content Quality | 内容质量
- [ ] Information is accurate and up-to-date | 信息准确且最新
- [ ] Language is clear and concise | 语言清晰简洁
- [ ] No spelling or grammar errors | 无拼写或语法错误
- [ ] Links are valid and working | 链接有效且可用
- [ ] Code examples are tested and working | 代码示例已测试且可用
- [ ] Formatting is consistent | 格式一致
### Documentation Standards | 文档标准
- [ ] Follows project documentation style | 遵循项目文档风格
- [ ] Includes necessary examples | 包含必要的示例
- [ ] Technical terms are explained | 技术术语已解释
- [ ] Self-review completed | 已完成自查
### Git
- [ ] Commits follow conventional format | 提交遵循 Conventional Commits 格式
- [ ] Rebased on latest `dev` branch | 已 rebase 到最新 `dev` 分支
- [ ] No merge conflicts | 无合并冲突
---
## 📚 Additional Notes | 补充说明
**English:** ｜ **中文：**
---
**By submitting this PR, I confirm | 提交此 PR，我确认：**
- [ ] I have read the [Contributing Guidelines](../../CONTRIBUTING.md) | 已阅读贡献指南
- [ ] I agree to the [Code of Conduct](../../CODE_OF_CONDUCT.md) | 同意行为准则
- [ ] My contribution is licensed under AGPL-3.0 | 贡献遵循 AGPL-3.0 许可证
---
🌟 **Thank you for your contribution! | 感谢你的贡献！**
.github/PULL_REQUEST_TEMPLATE/frontend.md
+119
View File
@@ -0,0 +1,119 @@
# Pull Request - Frontend | 前端 PR
> **💡 提示 Tip:** 推荐 PR 标题格式 `type(scope): description`
> 例如: `feat(ui): add dark mode toggle` | `fix(form): resolve validation bug`
---
## 📝 Description | 描述
**English:** ｜ **中文：**
---
## 🎯 Type of Change | 变更类型
- [ ] 🐛 Bug fix | 修复 Bug
- [ ] ✨ New feature | 新功能
- [ ] 💥 Breaking change | 破坏性变更
- [ ] 🎨 Code style update | 代码样式更新
- [ ] ♻️ Refactoring | 重构
- [ ] ⚡ Performance improvement | 性能优化
---
## 🔗 Related Issues | 相关 Issue
- Closes # | 关闭 #
- Related to # | 相关 #
---
## 📋 Changes Made | 具体变更
**English:** ｜ **中文：**
-
-
---
## 📸 Screenshots / Demo | 截图/演示
<!-- For UI changes, include before/after screenshots or video demo -->
<!-- 对于 UI 变更，请包含变更前后的截图或视频演示 -->
**Before | 变更前:**
**After | 变更后:**
---
## 🧪 Testing | 测试
### Test Environment | 测试环境
- **OS | 操作系统:**
- **Node Version | Node 版本:**
- **Browser(s) | 浏览器:**
### Manual Testing | 手动测试
- [ ] Tested in development mode | 开发模式测试通过
- [ ] Tested production build | 生产构建测试通过
- [ ] Tested on multiple browsers | 多浏览器测试通过
- [ ] Tested responsive design | 响应式设计测试通过
- [ ] Verified no existing functionality broke | 确认没有破坏现有功能
---
## 🌐 Internationalization | 国际化
- [ ] All user-facing text supports i18n | 所有面向用户的文本支持国际化
- [ ] Both English and Chinese versions provided | 提供了中英文版本
- [ ] N/A | 不适用
---
## ✅ Checklist | 检查清单
### Code Quality | 代码质量
- [ ] Code follows project style | 代码遵循项目风格
- [ ] Self-review completed | 已完成代码自查
- [ ] Comments added for complex logic | 已添加必要注释
- [ ] Code builds successfully | 代码构建成功 (`npm run build`)
- [ ] Ran `npm run lint` | 已运行 `npm run lint`
- [ ] No console errors or warnings | 无控制台错误或警告
### Testing | 测试
- [ ] Component tests added/updated | 已添加/更新组件测试
- [ ] Tests pass locally | 测试在本地通过
### Documentation | 文档
- [ ] Updated relevant documentation | 已更新相关文档
- [ ] Updated type definitions (TypeScript) | 已更新类型定义
- [ ] Added JSDoc comments where necessary | 已添加 JSDoc 注释
### Git
- [ ] Commits follow conventional format | 提交遵循 Conventional Commits 格式
- [ ] Rebased on latest `dev` branch | 已 rebase 到最新 `dev` 分支
- [ ] No merge conflicts | 无合并冲突
---
## 📚 Additional Notes | 补充说明
**English:** ｜ **中文：**
---
**By submitting this PR, I confirm | 提交此 PR，我确认：**
- [ ] I have read the [Contributing Guidelines](../../CONTRIBUTING.md) | 已阅读贡献指南
- [ ] I agree to the [Code of Conduct](../../CODE_OF_CONDUCT.md) | 同意行为准则
- [ ] My contribution is licensed under AGPL-3.0 | 贡献遵循 AGPL-3.0 许可证
---
🌟 **Thank you for your contribution! | 感谢你的贡献！**
.github/PULL_REQUEST_TEMPLATE/general.md
+98
View File
@@ -0,0 +1,98 @@
# Pull Request - General | 通用 PR
> **💡 提示 Tip:** 推荐 PR 标题格式 `type(scope): description`
> 例如: `feat(trader): add new strategy` | `fix(api): resolve auth issue` | `docs(readme): update`
---
## 📝 Description | 描述
**English:** ｜ **中文：**
---
## 🎯 Type of Change | 变更类型
- [ ] 🐛 Bug fix | 修复 Bug
- [ ] ✨ New feature | 新功能
- [ ] 💥 Breaking change | 破坏性变更
- [ ] 📝 Documentation update | 文档更新
- [ ] 🎨 Code style update | 代码样式更新
- [ ] ♻️ Refactoring | 重构
- [ ] ⚡ Performance improvement | 性能优化
- [ ] ✅ Test update | 测试更新
- [ ] 🔧 Build/config change | 构建/配置变更
- [ ] 🔒 Security fix | 安全修复
---
## 🔗 Related Issues | 相关 Issue
- Closes # | 关闭 #
- Related to # | 相关 #
---
## 📋 Changes Made | 具体变更
**English:** ｜ **中文：**
-
-
---
## 🧪 Testing | 测试
- [ ] Tested locally | 本地测试通过
- [ ] Tests pass | 测试通过
- [ ] Verified no existing functionality broke | 确认没有破坏现有功能
**Test details | 测试详情：**
---
## ✅ Checklist | 检查清单
### Code Quality | 代码质量
- [ ] Code follows project style | 代码遵循项目风格
- [ ] Self-review completed | 已完成代码自查
- [ ] Comments added for complex logic | 已添加必要注释
- [ ] No new warnings or errors | 无新的警告或错误
### Documentation | 文档
- [ ] Updated relevant documentation | 已更新相关文档
- [ ] Added inline comments where necessary | 已添加必要的代码注释
### Git
- [ ] Commits follow conventional format | 提交遵循 Conventional Commits 格式
- [ ] Rebased on latest `dev` branch | 已 rebase 到最新 `dev` 分支
- [ ] No merge conflicts | 无合并冲突
---
## 🔒 Security (if applicable) | 安全（如适用）
- [ ] No API keys or secrets hardcoded | 没有硬编码 API 密钥
- [ ] User inputs properly validated | 用户输入已正确验证
- [ ] N/A | 不适用
---
## 📚 Additional Notes | 补充说明
**English:** ｜ **中文：**
---
**By submitting this PR, I confirm | 提交此 PR，我确认：**
- [ ] I have read the [Contributing Guidelines](../../CONTRIBUTING.md) | 已阅读贡献指南
- [ ] I agree to the [Code of Conduct](../../CODE_OF_CONDUCT.md) | 同意行为准则
- [ ] My contribution is licensed under AGPL-3.0 | 贡献遵循 AGPL-3.0 许可证
---
🌟 **Thank you for your contribution! | 感谢你的贡献！**
.github/workflows/docker-build.yml
+181
View File
@@ -0,0 +1,181 @@
name: Build and Push Docker Images
on:
push:
branches:
- main
- dev
tags:
- 'v*'
pull_request:
branches:
- main
- dev
workflow_dispatch:
env:
REGISTRY_GHCR: ghcr.io
jobs:
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 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 }}/${{ 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,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: ${{ matrix.platform }}
push: ${{ github.event_name != 'pull_request' }}
tags: ${{ steps.meta.outputs.tags }}
labels: ${{ steps.meta.outputs.labels }}
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 "✅ 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!"
.github/workflows/pr-checks-comment.yml
+145 -31
View File
@@ -104,6 +104,53 @@ jobs:
echo "⚠️ Frontend results artifact not found"
fi
- name: Get PR information
id: pr-info
if: steps.backend.outputs.pr_number != '0'
uses: actions/github-script@v7
with:
script: |
const prNumber = ${{ steps.backend.outputs.pr_number }};
// Get PR details
const { data: pr } = await github.rest.pulls.get({
owner: context.repo.owner,
repo: context.repo.repo,
pull_number: prNumber
});
// Check PR title format (Conventional Commits)
const prTitle = pr.title;
const conventionalCommitPattern = /^(feat|fix|docs|style|refactor|perf|test|chore|ci|security|build)(\(.+\))?: .+/;
const titleValid = conventionalCommitPattern.test(prTitle);
core.setOutput('pr_title', prTitle);
core.setOutput('title_valid', titleValid);
// Calculate PR size
const additions = pr.additions;
const deletions = pr.deletions;
const total = additions + deletions;
let size = '';
let sizeEmoji = '';
if (total < 300) {
size = 'Small';
sizeEmoji = '🟢';
} else if (total < 1000) {
size = 'Medium';
sizeEmoji = '🟡';
} else {
size = 'Large';
sizeEmoji = '🔴';
}
core.setOutput('pr_size', size);
core.setOutput('size_emoji', sizeEmoji);
core.setOutput('total_lines', total);
core.setOutput('additions', additions);
core.setOutput('deletions', deletions);
- name: Post advisory results comment
if: steps.backend.outputs.pr_number != '0'
uses: actions/github-script@v7
@@ -113,7 +160,40 @@ jobs:
let comment = '## 🤖 Advisory Check Results\n\n';
comment += 'These are **advisory** checks to help improve code quality. They won\'t block your PR from being merged.\n\n';
comment += '> **Note:** PR title and size checks are handled by the main workflow and may appear in a separate comment.\n\n';
// PR Information section
const prTitle = '${{ steps.pr-info.outputs.pr_title }}';
const titleValid = '${{ steps.pr-info.outputs.title_valid }}' === 'true';
const prSize = '${{ steps.pr-info.outputs.pr_size }}';
const sizeEmoji = '${{ steps.pr-info.outputs.size_emoji }}';
const totalLines = '${{ steps.pr-info.outputs.total_lines }}';
const additions = '${{ steps.pr-info.outputs.additions }}';
const deletions = '${{ steps.pr-info.outputs.deletions }}';
comment += '### 📋 PR Information\n\n';
// Title check
if (titleValid) {
comment += '**Title Format:** ✅ Good - Follows Conventional Commits\n';
} else {
comment += '**Title Format:** ⚠️ Suggestion - Consider using `type(scope): description`\n';
comment += '<details><summary>Recommended format</summary>\n\n';
comment += '**Valid types:** `feat`, `fix`, `docs`, `style`, `refactor`, `perf`, `test`, `chore`, `ci`, `security`, `build`\n\n';
comment += '**Examples:**\n';
comment += '- `feat(trader): add new trading strategy`\n';
comment += '- `fix(api): resolve authentication issue`\n';
comment += '- `docs: update README`\n';
comment += '</details>\n\n';
}
// Size check
comment += `**PR Size:** ${sizeEmoji} ${prSize} (${totalLines} lines: +${additions} -${deletions})\n`;
if (prSize === 'Large') {
comment += '\n💡 **Suggestion:** This is a large PR. Consider breaking it into smaller, focused PRs for easier review.\n';
}
comment += '\n';
// Backend checks
const fmtStatus = '${{ steps.backend.outputs.fmt_status }}';
@@ -208,37 +288,71 @@ jobs:
return;
}
const prNumber = pulls.data[0].number;
const pr = pulls.data[0];
const prNumber = pr.number;
const comment = [
'## ⚠️ Advisory Checks - Results Unavailable',
'',
'The advisory checks workflow completed, but results could not be retrieved.',
'',
'### Possible reasons:',
'- Artifacts were not uploaded successfully',
'- Artifacts expired (retention: 1 day)',
'- Permission issues',
'',
'### What to do:',
'1. Check the [PR Checks - Run workflow](${{ github.event.workflow_run.html_url }}) logs',
'2. Ensure your code passes local checks:',
'```bash',
'# Backend',
'go fmt ./...',
'go vet ./...',
'go build',
'go test ./...',
'',
'# Frontend (if applicable)',
'cd web',
'npm run build',
'```',
'',
'---',
'',
'*This is an automated fallback message. The advisory checks ran but results are not available.*'
].join('\n');
// Get PR information for fallback comment
const prTitle = pr.title;
const conventionalCommitPattern = /^(feat|fix|docs|style|refactor|perf|test|chore|ci|security|build)(\(.+\))?: .+/;
const titleValid = conventionalCommitPattern.test(prTitle);
const additions = pr.additions || 0;
const deletions = pr.deletions || 0;
const total = additions + deletions;
let size = '';
let sizeEmoji = '';
if (total < 300) {
size = 'Small';
sizeEmoji = '🟢';
} else if (total < 1000) {
size = 'Medium';
sizeEmoji = '🟡';
} else {
size = 'Large';
sizeEmoji = '🔴';
}
let comment = '## ⚠️ Advisory Checks - Results Unavailable\n\n';
comment += 'The advisory checks workflow completed, but results could not be retrieved.\n\n';
// Add PR Information
comment += '### 📋 PR Information\n\n';
if (titleValid) {
comment += '**Title Format:** ✅ Good - Follows Conventional Commits\n';
} else {
comment += '**Title Format:** ⚠️ Suggestion - Consider using `type(scope): description`\n';
}
comment += `**PR Size:** ${sizeEmoji} ${size} (${total} lines: +${additions} -${deletions})\n\n`;
if (size === 'Large') {
comment += '💡 **Suggestion:** This is a large PR. Consider breaking it into smaller, focused PRs for easier review.\n\n';
}
comment += '---\n\n';
comment += '### ⚠️ Backend/Frontend Check Results\n\n';
comment += 'Results could not be retrieved.\n\n';
comment += '**Possible reasons:**\n';
comment += '- Artifacts were not uploaded successfully\n';
comment += '- Artifacts expired (retention: 1 day)\n';
comment += '- Permission issues\n\n';
comment += '**What to do:**\n';
comment += `1. Check the [PR Checks - Run workflow](${context.payload.workflow_run?.html_url || 'logs'}) logs\n`;
comment += '2. Ensure your code passes local checks:\n';
comment += '```bash\n';
comment += '# Backend\n';
comment += 'go fmt ./...\n';
comment += 'go vet ./...\n';
comment += 'go build\n';
comment += 'go test ./...\n\n';
comment += '# Frontend (if applicable)\n';
comment += 'cd web\n';
comment += 'npm run build\n';
comment += '```\n\n';
comment += '---\n\n';
comment += '*This is an automated fallback message. The advisory checks ran but results are not available.*';
await github.rest.issues.createComment({
issue_number: prNumber,
.github/workflows/pr-docker-check.yml
+246
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
});
.github/workflows/pr-go-test-coverage.yml
+84
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
.github/workflows/pr-template-suggester.yml
+189
View File
@@ -0,0 +1,189 @@
name: PR Template Suggester
on:
pull_request:
types: [opened, edited, synchronize]
permissions:
pull-requests: write
contents: read
jobs:
suggest-template:
runs-on: ubuntu-latest
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Analyze PR files and auto-apply template
uses: actions/github-script@v7
with:
github-token: ${{ secrets.GITHUB_TOKEN }}
script: |
const { data: files } = await github.rest.pulls.listFiles({
owner: context.repo.owner,
repo: context.repo.repo,
pull_number: context.issue.number,
});
let goFiles = 0, jsFiles = 0, tsFiles = 0, mdFiles = 0, otherFiles = 0;
for (const file of files) {
const filename = file.filename.toLowerCase();
if (filename.endsWith('.go')) goFiles++;
else if (filename.endsWith('.js') || filename.endsWith('.jsx')) jsFiles++;
else if (filename.endsWith('.ts') || filename.endsWith('.tsx') || filename.endsWith('.vue')) tsFiles++;
else if (filename.endsWith('.md')) mdFiles++;
else otherFiles++;
}
const totalFiles = goFiles + jsFiles + tsFiles + mdFiles + otherFiles;
if (totalFiles === 0) { console.log('No files changed'); return; }
let suggestedTemplate = null, templateEmoji = '', templateLabel = '';
if (goFiles / totalFiles > 0.5) {
suggestedTemplate = 'backend'; templateEmoji = '🔧'; templateLabel = 'backend';
} else if ((jsFiles + tsFiles) / totalFiles > 0.5) {
suggestedTemplate = 'frontend'; templateEmoji = '🎨'; templateLabel = 'frontend';
} else if (mdFiles / totalFiles > 0.7) {
suggestedTemplate = 'docs'; templateEmoji = '📝'; templateLabel = 'documentation';
}
const { data: pr } = await github.rest.pulls.get({
owner: context.repo.owner,
repo: context.repo.repo,
pull_number: context.issue.number,
});
const prBody = pr.body || '';
const usesBackendTemplate = prBody.includes('Pull Request - Backend');
const usesFrontendTemplate = prBody.includes('Pull Request - Frontend');
const usesDocsTemplate = prBody.includes('Pull Request - Documentation');
const usesGeneralTemplate = prBody.includes('Pull Request - General');
const usingDefaultTemplate = !usesBackendTemplate && !usesFrontendTemplate && !usesDocsTemplate && !usesGeneralTemplate;
if (templateLabel) {
try {
await github.rest.issues.addLabels({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: context.issue.number,
labels: [templateLabel]
});
console.log('Added label: ' + templateLabel);
} catch (error) {
console.log('Label might not exist, skipping...');
}
}
function isPRBodyEmpty(body) {
if (!body || body.trim().length < 100) return true;
const hasEmptyDescription = body.includes('**English:**') && body.match(/\*\*English:\*\*\s*\n\s*\n\s*\n/);
const hasEmptyChanges = body.includes('具体变更') && body.match(/\*\*中文：\*\*\s*\n\s*-\s*\n\s*-\s*\n/);
if (hasEmptyDescription || hasEmptyChanges) return true;
const descMatch = body.match(/\*\*English:\*\*[｜|]\s*\*\*中文：\*\*\s*\n\s*(.+)/);
if (!descMatch || descMatch[1].trim().length < 10) return true;
return false;
}
if (suggestedTemplate && usingDefaultTemplate) {
const shouldAutoApply = isPRBodyEmpty(prBody);
const templatePath = '.github/PULL_REQUEST_TEMPLATE/' + suggestedTemplate + '.md';
if (shouldAutoApply) {
try {
const { data: templateFile } = await github.rest.repos.getContent({
owner: context.repo.owner,
repo: context.repo.repo,
path: templatePath,
ref: context.payload.pull_request.head.ref
});
const templateContent = Buffer.from(templateFile.content, 'base64').toString('utf-8');
await github.rest.pulls.update({
owner: context.repo.owner,
repo: context.repo.repo,
pull_number: context.issue.number,
body: templateContent
});
console.log('Auto-applied ' + suggestedTemplate + ' template');
let fileStats = [];
if (goFiles > 0) fileStats.push('- 🔧 Go files: ' + goFiles);
if (jsFiles > 0) fileStats.push('- 🎨 JavaScript files: ' + jsFiles);
if (tsFiles > 0) fileStats.push('- 🎨 TypeScript files: ' + tsFiles);
if (mdFiles > 0) fileStats.push('- 📝 Markdown files: ' + mdFiles);
if (otherFiles > 0) fileStats.push('- 📦 Other files: ' + otherFiles);
const fileStatsText = fileStats.join('\n');
const notifyComment = '## ' + templateEmoji + ' 已自动应用专用模板 | Auto-Applied Template\n\n' +
'检测到您的PR主要包含 **' + suggestedTemplate + '** 相关的变更，系统已自动为您应用相应的模板。\n\n' +
'Detected that your PR primarily contains **' + suggestedTemplate + '** changes. The appropriate template has been automatically applied.\n\n' +
'**文件统计 | File Statistics**\n' + fileStatsText + '\n\n' +
'**已应用模板 | Applied Template**\n`' + templatePath + '`\n\n' +
'✨ 您现在可以直接在PR描述中填写相关信息了！\n\n' +
'✨ You can now fill in the relevant information in the PR description!';
await github.rest.issues.createComment({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: context.issue.number,
body: notifyComment
});
} catch (error) {
console.log('Failed to fetch or apply template: ' + error.message);
const templateUrl = 'https://raw.githubusercontent.com/' + context.repo.owner + '/' + context.repo.repo + '/dev/.github/PULL_REQUEST_TEMPLATE/' + suggestedTemplate + '.md';
const fallbackComment = '## ' + templateEmoji + ' 建议使用专用模板 | Suggested Template\n\n' +
'您的PR主要包含 **' + suggestedTemplate + '** 相关的变更。\n\n' +
'**推荐模板 | Recommended Template:** `.github/PULL_REQUEST_TEMPLATE/' + suggestedTemplate + '.md`\n\n' +
'**如何使用 | How to use:** [点击查看模板内容](' + templateUrl + ')';
await github.rest.issues.createComment({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: context.issue.number,
body: fallbackComment
});
}
} else {
console.log('PR body has content, sending suggestion only');
let fileStats = [];
if (goFiles > 0) fileStats.push('- 🔧 Go files: ' + goFiles);
if (jsFiles > 0) fileStats.push('- 🎨 JavaScript files: ' + jsFiles);
if (tsFiles > 0) fileStats.push('- 🎨 TypeScript files: ' + tsFiles);
if (mdFiles > 0) fileStats.push('- 📝 Markdown files: ' + mdFiles);
if (otherFiles > 0) fileStats.push('- 📦 Other files: ' + otherFiles);
const fileStatsText = fileStats.join('\n');
const templateUrl = 'https://raw.githubusercontent.com/' + context.repo.owner + '/' + context.repo.repo + '/dev/.github/PULL_REQUEST_TEMPLATE/' + suggestedTemplate + '.md';
const comment = '## ' + templateEmoji + ' 建议使用专用模板 | Suggested Template\n\n' +
'您的PR主要包含 **' + suggestedTemplate + '** 相关的变更。我们建议使用更适合的模板以简化填写。\n\n' +
'Your PR primarily contains **' + suggestedTemplate + '** changes. We suggest using a more suitable template to simplify filling.\n\n' +
'**文件统计 | File Statistics**\n' + fileStatsText + '\n\n' +
'**推荐模板 | Recommended Template**\n```\n.github/PULL_REQUEST_TEMPLATE/' + suggestedTemplate + '.md\n```\n\n' +
'**如何使用 | How to use**\n' +
'1. 编辑PR描述 | Edit PR description\n' +
'2. 复制 [' + suggestedTemplate + ' 模板内容](' + templateUrl + ') | Copy [' + suggestedTemplate + ' template content](' + templateUrl + ')\n' +
'3. 或在创建PR时使用URL参数 | Or use URL parameter when creating PR\n' +
' `?template=' + suggestedTemplate + '.md`\n\n' +
'_这是一个自动建议，您可以继续使用当前模板。_\n\n' +
'_This is an automated suggestion. You may continue using the current template._';
await github.rest.issues.createComment({
owner: context.repo.owner,
repo: context.repo.repo,
issue_number: context.issue.number,
body: comment
});
}
} else if (suggestedTemplate && !usingDefaultTemplate) {
console.log('PR already uses a specific template');
} else {
console.log('No specific template suggestion needed - mixed changes');
}
.github/workflows/scripts/calculate_coverage.py
Executable
+192
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()
.github/workflows/scripts/comment_pr.py
Executable
+246
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()
.github/workflows/scripts/requirements.txt
+2
View File
@@ -0,0 +1,2 @@
# Python dependencies for GitHub Actions scripts
requests>=2.31.0
.github/workflows/test.yml
+54
View File
@@ -0,0 +1,54 @@
name: Test
on:
push:
branches: [main, dev]
pull_request:
branches: [main, dev]
jobs:
backend-tests:
name: Backend Tests
runs-on: ubuntu-latest
continue-on-error: true # Don't block PRs
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Set up Go
uses: actions/setup-go@v5
with:
go-version: '1.23'
- name: Download dependencies
run: go mod download
- name: Run tests
run: go test -v ./...
- name: Generate coverage
run: go test -coverprofile=coverage.out ./...
continue-on-error: true
frontend-tests:
name: Frontend Tests
runs-on: ubuntu-latest
continue-on-error: true # Don't block PRs
steps:
- name: Checkout code
uses: actions/checkout@v4
- name: Set up Node.js
uses: actions/setup-node@v4
with:
node-version: '20'
cache: 'npm'
cache-dependency-path: web/package-lock.json
- name: Install dependencies
run: cd web && npm ci
- name: Run tests
run: cd web && npm run test
.gitignore
+98
View File
@@ -5,6 +5,7 @@
# AI 工具
.claude/
CLAUDE.md
# 编译产物
nofx-auto
@@ -29,8 +30,24 @@ Thumbs.db
# 环境变量
.env
config.json
<<<<<<< HEAD
config.db
.tool-versions
=======
config.db*
nofx.db
configbak.json
# 生产配置
nginx/
certs/
beta_codes.txt
# 密钥文件
keys/
*.key
*.pem
>>>>>>> beta
# 决策日志
decision_logs/
@@ -42,4 +59,85 @@ web/node_modules/
node_modules/
web/dist/
web/.vite/
<<<<<<< HEAD
web/yarn.lock
=======
# 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/
>>>>>>> beta
.husky/_/husky.sh
Executable
+36
View File
@@ -0,0 +1,36 @@
#!/usr/bin/env sh
if [ -z "$husky_skip_init" ]; then
debug () {
if [ "$HUSKY_DEBUG" = "1" ]; then
echo "husky (debug) - $1"
fi
}
readonly hook_name="$(basename -- "$0")"
debug "starting $hook_name..."
if [ "$HUSKY" = "0" ]; then
debug "HUSKY env variable is set to 0, skipping hook"
exit 0
fi
if [ -f ~/.huskyrc ]; then
debug "sourcing ~/.huskyrc"
. ~/.huskyrc
fi
readonly husky_skip_init=1
export husky_skip_init
sh -e "$0" "$@"
exitCode="$?"
if [ $exitCode != 0 ]; then
echo "husky - $hook_name hook exited with code $exitCode (error)"
fi
if [ $exitCode = 127 ]; then
echo "husky - command not found in PATH=$PATH"
fi
exit $exitCode
fi
.husky/pre-commit
Executable
+4
View File
@@ -0,0 +1,4 @@
#!/usr/bin/env sh
. "$(dirname -- "$0")/_/husky.sh"
cd web && npx lint-staged
CHANGELOG.md
+1 -1
View File
@@ -13,7 +13,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
### Added
- Documentation system with multi-language support (EN/CN/RU/UK)
- Complete getting-started guides (Docker, PM2, Custom API)
- Complete getting-started guides (Docker, Custom API)
- Architecture documentation with system design details
- User guides with FAQ and troubleshooting
- Community documentation with bounty programs
CHANGELOG.zh-CN.md
+1 -1
View File
@@ -13,7 +13,7 @@ NOFX 项目的所有重要更改都将记录在此文件中。
### 新增
- 多语言文档系统（英文/中文/俄语/乌克兰语）
- 完整的快速开始指南（Docker、PM2、自定义 API）
- 完整的快速开始指南（Docker、自定义 API）
- 架构文档，包含系统设计细节
- 用户指南，包含 FAQ 和故障排除
- 社区文档，包含悬赏计划
DOCKER_DEPLOY.ja.md
+472
View File
@@ -0,0 +1,472 @@
# 🐳 Dockerワンクリックデプロイガイド
このガイドは、Dockerを使用してNOFX AIトレーディング競争システムを迅速にデプロイする方法を説明します。
## 📋 前提条件
開始する前に、システムに以下が必要です：
- **Docker**: バージョン20.10以上
- **Docker Compose**: バージョン2.0以上
### Dockerのインストール
#### macOS / Windows
[Docker Desktop](https://www.docker.com/products/docker-desktop/)をダウンロードしてインストール
#### Linux (Ubuntu/Debian)
> #### Docker Composeバージョンに関する注意
>
> **新規ユーザー推奨：**
> - **Docker Desktopを使用**: 最新のDocker Composeが自動的に含まれ、別途インストールは不要
> - シンプルなインストール、ワンクリックセットアップ、GUI管理を提供
> - macOS、Windows、一部のLinuxディストリビューションをサポート
>
> **既存ユーザー向け注意：**
> - **スタンドアロンdocker-composeの非推奨**: 独立したDocker Composeバイナリのダウンロードは推奨されません
> - **組み込みバージョンを使用**: Docker 20.10+には`docker compose`コマンド（スペース付き）が含まれています
> - 古い`docker-compose`をまだ使用している場合は、新しい構文にアップグレードしてください
*推奨：Docker Desktop（利用可能な場合）またはCompose組み込みのDocker CEを使用*
```bash
# Dockerをインストール（composeを含む）
curl -fsSL https://get.docker.com -o get-docker.sh
sudo sh get-docker.sh
# dockerグループにユーザーを追加
sudo usermod -aG docker $USER
newgrp docker
# インストールを確認（新しいコマンド）
docker --version
docker compose --version # Docker 24+にはこれが含まれており、別途インストール不要
```
## 🚀 クイックスタート（3ステップ）
### ステップ1：設定ファイルを準備
```bash
# 設定テンプレートをコピー
cp config.json.example config.json
# APIキーで設定ファイルを編集
nano config.json # または他のエディタを使用
```
**必須フィールド：**
```json
{
"traders": [
{
"id": "my_trader",
"name": "My AI Trader",
"ai_model": "deepseek",
"binance_api_key": "YOUR_BINANCE_API_KEY", // ← BinanceのAPIキー
"binance_secret_key": "YOUR_BINANCE_SECRET_KEY", // ← Binanceのシークレットキー
"deepseek_key": "YOUR_DEEPSEEK_API_KEY", // ← DeepSeekのAPIキー
"initial_balance": 1000.0,
"scan_interval_minutes": 3
}
],
"use_default_coins": true,
"api_server_port": 8080
}
```
### ステップ2：ワンクリック起動
```bash
# すべてのサービスをビルドして起動（初回実行）
docker compose up -d --build
# 以降の起動（リビルドなし）
docker compose up -d
```
**起動オプション：**
- `--build`: Dockerイメージをビルド（初回実行またはコード更新後に使用）
- `-d`: デタッチモードで実行（バックグラウンド）
### ステップ3：システムにアクセス
デプロイが完了したら、ブラウザを開いて以下にアクセス：
- **Webインターフェース**: http://localhost:3000
- **APIヘルスチェック**: http://localhost:8080/health
## 📊 サービス管理
### 実行状態を表示
```bash
# すべてのコンテナステータスを表示
docker compose ps
# サービスヘルスステータスを表示
docker compose ps --format json | jq
```
### ログを表示
```bash
# すべてのサービスログを表示
docker compose logs -f
# バックエンドログのみを表示
docker compose logs -f backend
# フロントエンドログのみを表示
docker compose logs -f frontend
# 最後の100行を表示
docker compose logs --tail=100
```
### サービスを停止
```bash
# すべてのサービスを停止（データを保持）
docker compose stop
# コンテナを停止して削除（データを保持）
docker compose down
# コンテナとボリュームを停止して削除（すべてのデータをクリア）
docker compose down -v
```
### サービスを再起動
```bash
# すべてのサービスを再起動
docker compose restart
# バックエンドのみを再起動
docker compose restart backend
# フロントエンドのみを再起動
docker compose restart frontend
```
### サービスを更新
```bash
# 最新のコードをプル
git pull
# リビルドして再起動
docker compose up -d --build
```
## 🔧 高度な設定
### ポートを変更
`docker-compose.yml`を編集してポートマッピングを変更：
```yaml
services:
backend:
ports:
- "8080:8080" # "your_port:8080"に変更
frontend:
ports:
- "3000:80" # "your_port:80"に変更
```
### リソース制限
`docker-compose.yml`にリソース制限を追加：
```yaml
services:
backend:
deploy:
resources:
limits:
cpus: '2'
memory: 2G
reservations:
cpus: '1'
memory: 1G
```
### 環境変数
`.env`ファイルを作成して環境変数を管理：
```bash
# .env
TZ=Asia/Tokyo
BACKEND_PORT=8080
FRONTEND_PORT=3000
```
次に`docker-compose.yml`で使用：
```yaml
services:
backend:
ports:
- "${BACKEND_PORT}:8080"
```
## 📁 データの永続化
システムは自動的にデータをローカルディレクトリに永続化します：
- `./decision_logs/`: AI判断ログ
- `./coin_pool_cache/`: コインプールキャッシュ
- `./config.json`: 設定ファイル（マウント済み）
**データの場所：**
```bash
# データディレクトリを表示
ls -la decision_logs/
ls -la coin_pool_cache/
# データをバックアップ
tar -czf backup_$(date +%Y%m%d).tar.gz decision_logs/ coin_pool_cache/ config.json
# データを復元
tar -xzf backup_20241029.tar.gz
```
## 🐛 トラブルシューティング
### コンテナが起動しない
```bash
# 詳細なエラーメッセージを表示
docker compose logs backend
docker compose logs frontend
# コンテナステータスを確認
docker compose ps -a
# リビルド（キャッシュをクリア）
docker compose build --no-cache
```
### ポートが既に使用中
```bash
# ポートを使用しているプロセスを検索
lsof -i :8080 # バックエンドポート
lsof -i :3000 # フロントエンドポート
# プロセスを強制終了
kill -9 <PID>
```
### 設定ファイルが見つからない
```bash
# config.jsonが存在することを確認
ls -la config.json
# 存在しない場合、テンプレートをコピー
cp config.json.example config.json
```
### ヘルスチェックが失敗
```bash
# ヘルスステータスを確認
docker inspect nofx-backend | jq '.[0].State.Health'
docker inspect nofx-frontend | jq '.[0].State.Health'
# ヘルスエンドポイントを手動でテスト
curl http://localhost:8080/health
curl http://localhost:3000/health
```
### フロントエンドがバックエンドに接続できない
```bash
# ネットワーク接続を確認
docker compose exec frontend ping backend
# バックエンドサービスが実行中か確認
docker compose exec frontend wget -O- http://backend:8080/health
```
### Dockerリソースをクリーン
```bash
# 未使用のイメージをクリーン
docker image prune -a
# 未使用のボリュームをクリーン
docker volume prune
# すべての未使用リソースをクリーン（注意して使用）
docker system prune -a --volumes
```
## 🔐 セキュリティ推奨事項
1. **config.jsonをGitにコミットしない**
```bash
# config.jsonが.gitignoreに含まれていることを確認
echo "config.json" >> .gitignore
```
2. **機密データには環境変数を使用**
```yaml
# docker-compose.yml
services:
backend:
environment:
- BINANCE_API_KEY=${BINANCE_API_KEY}
- BINANCE_SECRET_KEY=${BINANCE_SECRET_KEY}
```
3. **APIアクセスを制限**
```yaml
# ローカルアクセスのみを許可
services:
backend:
ports:
- "127.0.0.1:8080:8080"
```
4. **イメージを定期的に更新**
```bash
docker compose pull
docker compose up -d
```
## 🌐 本番環境デプロイ
### Nginxリバースプロキシの使用
```nginx
# /etc/nginx/sites-available/nofx
server {
listen 80;
server_name your-domain.com;
location / {
proxy_pass http://localhost:3000;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
location /api/ {
proxy_pass http://localhost:8080/api/;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
}
}
```
### HTTPSの設定（Let's Encrypt）
```bash
# Certbotをインストール
sudo apt-get install certbot python3-certbot-nginx
# SSL証明書を取得
sudo certbot --nginx -d your-domain.com
# 自動更新
sudo certbot renew --dry-run
```
### Docker Swarmの使用（クラスタデプロイ）
```bash
# Swarmを初期化
docker swarm init
# スタックをデプロイ
docker stack deploy -c docker-compose.yml nofx
# サービスステータスを表示
docker stack services nofx
# サービスをスケール
docker service scale nofx_backend=3
```
## 📈 監視＆ロギング
### ログ管理
```bash
# ログローテーションを設定（docker-compose.ymlで既に設定済み）
logging:
driver: "json-file"
options:
max-size: "10m"
max-file: "3"
# ログ統計を表示
docker compose logs --timestamps | wc -l
```
### 監視ツール統合
Prometheus + Grafanaで監視を統合：
```yaml
# docker-compose.yml（監視サービスを追加）
services:
prometheus:
image: prom/prometheus
ports:
- "9090:9090"
volumes:
- ./prometheus.yml:/etc/prometheus/prometheus.yml
grafana:
image: grafana/grafana
ports:
- "3001:3000"
```
## 🆘 ヘルプを取得
- **GitHub Issues**: [Issueを提出](https://github.com/yourusername/open-nofx/issues)
- **ドキュメント**: [README.md](README.md)を確認
- **コミュニティ**: Discord/Telegramグループに参加
## 📝 コマンドチートシート
```bash
# 起動
docker compose up -d --build # ビルドして起動
docker compose up -d # 起動（リビルドなし）
# 停止
docker compose stop # サービスを停止
docker compose down # コンテナを停止して削除
docker compose down -v # コンテナとデータを停止して削除
# 表示
docker compose ps # ステータスを表示
docker compose logs -f # ログを表示
docker compose top # プロセスを表示
# 再起動
docker compose restart # すべてのサービスを再起動
docker compose restart backend # バックエンドを再起動
# 更新
git pull && docker compose up -d --build
# クリーン
docker compose down -v # すべてのデータをクリア
docker system prune -a # Dockerリソースをクリーン
```
---
🎉 おめでとうございます！NOFX AIトレーディング競争システムのデプロイに成功しました！
問題が発生した場合は、[トラブルシューティング](#-トラブルシューティング)セクションを確認するか、Issueを提出してください。
ENCRYPTION_README.md
+136
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.**
Makefile
+153
View File
@@ -0,0 +1,153 @@
# NOFX Makefile for testing and development
.PHONY: help test test-backend test-frontend test-coverage clean
# Default target
help:
@echo "NOFX Testing & Development Commands"
@echo ""
@echo "Testing:"
@echo " make test - Run all tests (backend + frontend)"
@echo " make test-backend - Run backend tests only"
@echo " make test-frontend - Run frontend tests only"
@echo " make test-coverage - Generate backend coverage report"
@echo ""
@echo "Build:"
@echo " make build - Build backend binary"
@echo " make build-frontend - Build frontend"
@echo ""
@echo "Clean:"
@echo " make clean - Clean build artifacts and test cache"
# =============================================================================
# Testing
# =============================================================================
# Run all tests
test:
@echo "🧪 Running backend tests..."
go test -v ./...
@echo ""
@echo "🧪 Running frontend tests..."
cd web && npm run test
@echo "✅ All tests completed"
# Backend tests only
test-backend:
@echo "🧪 Running backend tests..."
go test -v ./...
# Frontend tests only
test-frontend:
@echo "🧪 Running frontend tests..."
cd web && npm run test
# Coverage report
test-coverage:
@echo "📊 Generating coverage..."
go test -coverprofile=coverage.out ./...
go tool cover -html=coverage.out -o coverage.html
@echo "✅ Backend coverage: coverage.html"
# =============================================================================
# Build
# =============================================================================
# Build backend binary
build:
@echo "🔨 Building backend..."
go build -o nofx
@echo "✅ Backend built: ./nofx"
# Build frontend
build-frontend:
@echo "🔨 Building frontend..."
cd web && npm run build
@echo "✅ Frontend built: ./web/dist"
# =============================================================================
# Development
# =============================================================================
# Run backend in development mode
run:
@echo "🚀 Starting backend..."
go run main.go
# Run frontend in development mode
run-frontend:
@echo "🚀 Starting frontend dev server..."
cd web && npm run dev
# Format Go code
fmt:
@echo "🎨 Formatting Go code..."
go fmt ./...
@echo "✅ Code formatted"
# Lint Go code (requires golangci-lint)
lint:
@echo "🔍 Linting Go code..."
golangci-lint run
@echo "✅ Linting completed"
# =============================================================================
# Clean
# =============================================================================
clean:
@echo "🧹 Cleaning..."
rm -f nofx
rm -f coverage.out coverage.html
rm -rf web/dist
go clean -testcache
@echo "✅ Cleaned"
# =============================================================================
# Docker
# =============================================================================
# Build Docker images
docker-build:
@echo "🐳 Building Docker images..."
docker compose build
@echo "✅ Docker images built"
# Run Docker containers
docker-up:
@echo "🐳 Starting Docker containers..."
docker compose up -d
@echo "✅ Docker containers started"
# Stop Docker containers
docker-down:
@echo "🐳 Stopping Docker containers..."
docker compose down
@echo "✅ Docker containers stopped"
# View Docker logs
docker-logs:
docker compose logs -f
# =============================================================================
# Dependencies
# =============================================================================
# Download Go dependencies
deps:
@echo "📦 Downloading Go dependencies..."
go mod download
@echo "✅ Dependencies downloaded"
# Update Go dependencies
deps-update:
@echo "📦 Updating Go dependencies..."
go get -u ./...
go mod tidy
@echo "✅ Dependencies updated"
# Install frontend dependencies
deps-frontend:
@echo "📦 Installing frontend dependencies..."
cd web && npm install
@echo "✅ Frontend dependencies installed"
README.ja.md
+1343
View File
File diff suppressed because it is too large Load Diff
README.md
+149 -21
View File
@@ -3,14 +3,14 @@
[![Go Version](https://img.shields.io/badge/Go-1.21+-00ADD8?style=flat&logo=go)](https://golang.org/)
[![React](https://img.shields.io/badge/React-18+-61DAFB?style=flat&logo=react)](https://reactjs.org/)
[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-3178C6?style=flat&logo=typescript)](https://www.typescriptlang.org/)
[![License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
[![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:**
@@ -281,7 +326,7 @@ Docker automatically handles all dependencies (Go, Node.js, TA-Lib, SQLite) and
#### Step 1: Prepare Configuration
```bash
# Copy configuration template
cp config.example.jsonc config.json
cp config.json.example config.json
# Edit and fill in your API keys
nano config.json # or use any editor
@@ -292,8 +337,8 @@ nano config.json # or use any editor
#### Step 2: One-Click Start
```bash
# Option 1: Use convenience script (Recommended)
chmod +x start.sh
./start.sh start --build
chmod +x scripts/start.sh
./scripts/start.sh start --build
> #### Docker Compose Version Notes
>
@@ -318,10 +363,10 @@ Open your browser and visit: **http://localhost:3000**
#### Manage Your System
```bash
./start.sh logs # View logs
./start.sh status # Check status
./start.sh stop # Stop services
./start.sh restart # Restart services
./scripts/start.sh logs # View logs
./scripts/start.sh status # Check status
./scripts/start.sh stop # Stop services
./scripts/start.sh restart # Restart services
```
**📖 For detailed Docker deployment guide, troubleshooting, and advanced configuration:**
@@ -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)
@@ -1240,7 +1360,15 @@ sudo apt-get install libta-lib0-dev
## 📄 License
MIT License - See [LICENSE](LICENSE) file for details
This project is licensed under the **GNU Affero General Public License v3.0 (AGPL-3.0)** - See [LICENSE](LICENSE) file for details.
**What this means:**
- ✅ You can use, modify, and distribute this software
- ✅ You must disclose source code of your modifications
- ✅ If you run a modified version on a server, you must make the source code available to users
- ✅ All derivatives must also be licensed under AGPL-3.0
For commercial licensing or questions, please contact the maintainers.
---
api/crypto_handler.go
+72
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
}
api/register_otp_test.go
+252
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)
})
}
}
api/server.go
+716 -104
View File
File diff suppressed because it is too large Load Diff
api/server_test.go
+227
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)
}
}
api/utils.go
+97
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
}
api/utils_test.go
+193
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)
}
})
}
}
auth/auth.go
+41 -8
View File
@@ -3,6 +3,8 @@ package auth
import (
"crypto/rand"
"fmt"
"log"
"sync"
"time"
"github.com/golang-jwt/jwt/v5"
@@ -14,8 +16,14 @@ import (
// JWTSecret JWT密钥，将从配置中动态设置
var JWTSecret []byte
// AdminMode 管理员模式标志
var AdminMode bool = false
// 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"
@@ -25,14 +33,39 @@ func SetJWTSecret(secret string) {
JWTSecret = []byte(secret)
}
// SetAdminMode 设置管理员模式
func SetAdminMode(enabled bool) {
AdminMode = enabled
// 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)
}
}
}
// IsAdminMode 检查是否为管理员模式
func IsAdminMode() bool {
return AdminMode
// 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声明
bootstrap/README.md
+455
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 项目内部模块，遵循项目整体许可证。
bootstrap/bootstrap.go
+169
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)
}
bootstrap/context.go
+49
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
}
bootstrap/hook_builder.go
+27
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
}
bootstrap/init_hook.go
+22
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
}
config.json.example
+4 -2
View File
@@ -1,5 +1,4 @@
{
"admin_mode": true,
"beta_mode": false,
"leverage": {
"btc_eth_leverage": 5,
@@ -20,5 +19,8 @@
"max_daily_loss": 10.0,
"max_drawdown": 20.0,
"stop_trading_minutes": 60,
"jwt_secret": "Qk0kAa+d0iIEzXVHXbNbm+UaN3RNabmWtH8rDWZ5OPf+4GX8pBflAHodfpbipVMyrw1fsDanHsNBjhgbDeK9Jg=="
"jwt_secret": "Qk0kAa+d0iIEzXVHXbNbm+UaN3RNabmWtH8rDWZ5OPf+4GX8pBflAHodfpbipVMyrw1fsDanHsNBjhgbDeK9Jg==",
"log": {
"level": "info"
}
}
config/config.go
+37 -168
View File
@@ -3,197 +3,66 @@ 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）
AltcoinLeverage int `json:"altcoin_leverage"` // 山寨币的杠杆倍数（主账户建议5-20，子账户≤5）
}
// LogConfig 日志配置
type LogConfig struct {
Level string `json:"level"` // 日志级别: debug, info, warn, error (默认: info)
Telegram *TelegramConfig `json:"telegram"` // Telegram推送配置（可选）
}
// TelegramConfig Telegram推送配置（简化版，只保留必需字段）
type TelegramConfig struct {
Enabled bool `json:"enabled"` // 是否启用（默认: false）
BotToken string `json:"bot_token"` // Bot Token
ChatID int64 `json:"chat_id"` // Chat ID
MinLevel string `json:"min_level"` // 最低日志级别，该级别及以上的日志会推送到Telegram（可选，默认: error）
}
// 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"` // 杠杆配置
Leverage LeverageConfig `json:"leverage"`
JWTSecret string `json:"jwt_secret"`
DataKLineTime string `json:"data_k_line_time"`
Log *LogConfig `json:"log"` // 日志配置
}
// 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
}
config/database.go
+221 -32
View File
@@ -7,27 +7,82 @@ import (
"encoding/json"
"fmt"
"log"
"nofx/crypto"
"nofx/market"
"os"
"slices"
"strings"
"time"
_ "github.com/mattn/go-sqlite3"
_ "modernc.org/sqlite"
)
// DatabaseInterface 定义了数据库实现需要提供的方法集合
type DatabaseInterface interface {
SetCryptoService(cs *crypto.CryptoService)
CreateUser(user *User) error
GetUserByEmail(email string) (*User, error)
GetUserByID(userID string) (*User, error)
GetAllUsers() ([]string, error)
UpdateUserOTPVerified(userID string, verified bool) error
GetAIModels(userID string) ([]*AIModelConfig, error)
UpdateAIModel(userID, id string, enabled bool, apiKey, customAPIURL, customModelName string) error
GetExchanges(userID string) ([]*ExchangeConfig, error)
UpdateExchange(userID, id string, enabled bool, apiKey, secretKey string, testnet bool, hyperliquidWalletAddr, asterUser, asterSigner, asterPrivateKey string) error
CreateAIModel(userID, id, name, provider string, enabled bool, apiKey, customAPIURL string) error
CreateExchange(userID, id, name, typ string, enabled bool, apiKey, secretKey string, testnet bool, hyperliquidWalletAddr, asterUser, asterSigner, asterPrivateKey string) error
CreateTrader(trader *TraderRecord) error
GetTraders(userID string) ([]*TraderRecord, error)
UpdateTraderStatus(userID, id string, isRunning bool) error
UpdateTrader(trader *TraderRecord) error
UpdateTraderInitialBalance(userID, id string, newBalance float64) error
UpdateTraderCustomPrompt(userID, id string, customPrompt string, overrideBase bool) error
DeleteTrader(userID, id string) error
GetTraderConfig(userID, traderID string) (*TraderRecord, *AIModelConfig, *ExchangeConfig, error)
GetSystemConfig(key string) (string, error)
SetSystemConfig(key, value string) error
CreateUserSignalSource(userID, coinPoolURL, oiTopURL string) error
GetUserSignalSource(userID string) (*UserSignalSource, error)
UpdateUserSignalSource(userID, coinPoolURL, oiTopURL string) error
GetCustomCoins() []string
LoadBetaCodesFromFile(filePath string) error
ValidateBetaCode(code string) (bool, error)
UseBetaCode(code, userEmail string) error
GetBetaCodeStats() (total, used int, err error)
Close() error
}
// Database 配置数据库
type Database struct {
db *sql.DB
db *sql.DB
cryptoService *crypto.CryptoService
}
// NewDatabase 创建配置数据库
func NewDatabase(dbPath string) (*Database, error) {
db, err := sql.Open("sqlite3", dbPath)
db, err := sql.Open("sqlite", dbPath)
if err != nil {
return nil, fmt.Errorf("打开数据库失败: %w", err)
}
// 🔒 启用 WAL 模式,提高并发性能和崩溃恢复能力
// WAL (Write-Ahead Logging) 模式的优势:
// 1. 更好的并发性能:读操作不会被写操作阻塞
// 2. 崩溃安全:即使在断电或强制终止时也能保证数据完整性
// 3. 更快的写入:不需要每次都写入主数据库文件
if _, err := db.Exec("PRAGMA journal_mode=WAL"); err != nil {
db.Close()
return nil, fmt.Errorf("启用WAL模式失败: %w", err)
}
// 🔒 设置 synchronous=FULL 确保数据持久性
// FULL (2) 模式: 确保数据在关键时刻完全写入磁盘
// 配合 WAL 模式,在保证数据安全的同时获得良好性能
if _, err := db.Exec("PRAGMA synchronous=FULL"); err != nil {
db.Close()
return nil, fmt.Errorf("设置synchronous失败: %w", err)
}
database := &Database{db: db}
if err := database.createTables(); err != nil {
return nil, fmt.Errorf("创建表失败: %w", err)
@@ -37,6 +92,7 @@ func NewDatabase(dbPath string) (*Database, error) {
return nil, fmt.Errorf("初始化默认数据失败: %w", err)
}
log.Printf("✅ 数据库已启用 WAL 模式和 FULL 同步,数据持久性得到保证")
return database, nil
}
@@ -258,17 +314,16 @@ func (d *Database) initDefaultData() error {
// 初始化系统配置 - 创建所有字段，设置默认值，后续由config.json同步更新
systemConfigs := map[string]string{
"admin_mode": "true", // 默认开启管理员模式，便于首次使用
"beta_mode": "false", // 默认关闭内测模式
"api_server_port": "8080", // 默认API端口
"use_default_coins": "true", // 默认使用内置币种列表
"default_coins": `["BTCUSDT","ETHUSDT","SOLUSDT","BNBUSDT","XRPUSDT","DOGEUSDT","ADAUSDT","HYPEUSDT"]`, // 默认币种列表（JSON格式）
"max_daily_loss": "10.0", // 最大日损失百分比
"max_drawdown": "20.0", // 最大回撤百分比
"stop_trading_minutes": "60", // 停止交易时间（分钟）
"btc_eth_leverage": "5", // BTC/ETH杠杆倍数
"altcoin_leverage": "5", // 山寨币杠杆倍数
"jwt_secret": "", // JWT密钥，默认为空，由config.json或系统生成
"beta_mode": "false", // 默认关闭内测模式
"api_server_port": "8080", // 默认API端口
"use_default_coins": "true", // 默认使用内置币种列表
"default_coins": `["BTCUSDT","ETHUSDT","SOLUSDT","BNBUSDT","XRPUSDT","DOGEUSDT","ADAUSDT","HYPEUSDT"]`, // 默认币种列表（JSON格式）
"max_daily_loss": "10.0", // 最大日损失百分比
"max_drawdown": "20.0", // 最大回撤百分比
"stop_trading_minutes": "60", // 停止交易时间（分钟）
"btc_eth_leverage": "5", // BTC/ETH杠杆倍数
"altcoin_leverage": "5", // 山寨币杠杆倍数
"jwt_secret": "", // JWT密钥，默认为空，由config.json或系统生成
}
for key, value := range systemConfigs {
@@ -398,11 +453,12 @@ type ExchangeConfig struct {
Name string `json:"name"`
Type string `json:"type"`
Enabled bool `json:"enabled"`
APIKey string `json:"apiKey"`
SecretKey string `json:"secretKey"`
APIKey string `json:"apiKey"` // For Binance: API Key; For Hyperliquid: Agent Private Key (should have ~0 balance)
SecretKey string `json:"secretKey"` // For Binance: Secret Key; Not used for Hyperliquid
Testnet bool `json:"testnet"`
// Hyperliquid 特定字段
HyperliquidWalletAddr string `json:"hyperliquidWalletAddr"`
// Hyperliquid Agent Wallet configuration (following official best practices)
// Reference: https://hyperliquid.gitbook.io/hyperliquid-docs/for-developers/api/nonces-and-api-wallets
HyperliquidWalletAddr string `json:"hyperliquidWalletAddr"` // Main Wallet Address (holds funds, never expose private key)
// Aster 特定字段
AsterUser string `json:"asterUser"`
AsterSigner string `json:"asterSigner"`
@@ -546,6 +602,16 @@ func (d *Database) UpdateUserOTPVerified(userID string, verified bool) error {
return err
}
// UpdateUserPassword 更新用户密码
func (d *Database) UpdateUserPassword(userID, passwordHash string) error {
_, err := d.db.Exec(`
UPDATE users
SET password_hash = ?, updated_at = CURRENT_TIMESTAMP
WHERE id = ?
`, passwordHash, userID)
return err
}
// GetAIModels 获取用户的AI模型配置
func (d *Database) GetAIModels(userID string) ([]*AIModelConfig, error) {
rows, err := d.db.Query(`
@@ -572,6 +638,8 @@ func (d *Database) GetAIModels(userID string) ([]*AIModelConfig, error) {
if err != nil {
return nil, err
}
// 解密API Key
model.APIKey = d.decryptSensitiveData(model.APIKey)
models = append(models, &model)
}
@@ -588,10 +656,11 @@ func (d *Database) UpdateAIModel(userID, id string, enabled bool, apiKey, custom
if err == nil {
// 找到了现有配置（精确匹配 ID），更新它
encryptedAPIKey := d.encryptSensitiveData(apiKey)
_, err = d.db.Exec(`
UPDATE ai_models SET enabled = ?, api_key = ?, custom_api_url = ?, custom_model_name = ?, updated_at = datetime('now')
WHERE id = ? AND user_id = ?
`, enabled, apiKey, customAPIURL, customModelName, existingID, userID)
`, enabled, encryptedAPIKey, customAPIURL, customModelName, existingID, userID)
return err
}
@@ -604,10 +673,11 @@ func (d *Database) UpdateAIModel(userID, id string, enabled bool, apiKey, custom
if err == nil {
// 找到了现有配置（通过 provider 匹配，兼容旧版），更新它
log.Printf("⚠️ 使用旧版 provider 匹配更新模型: %s -> %s", provider, existingID)
encryptedAPIKey := d.encryptSensitiveData(apiKey)
_, err = d.db.Exec(`
UPDATE ai_models SET enabled = ?, api_key = ?, custom_api_url = ?, custom_model_name = ?, updated_at = datetime('now')
WHERE id = ? AND user_id = ?
`, enabled, apiKey, customAPIURL, customModelName, existingID, userID)
`, enabled, encryptedAPIKey, customAPIURL, customModelName, existingID, userID)
return err
}
@@ -651,10 +721,11 @@ func (d *Database) UpdateAIModel(userID, id string, enabled bool, apiKey, custom
}
log.Printf("✓ 创建新的 AI 模型配置: ID=%s, Provider=%s, Name=%s", newModelID, provider, name)
encryptedAPIKey := d.encryptSensitiveData(apiKey)
_, err = d.db.Exec(`
INSERT INTO ai_models (id, user_id, name, provider, enabled, api_key, custom_api_url, custom_model_name, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
`, newModelID, userID, name, provider, enabled, apiKey, customAPIURL, customModelName)
`, newModelID, userID, name, provider, enabled, encryptedAPIKey, customAPIURL, customModelName)
return err
}
@@ -689,6 +760,12 @@ func (d *Database) GetExchanges(userID string) ([]*ExchangeConfig, error) {
if err != nil {
return nil, err
}
// 解密敏感字段
exchange.APIKey = d.decryptSensitiveData(exchange.APIKey)
exchange.SecretKey = d.decryptSensitiveData(exchange.SecretKey)
exchange.AsterPrivateKey = d.decryptSensitiveData(exchange.AsterPrivateKey)
exchanges = append(exchanges, &exchange)
}
@@ -696,15 +773,52 @@ func (d *Database) GetExchanges(userID string) ([]*ExchangeConfig, error) {
}
// UpdateExchange 更新交易所配置，如果不存在则创建用户特定配置
// 🔒 安全特性：空值不会覆盖现有的敏感字段（api_key, secret_key, aster_private_key）
func (d *Database) UpdateExchange(userID, id string, enabled bool, apiKey, secretKey string, testnet bool, hyperliquidWalletAddr, asterUser, asterSigner, asterPrivateKey string) error {
log.Printf("🔧 UpdateExchange: userID=%s, id=%s, enabled=%v", userID, id, enabled)
// 首先尝试更新现有的用户配置
result, err := d.db.Exec(`
UPDATE exchanges SET enabled = ?, api_key = ?, secret_key = ?, testnet = ?,
hyperliquid_wallet_addr = ?, aster_user = ?, aster_signer = ?, aster_private_key = ?, updated_at = datetime('now')
// 构建动态 UPDATE SET 子句
// 基础字段：总是更新
setClauses := []string{
"enabled = ?",
"testnet = ?",
"hyperliquid_wallet_addr = ?",
"aster_user = ?",
"aster_signer = ?",
"updated_at = datetime('now')",
}
args := []interface{}{enabled, testnet, hyperliquidWalletAddr, asterUser, asterSigner}
// 🔒 敏感字段：只在非空时更新（保护现有数据）
if apiKey != "" {
encryptedAPIKey := d.encryptSensitiveData(apiKey)
setClauses = append(setClauses, "api_key = ?")
args = append(args, encryptedAPIKey)
}
if secretKey != "" {
encryptedSecretKey := d.encryptSensitiveData(secretKey)
setClauses = append(setClauses, "secret_key = ?")
args = append(args, encryptedSecretKey)
}
if asterPrivateKey != "" {
encryptedAsterPrivateKey := d.encryptSensitiveData(asterPrivateKey)
setClauses = append(setClauses, "aster_private_key = ?")
args = append(args, encryptedAsterPrivateKey)
}
// WHERE 条件
args = append(args, id, userID)
// 构建完整的 UPDATE 语句
query := fmt.Sprintf(`
UPDATE exchanges SET %s
WHERE id = ? AND user_id = ?
`, enabled, apiKey, secretKey, testnet, hyperliquidWalletAddr, asterUser, asterSigner, asterPrivateKey, id, userID)
`, strings.Join(setClauses, ", "))
// 执行更新
result, err := d.db.Exec(query, args...)
if err != nil {
log.Printf("❌ UpdateExchange: 更新失败: %v", err)
return err
@@ -743,7 +857,7 @@ func (d *Database) UpdateExchange(userID, id string, enabled bool, apiKey, secre
// 创建用户特定的配置，使用原始的交易所ID
_, err = d.db.Exec(`
INSERT INTO exchanges (id, user_id, name, type, enabled, api_key, secret_key, testnet,
INSERT INTO exchanges (id, user_id, name, type, enabled, api_key, secret_key, testnet,
hyperliquid_wallet_addr, aster_user, aster_signer, aster_private_key, created_at, updated_at)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, datetime('now'), datetime('now'))
`, id, userID, name, typ, enabled, apiKey, secretKey, testnet, hyperliquidWalletAddr, asterUser, asterSigner, asterPrivateKey)
@@ -771,10 +885,15 @@ func (d *Database) CreateAIModel(userID, id, name, provider string, enabled bool
// CreateExchange 创建交易所配置
func (d *Database) CreateExchange(userID, id, name, typ string, enabled bool, apiKey, secretKey string, testnet bool, hyperliquidWalletAddr, asterUser, asterSigner, asterPrivateKey string) error {
// 加密敏感字段
encryptedAPIKey := d.encryptSensitiveData(apiKey)
encryptedSecretKey := d.encryptSensitiveData(secretKey)
encryptedAsterPrivateKey := d.encryptSensitiveData(asterPrivateKey)
_, err := d.db.Exec(`
INSERT OR IGNORE INTO exchanges (id, user_id, name, type, enabled, api_key, secret_key, testnet, hyperliquid_wallet_addr, aster_user, aster_signer, aster_private_key)
VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
`, id, userID, name, typ, enabled, apiKey, secretKey, testnet, hyperliquidWalletAddr, asterUser, asterSigner, asterPrivateKey)
`, id, userID, name, typ, enabled, encryptedAPIKey, encryptedSecretKey, testnet, hyperliquidWalletAddr, asterUser, asterSigner, encryptedAsterPrivateKey)
return err
}
@@ -853,6 +972,12 @@ func (d *Database) UpdateTraderCustomPrompt(userID, id string, customPrompt stri
return err
}
// UpdateTraderInitialBalance 更新交易员初始余额（用于自动同步交易所实际余额）
func (d *Database) UpdateTraderInitialBalance(userID, id string, newBalance float64) error {
_, err := d.db.Exec(`UPDATE traders SET initial_balance = ? WHERE id = ? AND user_id = ?`, newBalance, id, userID)
return err
}
// DeleteTrader 删除交易员
func (d *Database) DeleteTrader(userID, id string) error {
_, err := d.db.Exec(`DELETE FROM traders WHERE id = ? AND user_id = ?`, id, userID)
@@ -866,9 +991,22 @@ func (d *Database) GetTraderConfig(userID, traderID string) (*TraderRecord, *AIM
var exchange ExchangeConfig
err := d.db.QueryRow(`
SELECT
t.id, t.user_id, t.name, t.ai_model_id, t.exchange_id, t.initial_balance, t.scan_interval_minutes, t.is_running, t.created_at, t.updated_at,
a.id, a.user_id, a.name, a.provider, a.enabled, a.api_key, a.created_at, a.updated_at,
SELECT
t.id, t.user_id, t.name, t.ai_model_id, t.exchange_id, t.initial_balance, t.scan_interval_minutes, t.is_running,
COALESCE(t.btc_eth_leverage, 5) as btc_eth_leverage,
COALESCE(t.altcoin_leverage, 5) as altcoin_leverage,
COALESCE(t.trading_symbols, '') as trading_symbols,
COALESCE(t.use_coin_pool, 0) as use_coin_pool,
COALESCE(t.use_oi_top, 0) as use_oi_top,
COALESCE(t.custom_prompt, '') as custom_prompt,
COALESCE(t.override_base_prompt, 0) as override_base_prompt,
COALESCE(t.system_prompt_template, 'default') as system_prompt_template,
COALESCE(t.is_cross_margin, 1) as is_cross_margin,
t.created_at, t.updated_at,
a.id, a.user_id, a.name, a.provider, a.enabled, a.api_key,
COALESCE(a.custom_api_url, '') as custom_api_url,
COALESCE(a.custom_model_name, '') as custom_model_name,
a.created_at, a.updated_at,
e.id, e.user_id, e.name, e.type, e.enabled, e.api_key, e.secret_key, e.testnet,
COALESCE(e.hyperliquid_wallet_addr, '') as hyperliquid_wallet_addr,
COALESCE(e.aster_user, '') as aster_user,
@@ -882,8 +1020,13 @@ func (d *Database) GetTraderConfig(userID, traderID string) (*TraderRecord, *AIM
`, traderID, userID).Scan(
&trader.ID, &trader.UserID, &trader.Name, &trader.AIModelID, &trader.ExchangeID,
&trader.InitialBalance, &trader.ScanIntervalMinutes, &trader.IsRunning,
&trader.BTCETHLeverage, &trader.AltcoinLeverage, &trader.TradingSymbols,
&trader.UseCoinPool, &trader.UseOITop,
&trader.CustomPrompt, &trader.OverrideBasePrompt, &trader.SystemPromptTemplate,
&trader.IsCrossMargin,
&trader.CreatedAt, &trader.UpdatedAt,
&aiModel.ID, &aiModel.UserID, &aiModel.Name, &aiModel.Provider, &aiModel.Enabled, &aiModel.APIKey,
&aiModel.CustomAPIURL, &aiModel.CustomModelName,
&aiModel.CreatedAt, &aiModel.UpdatedAt,
&exchange.ID, &exchange.UserID, &exchange.Name, &exchange.Type, &exchange.Enabled,
&exchange.APIKey, &exchange.SecretKey, &exchange.Testnet,
@@ -895,6 +1038,12 @@ func (d *Database) GetTraderConfig(userID, traderID string) (*TraderRecord, *AIM
return nil, nil, nil, err
}
// 解密敏感数据
aiModel.APIKey = d.decryptSensitiveData(aiModel.APIKey)
exchange.APIKey = d.decryptSensitiveData(exchange.APIKey)
exchange.SecretKey = d.decryptSensitiveData(exchange.SecretKey)
exchange.AsterPrivateKey = d.decryptSensitiveData(exchange.AsterPrivateKey)
return &trader, &aiModel, &exchange, nil
}
@@ -1019,7 +1168,7 @@ func (d *Database) LoadBetaCodesFromFile(filePath string) error {
log.Printf("插入内测码 %s 失败: %v", code, err)
continue
}
if rowsAffected, _ := result.RowsAffected(); rowsAffected > 0 {
insertedCount++
}
@@ -1082,3 +1231,43 @@ func (d *Database) GetBetaCodeStats() (total, used int, err error) {
return total, used, nil
}
// SetCryptoService 设置加密服务
func (d *Database) SetCryptoService(cs *crypto.CryptoService) {
d.cryptoService = cs
}
// encryptSensitiveData 加密敏感数据用于存储
func (d *Database) encryptSensitiveData(plaintext string) string {
if d.cryptoService == nil || plaintext == "" {
return plaintext
}
encrypted, err := d.cryptoService.EncryptForStorage(plaintext)
if err != nil {
log.Printf("⚠️ 加密失败: %v", err)
return plaintext // 返回明文作为降级处理
}
return encrypted
}
// decryptSensitiveData 解密敏感数据
func (d *Database) decryptSensitiveData(encrypted string) string {
if d.cryptoService == nil || encrypted == "" {
return encrypted
}
// 如果不是加密格式，直接返回
if !d.cryptoService.IsEncryptedStorageValue(encrypted) {
return encrypted
}
decrypted, err := d.cryptoService.DecryptFromStorage(encrypted)
if err != nil {
log.Printf("⚠️ 解密失败: %v", err)
return encrypted // 返回加密文本作为降级处理
}
return decrypted
}
config/database_test.go
+799
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)
}
}
config/test_rsa_key.pem.pub
+9
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-----
crypto/crypto.go
+394
View File
@@ -0,0 +1,394 @@
package crypto
import (
"crypto/aes"
"crypto/cipher"
"crypto/rand"
"crypto/rsa"
"crypto/sha256"
"crypto/x509"
"encoding/base64"
"encoding/hex"
"encoding/json"
"encoding/pem"
"errors"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"strings"
"time"
)
const (
storagePrefix = "ENC:v1:"
storageDelimiter = ":"
dataKeyEnvName = "DATA_ENCRYPTION_KEY"
)
type EncryptedPayload struct {
WrappedKey string `json:"wrappedKey"`
IV string `json:"iv"`
Ciphertext string `json:"ciphertext"`
AAD string `json:"aad,omitempty"`
KID string `json:"kid,omitempty"`
TS int64 `json:"ts,omitempty"`
}
type AADData struct {
UserID string `json:"userId"`
SessionID string `json:"sessionId"`
TS int64 `json:"ts"`
Purpose string `json:"purpose"`
}
type CryptoService struct {
privateKey *rsa.PrivateKey
publicKey *rsa.PublicKey
dataKey []byte
}
func NewCryptoService(privateKeyPath string) (*CryptoService, error) {
// 读取私钥文件
privateKeyPEM, err := ioutil.ReadFile(privateKeyPath)
if err != nil {
// 如果私钥文件不存在，生成新的密钥对
if err := GenerateRSAKeyPair(privateKeyPath); err != nil {
return nil, fmt.Errorf("failed to generate RSA key pair: %w", err)
}
privateKeyPEM, err = ioutil.ReadFile(privateKeyPath)
if err != nil {
return nil, fmt.Errorf("failed to read generated private key: %w", err)
}
}
// 解析私钥
privateKey, err := ParseRSAPrivateKeyFromPEM(privateKeyPEM)
if err != nil {
return nil, fmt.Errorf("failed to parse private key: %w", err)
}
dataKey, err := loadDataKeyFromEnv()
if err != nil {
return nil, fmt.Errorf("failed to load data encryption key: %w", err)
}
return &CryptoService{
privateKey: privateKey,
publicKey: &privateKey.PublicKey,
dataKey: dataKey,
}, nil
}
func GenerateRSAKeyPair(privateKeyPath string) error {
// 确保目录存在
dir := filepath.Dir(privateKeyPath)
if dir != "." {
if err := os.MkdirAll(dir, 0700); err != nil {
return fmt.Errorf("failed to create directory %s: %w", dir, err)
}
}
// 生成 RSA 密钥对
privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
if err != nil {
return err
}
// 编码私钥
privateKeyPEM := pem.EncodeToMemory(&pem.Block{
Type: "RSA PRIVATE KEY",
Bytes: x509.MarshalPKCS1PrivateKey(privateKey),
})
// 保存私钥
if err := ioutil.WriteFile(privateKeyPath, privateKeyPEM, 0600); err != nil {
return err
}
// 编码公钥
publicKeyDER, err := x509.MarshalPKIXPublicKey(&privateKey.PublicKey)
if err != nil {
return err
}
publicKeyPEM := pem.EncodeToMemory(&pem.Block{
Type: "PUBLIC KEY",
Bytes: publicKeyDER,
})
// 保存公钥
publicKeyPath := privateKeyPath + ".pub"
if err := ioutil.WriteFile(publicKeyPath, publicKeyPEM, 0644); err != nil {
return err
}
return nil
}
func ParseRSAPrivateKeyFromPEM(pemBytes []byte) (*rsa.PrivateKey, error) {
block, _ := pem.Decode(pemBytes)
if block == nil {
return nil, errors.New("no PEM block found")
}
switch block.Type {
case "RSA PRIVATE KEY":
return x509.ParsePKCS1PrivateKey(block.Bytes)
case "PRIVATE KEY":
key, err := x509.ParsePKCS8PrivateKey(block.Bytes)
if err != nil {
return nil, err
}
rsaKey, ok := key.(*rsa.PrivateKey)
if !ok {
return nil, errors.New("not an RSA key")
}
return rsaKey, nil
default:
return nil, errors.New("unsupported key type: " + block.Type)
}
}
func loadDataKeyFromEnv() ([]byte, error) {
keyStr := strings.TrimSpace(os.Getenv(dataKeyEnvName))
if keyStr == "" {
return nil, fmt.Errorf("%s not set", dataKeyEnvName)
}
if key, ok := decodePossibleKey(keyStr); ok {
return key, nil
}
sum := sha256.Sum256([]byte(keyStr))
key := make([]byte, len(sum))
copy(key, sum[:])
return key, nil
}
func decodePossibleKey(value string) ([]byte, bool) {
decoders := []func(string) ([]byte, error){
base64.StdEncoding.DecodeString,
base64.RawStdEncoding.DecodeString,
func(s string) ([]byte, error) { return hex.DecodeString(s) },
}
for _, decoder := range decoders {
if decoded, err := decoder(value); err == nil {
if key, ok := normalizeAESKey(decoded); ok {
return key, true
}
}
}
return nil, false
}
func normalizeAESKey(raw []byte) ([]byte, bool) {
switch len(raw) {
case 16, 24, 32:
return raw, true
case 0:
return nil, false
default:
sum := sha256.Sum256(raw)
key := make([]byte, len(sum))
copy(key, sum[:])
return key, true
}
}
func (cs *CryptoService) HasDataKey() bool {
return len(cs.dataKey) > 0
}
func (cs *CryptoService) GetPublicKeyPEM() string {
publicKeyDER, err := x509.MarshalPKIXPublicKey(cs.publicKey)
if err != nil {
return ""
}
publicKeyPEM := pem.EncodeToMemory(&pem.Block{
Type: "PUBLIC KEY",
Bytes: publicKeyDER,
})
return string(publicKeyPEM)
}
func (cs *CryptoService) EncryptForStorage(plaintext string, aadParts ...string) (string, error) {
if plaintext == "" {
return "", nil
}
if !cs.HasDataKey() {
return "", errors.New("data encryption key not configured")
}
if isEncryptedStorageValue(plaintext) {
return plaintext, nil
}
block, err := aes.NewCipher(cs.dataKey)
if err != nil {
return "", err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return "", err
}
nonce := make([]byte, gcm.NonceSize())
if _, err := rand.Read(nonce); err != nil {
return "", err
}
aad := composeAAD(aadParts)
ciphertext := gcm.Seal(nil, nonce, []byte(plaintext), aad)
return storagePrefix +
base64.StdEncoding.EncodeToString(nonce) + storageDelimiter +
base64.StdEncoding.EncodeToString(ciphertext), nil
}
func (cs *CryptoService) DecryptFromStorage(value string, aadParts ...string) (string, error) {
if value == "" {
return "", nil
}
if !cs.HasDataKey() {
return "", errors.New("data encryption key not configured")
}
if !isEncryptedStorageValue(value) {
return "", errors.New("value is not encrypted")
}
payload := strings.TrimPrefix(value, storagePrefix)
parts := strings.SplitN(payload, storageDelimiter, 2)
if len(parts) != 2 {
return "", errors.New("invalid encrypted payload format")
}
nonce, err := base64.StdEncoding.DecodeString(parts[0])
if err != nil {
return "", fmt.Errorf("decode nonce failed: %w", err)
}
ciphertext, err := base64.StdEncoding.DecodeString(parts[1])
if err != nil {
return "", fmt.Errorf("decode ciphertext failed: %w", err)
}
block, err := aes.NewCipher(cs.dataKey)
if err != nil {
return "", err
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return "", err
}
if len(nonce) != gcm.NonceSize() {
return "", fmt.Errorf("invalid nonce size: expected %d, got %d", gcm.NonceSize(), len(nonce))
}
aad := composeAAD(aadParts)
plaintext, err := gcm.Open(nil, nonce, ciphertext, aad)
if err != nil {
return "", fmt.Errorf("decryption failed: %w", err)
}
return string(plaintext), nil
}
func (cs *CryptoService) IsEncryptedStorageValue(value string) bool {
return isEncryptedStorageValue(value)
}
func composeAAD(parts []string) []byte {
if len(parts) == 0 {
return nil
}
return []byte(strings.Join(parts, "|"))
}
func isEncryptedStorageValue(value string) bool {
return strings.HasPrefix(value, storagePrefix)
}
func (cs *CryptoService) DecryptPayload(payload *EncryptedPayload) ([]byte, error) {
// 1. 验证时间戳（防止重放攻击）
if payload.TS != 0 {
elapsed := time.Since(time.Unix(payload.TS, 0))
if elapsed > 5*time.Minute || elapsed < -1*time.Minute {
return nil, errors.New("timestamp invalid or expired")
}
}
// 2. 解码 base64url
wrappedKey, err := base64.RawURLEncoding.DecodeString(payload.WrappedKey)
if err != nil {
return nil, fmt.Errorf("failed to decode wrapped key: %w", err)
}
iv, err := base64.RawURLEncoding.DecodeString(payload.IV)
if err != nil {
return nil, fmt.Errorf("failed to decode IV: %w", err)
}
ciphertext, err := base64.RawURLEncoding.DecodeString(payload.Ciphertext)
if err != nil {
return nil, fmt.Errorf("failed to decode ciphertext: %w", err)
}
var aad []byte
if payload.AAD != "" {
aad, err = base64.RawURLEncoding.DecodeString(payload.AAD)
if err != nil {
return nil, fmt.Errorf("failed to decode AAD: %w", err)
}
// 验证 AAD
var aadData AADData
if err := json.Unmarshal(aad, &aadData); err == nil {
// 可以在这里添加额外的验证逻辑
// 例如：验证 sessionID、userID 等
}
}
// 3. 使用 RSA-OAEP 解密 AES 密钥
aesKey, err := rsa.DecryptOAEP(sha256.New(), rand.Reader, cs.privateKey, wrappedKey, nil)
if err != nil {
return nil, fmt.Errorf("failed to unwrap AES key: %w", err)
}
// 4. 使用 AES-GCM 解密数据
block, err := aes.NewCipher(aesKey)
if err != nil {
return nil, fmt.Errorf("failed to create AES cipher: %w", err)
}
gcm, err := cipher.NewGCM(block)
if err != nil {
return nil, fmt.Errorf("failed to create GCM: %w", err)
}
if len(iv) != gcm.NonceSize() {
return nil, fmt.Errorf("invalid IV size: expected %d, got %d", gcm.NonceSize(), len(iv))
}
// 解密并验证认证标签
plaintext, err := gcm.Open(nil, iv, ciphertext, aad)
if err != nil {
return nil, fmt.Errorf("authentication/decryption failed: %w", err)
}
return plaintext, nil
}
func (cs *CryptoService) DecryptSensitiveData(payload *EncryptedPayload) (string, error) {
plaintext, err := cs.DecryptPayload(payload)
if err != nil {
return "", err
}
return string(plaintext), nil
}
crypto/encryption.go
+373
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
}
crypto/encryption_test.go
+159
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
}
crypto/secure_storage.go
+302
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
}
decision/engine.go
+302 -51
View File
@@ -4,13 +4,30 @@ import (
"encoding/json"
"fmt"
"log"
"math"
"nofx/market"
"nofx/mcp"
"nofx/pool"
"regexp"
"strings"
"time"
)
// 预编译正则表达式（性能优化：避免每次调用时重新编译）
var (
// ✅ 安全的正則：精確匹配 ```json 代碼塊
// 使用反引號 + 拼接避免轉義問題
reJSONFence = regexp.MustCompile(`(?is)` + "```json\\s*(\\[\\s*\\{.*?\\}\\s*\\])\\s*```")
reJSONArray = regexp.MustCompile(`(?is)\[\s*\{.*?\}\s*\]`)
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 持仓信息
type PositionInfo struct {
Symbol string `json:"symbol"`
@@ -21,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"` // 持仓更新时间戳（毫秒）
@@ -70,15 +88,24 @@ type Context struct {
// Decision AI的交易决策
type Decision struct {
Symbol string `json:"symbol"`
Action string `json:"action"` // "open_long", "open_short", "close_long", "close_short", "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"`
PositionSizeUSD float64 `json:"position_size_usd,omitempty"`
StopLoss float64 `json:"stop_loss,omitempty"`
TakeProfit float64 `json:"take_profit,omitempty"`
Confidence int `json:"confidence,omitempty"` // 信心度 (0-100)
RiskUSD float64 `json:"risk_usd,omitempty"` // 最大美元风险
Reasoning string `json:"reasoning"`
// 调整参数（新增）
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"`
}
// FullDecision AI的完整决策（包含思维链）
@@ -88,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的完整交易决策（批量分析所有币种和持仓）
@@ -107,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)
}
@@ -160,17 +200,20 @@ func fetchMarketDataForContext(ctx *Context) error {
continue
}
// ⚠️ 流动性过滤：持仓价值低于15M USD的币种不做（多空都不做）
// ⚠️ 流动性过滤：持仓价值低于阈值的币种不做（多空都不做）
// 持仓价值 = 持仓量 × 当前价格
// 但现有持仓必须保留（需要决策是否平仓）
// 💡 OI 門檻配置：用戶可根據風險偏好調整
const minOIThresholdMillions = 15.0 // 可調整：15M(保守) / 10M(平衡) / 8M(寬鬆) / 5M(激進)
isExistingPosition := positionSymbols[symbol]
if !isExistingPosition && data.OpenInterest != nil && data.CurrentPrice > 0 {
// 计算持仓价值（USD）= 持仓量 × 当前价格
oiValue := data.OpenInterest.Latest * data.CurrentPrice
oiValueInMillions := oiValue / 1_000_000 // 转换为百万美元单位
if oiValueInMillions < 15 {
log.Printf("⚠️ %s 持仓价值过低(%.2fM USD < 15M)，跳过此币种 [持仓量:%.0f × 价格:%.4f]",
symbol, oiValueInMillions, data.OpenInterest.Latest, data.CurrentPrice)
if oiValueInMillions < minOIThresholdMillions {
log.Printf("⚠️ %s 持仓价值过低(%.2fM USD < %.1fM)，跳过此币种 [持仓量:%.0f × 价格:%.4f]",
symbol, oiValueInMillions, minOIThresholdMillions, data.OpenInterest.Latest, data.CurrentPrice)
continue
}
}
@@ -200,10 +243,31 @@ func fetchMarketDataForContext(ctx *Context) error {
// calculateMaxCandidates 根据账户状态计算需要分析的候选币种数量
func calculateMaxCandidates(ctx *Context) int {
// 直接返回候选池的全部币种数量
// 因为候选池已经在 auto_trader.go 中筛选过了
// 固定分析前20个评分最高的币种（来自AI500）
return len(ctx.CandidateCoins)
// ⚠️ 重要：限制候选币种数量，避免 Prompt 过大
// 根据持仓数量动态调整：持仓越少，可以分析更多候选币
const (
maxCandidatesWhenEmpty = 30 // 无持仓时最多分析30个候选币
maxCandidatesWhenHolding1 = 25 // 持仓1个时最多分析25个候选币
maxCandidatesWhenHolding2 = 20 // 持仓2个时最多分析20个候选币
maxCandidatesWhenHolding3 = 15 // 持仓3个时最多分析15个候选币（避免 Prompt 过大）
)
positionCount := len(ctx.Positions)
var maxCandidates int
switch positionCount {
case 0:
maxCandidates = maxCandidatesWhenEmpty
case 1:
maxCandidates = maxCandidatesWhenHolding1
case 2:
maxCandidates = maxCandidatesWhenHolding2
default: // 3+ 持仓
maxCandidates = maxCandidatesWhenHolding3
}
// 返回实际候选币数量和上限中的较小值
return min(len(ctx.CandidateCoins), maxCandidates)
}
// buildSystemPromptWithCustom 构建包含自定义内容的 System Prompt
@@ -264,20 +328,27 @@ func buildSystemPrompt(accountEquity float64, btcEthLeverage, altcoinLeverage in
sb.WriteString("# 硬约束（风险控制）\n\n")
sb.WriteString("1. 风险回报比: 必须 ≥ 1:3（冒1%风险，赚3%+收益）\n")
sb.WriteString("2. 最多持仓: 3个币种（质量>数量）\n")
sb.WriteString(fmt.Sprintf("3. 单币仓位: 山寨%.0f-%.0f U(%dx杠杆) | BTC/ETH %.0f-%.0f U(%dx杠杆)\n",
accountEquity*0.8, accountEquity*1.5, altcoinLeverage, accountEquity*5, accountEquity*10, btcEthLeverage))
sb.WriteString("4. 保证金: 总使用率 ≤ 90%\n\n")
sb.WriteString(fmt.Sprintf("3. 单币仓位: 山寨%.0f-%.0f U | BTC/ETH %.0f-%.0f U\n",
accountEquity*0.8, accountEquity*1.5, accountEquity*5, accountEquity*10))
sb.WriteString(fmt.Sprintf("4. 杠杆限制: **山寨币最大%dx杠杆** | **BTC/ETH最大%dx杠杆** (⚠️ 严格执行，不可超过)\n", altcoinLeverage, btcEthLeverage))
sb.WriteString("5. 保证金: 总使用率 ≤ 90%\n")
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")
@@ -327,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输出完整市场数据
@@ -416,39 +490,99 @@ 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)
}
// extractDecisions 提取JSON决策列表
func extractDecisions(response string) ([]Decision, error) {
// 直接查找JSON数组 - 找第一个完整的JSON数组
arrayStart := strings.Index(response, "[")
if arrayStart == -1 {
return nil, fmt.Errorf("无法找到JSON数组起始")
// 预清洗：去零宽/BOM
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")
}
// 从 [ 开始，匹配括号找到对应的 ]
arrayEnd := findMatchingBracket(response, arrayStart)
if arrayEnd == -1 {
return nil, fmt.Errorf("无法找到JSON数组结束")
// 修复 jsonPart 中的全角字符
jsonPart = fixMissingQuotes(jsonPart)
// 1) 优先从 ```json 代码块中提取
if m := reJSONFence.FindStringSubmatch(jsonPart); m != nil && len(m) > 1 {
jsonContent := strings.TrimSpace(m[1])
jsonContent = compactArrayOpen(jsonContent) // 把 "[ {" 规整为 "[{"
jsonContent = fixMissingQuotes(jsonContent) // 二次修复（防止 regex 提取后还有残留全角）
if err := validateJSONFormat(jsonContent); err != nil {
return nil, fmt.Errorf("JSON格式验证失败: %w\nJSON内容: %s\n完整响应:\n%s", err, jsonContent, response)
}
var decisions []Decision
if err := json.Unmarshal([]byte(jsonContent), &decisions); err != nil {
return nil, fmt.Errorf("JSON解析失败: %w\nJSON内容: %s", err, jsonContent)
}
return decisions, nil
}
jsonContent := strings.TrimSpace(response[arrayStart : arrayEnd+1])
// 2) 退而求其次 (Fallback)：全文寻找首个对象数组
// 注意：此时 jsonPart 已经过 fixMissingQuotes()，全角字符已转换为半角
jsonContent := strings.TrimSpace(reJSONArray.FindString(jsonPart))
if jsonContent == "" {
// 🔧 安全回退 (Safe Fallback)：当AI只输出思维链没有JSON时，生成保底决策（避免系统崩溃）
log.Printf("⚠️ [SafeFallback] AI未输出JSON决策，进入安全等待模式 (AI response without JSON, entering safe wait mode)")
// 🔧 修复常见的JSON格式错误：缺少引号的字段值
// 匹配: "reasoning": 内容"} 或 "reasoning": 内容} (没有引号)
// 修复为: "reasoning": "内容"}
// 使用简单的字符串扫描而不是正则表达式
jsonContent = fixMissingQuotes(jsonContent)
// 提取思维链摘要（最多 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 提取后还有残留全角）
// 🔧 验证 JSON 格式（检测常见错误）
if err := validateJSONFormat(jsonContent); err != nil {
return nil, fmt.Errorf("JSON格式验证失败: %w\nJSON内容: %s\n完整响应:\n%s", err, jsonContent, response)
}
// 解析JSON
var decisions []Decision
@@ -459,15 +593,86 @@ func extractDecisions(response string) ([]Decision, error) {
return decisions, nil
}
// fixMissingQuotes 替换中文引号为英文引号（避免输入法自动转换）
// fixMissingQuotes 替换中文引号和全角字符为英文引号和半角字符（避免AI输出全角JSON字符导致解析失败）
func fixMissingQuotes(jsonStr string) string {
// 替换中文引号
jsonStr = strings.ReplaceAll(jsonStr, "\u201c", "\"") // "
jsonStr = strings.ReplaceAll(jsonStr, "\u201d", "\"") // "
jsonStr = strings.ReplaceAll(jsonStr, "\u2018", "'") // '
jsonStr = strings.ReplaceAll(jsonStr, "\u2019", "'") // '
// ⚠️ 替换全角括号、冒号、逗号（防止AI输出全角JSON字符）
jsonStr = strings.ReplaceAll(jsonStr, "［", "[") // U+FF3B 全角左方括号
jsonStr = strings.ReplaceAll(jsonStr, "］", "]") // U+FF3D 全角右方括号
jsonStr = strings.ReplaceAll(jsonStr, "｛", "{") // U+FF5B 全角左花括号
jsonStr = strings.ReplaceAll(jsonStr, "｝", "}") // U+FF5D 全角右花括号
jsonStr = strings.ReplaceAll(jsonStr, "：", ":") // U+FF1A 全角冒号
jsonStr = strings.ReplaceAll(jsonStr, "，", ",") // U+FF0C 全角逗号
// ⚠️ 替换CJK标点符号（AI在中文上下文中也可能输出这些）
jsonStr = strings.ReplaceAll(jsonStr, "【", "[") // CJK左方头括号 U+3010
jsonStr = strings.ReplaceAll(jsonStr, "】", "]") // CJK右方头括号 U+3011
jsonStr = strings.ReplaceAll(jsonStr, "〔", "[") // CJK左龟壳括号 U+3014
jsonStr = strings.ReplaceAll(jsonStr, "〕", "]") // CJK右龟壳括号 U+3015
jsonStr = strings.ReplaceAll(jsonStr, "、", ",") // CJK顿号 U+3001
// ⚠️ 替换全角空格为半角空格（JSON中不应该有全角空格）
jsonStr = strings.ReplaceAll(jsonStr, "　", " ") // U+3000 全角空格
return jsonStr
}
// validateJSONFormat 验证 JSON 格式，检测常见错误
func validateJSONFormat(jsonStr string) error {
trimmed := strings.TrimSpace(jsonStr)
// 允许 [ 和 { 之间存在任意空白（含零宽）
if !reArrayHead.MatchString(trimmed) {
// 检查是否是纯数字/范围数组（常见错误）
if strings.HasPrefix(trimmed, "[") && !strings.Contains(trimmed[:min(20, len(trimmed))], "{") {
return fmt.Errorf("不是有效的决策数组（必须包含对象 {}），实际内容: %s", trimmed[:min(50, len(trimmed))])
}
return fmt.Errorf("JSON 必须以 [{ 开头（允许空白），实际: %s", trimmed[:min(20, len(trimmed))])
}
// 检查是否包含范围符号 ~（LLM 常见错误）
if strings.Contains(jsonStr, "~") {
return fmt.Errorf("JSON 中不可包含范围符号 ~，所有数字必须是精确的单一值")
}
// 检查是否包含千位分隔符（如 98,000）
// 使用简单的模式匹配：数字+逗号+3位数字
for i := 0; i < len(jsonStr)-4; i++ {
if jsonStr[i] >= '0' && jsonStr[i] <= '9' &&
jsonStr[i+1] == ',' &&
jsonStr[i+2] >= '0' && jsonStr[i+2] <= '9' &&
jsonStr[i+3] >= '0' && jsonStr[i+3] <= '9' &&
jsonStr[i+4] >= '0' && jsonStr[i+4] <= '9' {
return fmt.Errorf("JSON 数字不可包含千位分隔符逗号，发现: %s", jsonStr[i:min(i+10, len(jsonStr))])
}
}
return nil
}
// min 返回两个整数中的较小值
func min(a, b int) int {
if a < b {
return a
}
return b
}
// removeInvisibleRunes 去除零宽字符和 BOM，避免肉眼看不见的前缀破坏校验
func removeInvisibleRunes(s string) string {
return reInvisibleRunes.ReplaceAllString(s, "")
}
// compactArrayOpen 规整开头的 "[ {" → "[{"
func compactArrayOpen(s string) string {
return reArrayOpenSpace.ReplaceAllString(strings.TrimSpace(s), "[{")
}
// validateDecisions 验证所有决策（需要账户信息和杠杆配置）
func validateDecisions(decisions []Decision, accountEquity float64, btcEthLeverage, altcoinLeverage int) error {
for i, decision := range decisions {
@@ -504,12 +709,15 @@ func findMatchingBracket(s string, start int) int {
func validateDecision(d *Decision, accountEquity float64, btcEthLeverage, altcoinLeverage int) error {
// 验证action
validActions := map[string]bool{
"open_long": true,
"open_short": true,
"close_long": true,
"close_short": true,
"hold": true,
"wait": true,
"open_long": true,
"open_short": true,
"close_long": true,
"close_short": true,
"update_stop_loss": true,
"update_take_profit": true,
"partial_close": true,
"hold": true,
"wait": true,
}
if !validActions[d.Action] {
@@ -526,12 +734,34 @@ 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)
}
// ✅ 验证最小开仓金额（防止数量格式化为 0 的错误）
// Binance 最小名义价值 10 USDT + 安全边际
const minPositionSizeGeneral = 12.0 // 10 + 20% 安全边际
const minPositionSizeBTCETH = 60.0 // BTC/ETH 因价格高和精度限制需要更大金额（更灵活）
if d.Symbol == "BTCUSDT" || d.Symbol == "ETHUSDT" {
if d.PositionSizeUSD < minPositionSizeBTCETH {
return fmt.Errorf("%s 开仓金额过小(%.2f USDT)，必须≥%.2f USDT（因价格高且精度限制，避免数量四舍五入为0）", d.Symbol, d.PositionSizeUSD, minPositionSizeBTCETH)
}
} else {
if d.PositionSizeUSD < minPositionSizeGeneral {
return fmt.Errorf("开仓金额过小(%.2f USDT)，必须≥%.2f USDT（Binance 最小名义价值要求）", d.PositionSizeUSD, minPositionSizeGeneral)
}
}
// 验证仓位价值上限（加1%容差以避免浮点数精度问题）
tolerance := maxPositionValue * 0.01 // 1%容差
if d.PositionSizeUSD > maxPositionValue+tolerance {
@@ -589,5 +819,26 @@ func validateDecision(d *Decision, accountEquity float64, btcEthLeverage, altcoi
}
}
// 动态调整止损验证
if d.Action == "update_stop_loss" {
if d.NewStopLoss <= 0 {
return fmt.Errorf("新止损价格必须大于0: %.2f", d.NewStopLoss)
}
}
// 动态调整止盈验证
if d.Action == "update_take_profit" {
if d.NewTakeProfit <= 0 {
return fmt.Errorf("新止盈价格必须大于0: %.2f", d.NewTakeProfit)
}
}
// 部分平仓验证
if d.Action == "partial_close" {
if d.ClosePercentage <= 0 || d.ClosePercentage > 100 {
return fmt.Errorf("平仓百分比必须在0-100之间: %.1f", d.ClosePercentage)
}
}
return nil
}
decision/prompt_manager_test.go
+285
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)
}
}
decision/prompt_reload_integration_test.go
+243
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 同时读取和重新加载模板，无数据竞争")
}
decision/validate_test.go
+100
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)
}
})
}
}
deploy_encryption.sh
Executable
+286
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
docker-compose.yml
+6 -1
View File
@@ -6,6 +6,7 @@ services:
dockerfile: ./docker/Dockerfile.backend
container_name: nofx-trading
restart: unless-stopped
stop_grace_period: 30s # 允许应用有 30 秒时间优雅关闭
ports:
- "${NOFX_BACKEND_PORT:-8080}:8080"
volumes:
@@ -14,9 +15,13 @@ services:
- ./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} # 数据库加密密钥
- JWT_SECRET=${JWT_SECRET} # JWT认证密钥
networks:
- nofx-network
healthcheck:
@@ -40,7 +45,7 @@ services:
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
docs/MIGRATION_GUIDE.md
-3
View File
@@ -9,7 +9,6 @@ NOFX documentation has been reorganized into a structured `docs/` directory for
### Deployment Guides
- `DOCKER_DEPLOY.en.md` → `docs/getting-started/docker-deploy.en.md`
- `DOCKER_DEPLOY.md` → `docs/getting-started/docker-deploy.zh-CN.md`
- `PM2_DEPLOYMENT.md` → `docs/getting-started/pm2-deploy.md`
- `CUSTOM_API.md` → `docs/getting-started/custom-api.md`
### Community Docs
@@ -42,7 +41,6 @@ nofx/
├── README.uk.md
├── DOCKER_DEPLOY.md
├── DOCKER_DEPLOY.en.md
├── PM2_DEPLOYMENT.md
├── CUSTOM_API.md
├── HOW_TO_POST_BOUNTY.md
├── INTEGRATION_BOUNTY_HYPERLIQUID.md
@@ -101,7 +99,6 @@ Files GitHub needs to see:
1. **`getting-started/`** - Deployment and setup
- Docker deployment (EN/中文)
- PM2 deployment
- Custom API configuration
2. **`guides/`** - Usage guides and tutorials
docs/README.md
-3
View File
@@ -17,15 +17,12 @@ Welcome to the NOFX documentation! This page helps you find the right documentat
| [Getting Started Index (中文)](getting-started/README.zh-CN.md) | 所有部署选项 | All deployment options |
| [Docker Deployment (EN)](getting-started/docker-deploy.en.md) | Deploy with Docker (recommended) | Docker 部署（推荐） |
| [Docker Deployment (中文)](getting-started/docker-deploy.zh-CN.md) | Docker 部署指南（中文） | Docker deployment guide |
| [PM2 Deployment (EN)](getting-started/pm2-deploy.en.md) | Deploy with PM2 process manager | PM2 进程管理器部署 |
| [PM2 Deployment (中文)](getting-started/pm2-deploy.md) | PM2 部署指南（中文） | PM2 deployment guide |
| [Custom API (EN)](getting-started/custom-api.en.md) | Connect custom AI API providers | 连接自定义 AI API |
| [Custom API (中文)](getting-started/custom-api.md) | 连接自定义 AI API 提供商 | Custom AI provider guide |
**Quick Links:**
- 📖 See all options → [Getting Started](getting-started/README.md) / [快速开始](getting-started/README.zh-CN.md)
- 🐳 Want easiest setup? → [Docker (EN)](getting-started/docker-deploy.en.md) / [Docker (中文)](getting-started/docker-deploy.zh-CN.md)
- 🔧 Advanced user? → [PM2 (EN)](getting-started/pm2-deploy.en.md) / [PM2 (中文)](getting-started/pm2-deploy.md)
- 🤖 Custom AI model? → [Custom API (EN)](getting-started/custom-api.en.md) / [自定义 API](getting-started/custom-api.md)
---
docs/architecture/README.md
+1 -1
View File
@@ -93,7 +93,7 @@ nofx/
| `github.com/gin-gonic/gin` | HTTP API framework | v1.9+ |
| `github.com/adshao/go-binance/v2` | Binance API client | v2.4+ |
| `github.com/markcheno/go-talib` | Technical indicators (TA-Lib) | Latest |
| `github.com/mattn/go-sqlite3` | SQLite database driver | v1.14+ |
| `github.com/lib/pq` | PostgreSQL database driver | v1.10+ |
| `github.com/golang-jwt/jwt/v5` | JWT authentication | v5.0+ |
| `github.com/pquerna/otp` | 2FA/TOTP support | v1.4+ |
| `golang.org/x/crypto` | Password hashing (bcrypt) | Latest |
docs/architecture/README.zh-CN.md
+1 -2
View File
@@ -93,7 +93,7 @@ nofx/
| `github.com/gin-gonic/gin` | HTTP API 框架 | v1.9+ |
| `github.com/adshao/go-binance/v2` | Binance API 客户端 | v2.4+ |
| `github.com/markcheno/go-talib` | 技术指标（TA-Lib） | 最新 |
| `github.com/mattn/go-sqlite3` | SQLite 数据库驱动 | v1.14+ |
| `github.com/lib/pq` | PostgreSQL 数据库驱动 | v1.10+ |
| `github.com/golang-jwt/jwt/v5` | JWT 认证 | v5.0+ |
| `github.com/pquerna/otp` | 2FA/TOTP 支持 | v1.4+ |
| `golang.org/x/crypto` | 密码哈希（bcrypt） | 最新 |
@@ -282,7 +282,6 @@ GET /api/decisions/latest # 最近决策
- 基于 JWT token 的认证
- 使用 TOTP 的 2FA（Google Authenticator）
- Bcrypt 密码哈希
- 管理员模式（简化的单用户模式）
---
docs/community/bounty-guide.md
+1 -1
View File
@@ -197,7 +197,7 @@ Details: [详情链接]
### 法律 & 合规
- ✅ 明确说明这是开源贡献，不是雇佣关系
- ✅ 确保贡献者同意 MIT License
- ✅ 确保贡献者同意 AGPL-3.0 License
- ✅ 保留最终合并决定权
### 资金管理
docs/getting-started/README.md
+19 -24
View File
@@ -23,33 +23,12 @@ Choose the method that best fits your needs:
**Quick Start:**
```bash
cp config.example.jsonc config.json
./start.sh start --build
cp config.json.example config.json
./scripts/start.sh start --build
```
---
### 🔧 PM2 Deployment
**Best for:** Advanced users, development, custom setups
- **English:** [pm2-deploy.en.md](pm2-deploy.en.md)
- **中文:** [pm2-deploy.md](pm2-deploy.md)
**Pros:**
- ✅ Direct process control
- ✅ Better for development
- ✅ Lower resource usage
- ✅ More flexible
**Quick Start:**
```bash
go build -o nofx
cd web && npm install && npm run build
pm2 start ecosystem.config.js
```
---
## 🤖 AI Configuration
@@ -77,7 +56,6 @@ Before starting, ensure you have:
- ✅ Go 1.21+
- ✅ Node.js 18+
- ✅ TA-Lib library
- ✅ PM2 (optional)
---
@@ -90,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
docs/getting-started/README.zh-CN.md
+2 -24
View File
@@ -21,33 +21,12 @@
**快速开始：**
```bash
cp config.example.jsonc config.json
./start.sh start --build
cp config.json.example config.json
./scripts/start.sh start --build
```
---
### 🔧 PM2 部署
**适合：** 进阶用户、开发环境、自定义设置
- **中文文档：** [pm2-deploy.md](pm2-deploy.md)
- **English:** [pm2-deploy.en.md](pm2-deploy.en.md)
**优势：**
- ✅ 直接进程控制
- ✅ 更适合开发
- ✅ 资源占用更低
- ✅ 更灵活
**快速开始：**
```bash
go build -o nofx
cd web && npm install && npm run build
pm2 start ecosystem.config.js
```
---
## 🤖 AI 配置
@@ -75,7 +54,6 @@ pm2 start ecosystem.config.js
- ✅ Go 1.21+
- ✅ Node.js 18+
- ✅ TA-Lib 库
- ✅ PM2（可选）
---
docs/getting-started/docker-deploy.en.md
+2 -2
View File
@@ -50,7 +50,7 @@ docker compose --version # Docker 24+ includes this, no separate installation n
```bash
# Copy configuration template
cp config.example.jsonc config.json
cp config.json.example config.json
# Edit configuration file with your API keys
nano config.json # or use any other editor
@@ -267,7 +267,7 @@ kill -9 <PID>
# ~~ls -la config.json~~
# ~~If not exists, copy template~~
# ~~cp config.example.jsonc config.json~~
# ~~cp config.json.example config.json~~
*Note: Now using SQLite database for configuration storage, no longer need config.json*
```
docs/getting-started/docker-deploy.zh-CN.md
+2 -2
View File
@@ -55,7 +55,7 @@ docker compose --version # Docker 24+ 自带，无需单独安装
```bash
# 复制配置文件模板
cp config.example.jsonc config.json
cp config.json.example config.json
# 编辑配置文件，填入你的 API 密钥
nano config.json # 或使用其他编辑器
@@ -270,7 +270,7 @@ kill -9 <PID>
ls -la config.json
# 如果不存在，复制模板
cp config.example.jsonc config.json
cp config.json.example config.json
```
### 健康检查失败
docs/getting-started/pm2-deploy.en.md
-303
View File
@@ -1,303 +0,0 @@
# NoFX Trading Bot - PM2 Deployment Guide
Complete guide for local development and production deployment using PM2.
## 🚀 Quick Start
### 1. Install PM2
```bash
npm install -g pm2
```
### 2. One-Command Launch
```bash
./pm2.sh start
```
That's it! Frontend and backend will start automatically.
---
## 📋 All Commands
### Service Management
```bash
# Start services
./pm2.sh start
# Stop services
./pm2.sh stop
# Restart services
./pm2.sh restart
# View status
./pm2.sh status
# Delete services
./pm2.sh delete
```
### Log Viewing
```bash
# View all logs (live)
./pm2.sh logs
# Backend logs only
./pm2.sh logs backend
# Frontend logs only
./pm2.sh logs frontend
```
### Build & Compile
```bash
# Compile backend
./pm2.sh build
# Recompile backend and restart
./pm2.sh rebuild
```
### Monitoring
```bash
# Open PM2 monitoring dashboard (real-time CPU/Memory)
./pm2.sh monitor
```
---
## 📊 Access URLs
After successful startup:
- **Frontend Web Interface**: http://localhost:3000
- **Backend API**: http://localhost:8080
- **Health Check**: http://localhost:8080/api/health
---
## 🔧 Configuration Files
### pm2.config.js
PM2 configuration file, defines frontend and backend startup parameters:
```javascript
const path = require('path');
module.exports = {
apps: [
{
name: 'nofx-backend',
script: './nofx', // Go binary
cwd: __dirname, // Dynamically get current directory
autorestart: true,
max_memory_restart: '500M'
},
{
name: 'nofx-frontend',
script: 'npm',
args: 'run dev', // Vite dev server
cwd: path.join(__dirname, 'web'), // Dynamically join path
autorestart: true,
max_memory_restart: '300M'
}
]
};
```
**After modifying configuration, restart is required:**
```bash
./pm2.sh restart
```
---
## 📝 Log File Locations
- **Backend Logs**: `./logs/backend-error.log` and `./logs/backend-out.log`
- **Frontend Logs**: `./web/logs/frontend-error.log` and `./web/logs/frontend-out.log`
---
## 🔄 Startup on Boot
Set PM2 to start on boot:
```bash
# 1. Start services
./pm2.sh start
# 2. Save current process list
pm2 save
# 3. Generate startup script
pm2 startup
# 4. Follow the instructions to execute command (requires sudo)
```
**Disable startup on boot:**
```bash
pm2 unstartup
```
---
## 🛠️ Common Operations
### Restart After Code Changes
**Backend changes:**
```bash
./pm2.sh rebuild # Auto compile and restart
```
**Frontend changes:**
```bash
./pm2.sh restart # Vite will auto hot-reload, no restart needed
```
### View Real-time Resource Usage
```bash
./pm2.sh monitor
```
### View Detailed Information
```bash
pm2 info nofx-backend # Backend details
pm2 info nofx-frontend # Frontend details
```
### Clear Logs
```bash
pm2 flush
```
---
## 🐛 Troubleshooting
### Service Startup Failed
```bash
# 1. View detailed errors
./pm2.sh logs
# 2. Check port usage
lsof -i :8080 # Backend port
lsof -i :3000 # Frontend port
# 3. Manual compile test
go build -o nofx
./nofx
```
### Backend Won't Start
```bash
# ~~Check if config.json exists~~
# ~~ls -l config.json~~
# Check if database file exists
ls -l trading.db
# Check permissions
chmod +x nofx
# Run manually to see errors
./nofx
```
### Frontend Not Accessible
```bash
# Check node_modules
cd web && npm install
# Manual start test
npm run dev
```
---
## 🎯 Production Environment Recommendations
### 1. Use Production Mode
Modify `pm2.config.js`:
```javascript
{
name: 'nofx-frontend',
script: 'npm',
args: 'run preview', // Change to preview (requires npm run build first)
env: {
NODE_ENV: 'production'
}
}
```
### 2. Increase Instances (Load Balancing)
```javascript
{
name: 'nofx-backend',
script: './nofx',
instances: 2, // Start 2 instances
exec_mode: 'cluster'
}
```
### 3. Auto Restart Strategy
```javascript
{
autorestart: true,
max_restarts: 10,
min_uptime: '10s',
max_memory_restart: '500M'
}
```
---
## 📦 Comparison with Docker Deployment
| Feature | PM2 Deployment | Docker Deployment |
|---------|---------------|-------------------|
| Startup Speed | ⚡ Fast | 🐌 Slower |
| Resource Usage | 💚 Low | 🟡 Medium |
| Isolation | 🟡 Medium | 💚 High |
| Use Case | Dev/Single-machine | Production/Cluster |
| Configuration Complexity | 💚 Simple | 🟡 Medium |
**Recommendations:**
- **Development Environment**: Use `./pm2.sh`
- **Production Environment**: Use `./start.sh` (Docker)
---
## 🆘 Getting Help
```bash
./pm2.sh help
```
Or check PM2 official documentation: https://pm2.keymetrics.io/
---
## 📄 License
MIT
docs/getting-started/pm2-deploy.md
-303
View File
@@ -1,303 +0,0 @@
# NoFX Trading Bot - PM2 部署指南
使用 PM2 进行本地开发和生产部署的完整指南。
## 🚀 快速开始
### 1. 安装 PM2
```bash
npm install -g pm2
```
### 2. 一键启动
```bash
./pm2.sh start
```
就这么简单！前后端将自动启动。
---
## 📋 所有命令
### 服务管理
```bash
# 启动服务
./pm2.sh start
# 停止服务
./pm2.sh stop
# 重启服务
./pm2.sh restart
# 查看状态
./pm2.sh status
# 删除服务
./pm2.sh delete
```
### 日志查看
```bash
# 查看所有日志（实时）
./pm2.sh logs
# 只看后端日志
./pm2.sh logs backend
# 只看前端日志
./pm2.sh logs frontend
```
### 构建与编译
```bash
# 编译后端
./pm2.sh build
# 重新编译后端并重启
./pm2.sh rebuild
```
### 监控
```bash
# 打开 PM2 监控面板（实时CPU/内存）
./pm2.sh monitor
```
---
## 📊 访问地址
启动成功后：
- **前端 Web 界面**: http://localhost:3000
- **后端 API**: http://localhost:8080
- **健康检查**: http://localhost:8080/api/health
---
## 🔧 配置文件
### pm2.config.js
PM2 配置文件，定义了前后端的启动参数：
```javascript
const path = require('path');
module.exports = {
apps: [
{
name: 'nofx-backend',
script: './nofx', // Go 二进制文件
cwd: __dirname, // 动态获取当前目录
autorestart: true,
max_memory_restart: '500M'
},
{
name: 'nofx-frontend',
script: 'npm',
args: 'run dev', // Vite 开发服务器
cwd: path.join(__dirname, 'web'), // 动态拼接路径
autorestart: true,
max_memory_restart: '300M'
}
]
};
```
**修改配置后需要重启：**
```bash
./pm2.sh restart
```
---
## 📝 日志文件位置
- **后端日志**: `./logs/backend-error.log` 和 `./logs/backend-out.log`
- **前端日志**: `./web/logs/frontend-error.log` 和 `./web/logs/frontend-out.log`
---
## 🔄 开机自启动
设置 PM2 开机自启动：
```bash
# 1. 启动服务
./pm2.sh start
# 2. 保存当前进程列表
pm2 save
# 3. 生成启动脚本
pm2 startup
# 4. 按照提示执行命令（需要 sudo）
```
**取消开机自启动：**
```bash
pm2 unstartup
```
---
## 🛠️ 常见操作
### 修改代码后重启
**后端修改：**
```bash
./pm2.sh rebuild # 自动编译并重启
```
**前端修改：**
```bash
./pm2.sh restart # Vite 会自动热重载，无需重启
```
### 查看实时资源占用
```bash
./pm2.sh monitor
```
### 查看详细信息
```bash
pm2 info nofx-backend # 后端详情
pm2 info nofx-frontend # 前端详情
```
### 清空日志
```bash
pm2 flush
```
---
## 🐛 故障排查
### 服务启动失败
```bash
# 1. 查看详细错误
./pm2.sh logs
# 2. 检查端口占用
lsof -i :8080 # 后端端口
lsof -i :3000 # 前端端口
# 3. 手动编译测试
go build -o nofx
./nofx
```
### 后端无法启动
```bash
# ~~检查 config.json 是否存在~~
# ~~ls -l config.json~~
# 检查数据库文件是否存在
ls -l trading.db
# 检查权限
chmod +x nofx
# 手动运行看报错
./nofx
```
### 前端无法访问
```bash
# 检查 node_modules
cd web && npm install
# 手动启动测试
npm run dev
```
---
## 🎯 生产环境建议
### 1. 使用生产模式
修改 `pm2.config.js`：
```javascript
{
name: 'nofx-frontend',
script: 'npm',
args: 'run preview', // 改为 preview（需先 npm run build）
env: {
NODE_ENV: 'production'
}
}
```
### 2. 增加实例数（负载均衡）
```javascript
{
name: 'nofx-backend',
script: './nofx',
instances: 2, // 启动 2 个实例
exec_mode: 'cluster'
}
```
### 3. 自动重启策略
```javascript
{
autorestart: true,
max_restarts: 10,
min_uptime: '10s',
max_memory_restart: '500M'
}
```
---
## 📦 与 Docker 部署的对比
| 特性 | PM2 部署 | Docker 部署 |
|------|---------|------------|
| 启动速度 | ⚡ 快 | 🐌 较慢 |
| 资源占用 | 💚 低 | 🟡 中等 |
| 隔离性 | 🟡 中等 | 💚 高 |
| 适用场景 | 开发/单机 | 生产/集群 |
| 配置复杂度 | 💚 简单 | 🟡 中等 |
**建议：**
- **开发环境**: 使用 `./pm2.sh`
- **生产环境**: 使用 `./start.sh` (Docker)
---
## 🆘 获取帮助
```bash
./pm2.sh help
```
或查看 PM2 官方文档：https://pm2.keymetrics.io/
---
## 📄 License
MIT
docs/guides/TROUBLESHOOTING.md
+24 -25
View File
@@ -403,22 +403,24 @@ docker compose up -d
#### ❌ Trader Configuration Not Saving
**Check:**
1. **Permissions:**
1. **PostgreSQL container health**
```bash
ls -l config.db trading.db
# Should be writable by current user
docker compose ps postgres
docker compose exec postgres pg_isready -U nofx -d nofx
```
2. **Disk Space:**
2. **Inspect data directly**
```bash
./scripts/view_pg_data.sh # quick overview
docker compose exec postgres \
psql -U nofx -d nofx -c "SELECT COUNT(*) FROM traders;"
```
3. **Disk space**
```bash
df -h # Ensure disk not full
```
3. **Database Integrity:**
```bash
sqlite3 config.db "PRAGMA integrity_check;"
```
---
## 📊 How to Capture Logs
@@ -437,15 +439,9 @@ docker compose logs -f backend
docker compose logs backend --tail=500 > backend_logs.txt
```
**Manual/PM2:**
**Manual binary:**
```bash
# Terminal where you ran ./nofx shows logs
# PM2:
pm2 logs nofx --lines 100
# Save to file
pm2 logs nofx --lines 500 > backend_logs.txt
# If running without Docker, the terminal running ./nofx prints logs
```
---
@@ -532,13 +528,16 @@ docker compose restart frontend
```bash
# Check traders in database
sqlite3 config.db "SELECT id, name, ai_model_id, exchange_id, is_running FROM traders;"
docker compose exec postgres \
psql -U nofx -d nofx -c "SELECT id, name, ai_model_id, exchange_id, is_running FROM traders;"
# Check AI models
sqlite3 config.db "SELECT id, name, model_type, enabled FROM ai_models;"
docker compose exec postgres \
psql -U nofx -d nofx -c "SELECT id, name, provider, enabled FROM ai_models;"
# Check system config
sqlite3 config.db "SELECT key, value FROM system_config;"
docker compose exec postgres \
psql -U nofx -d nofx -c "SELECT key, value FROM system_config;"
```
---
@@ -572,12 +571,12 @@ If you've tried all the above and still have problems:
# Stop everything
docker compose down
# Backup databases (just in case)
cp config.db config.db.backup
cp trading.db trading.db.backup
# Optional: back up PostgreSQL data
docker compose exec postgres \
pg_dump -U nofx -d nofx > backup_nofx.sql
# Remove databases (fresh start)
rm config.db trading.db
# Remove all persisted volumes (fresh start)
docker compose down -v
# Restart
docker compose up -d --build
docs/guides/TROUBLESHOOTING.zh-CN.md
+24 -25
View File
@@ -403,22 +403,24 @@ docker compose up -d
#### ❌ 交易员配置无法保存
**检查:**
1. **权限:**
1. **PostgreSQL 容器状态**
```bash
ls -l config.db trading.db
# 应该对当前用户可写
docker compose ps postgres
docker compose exec postgres pg_isready -U nofx -d nofx
```
2. **磁盘空间:**
2. **直接检查数据库数据**
```bash
./scripts/view_pg_data.sh # 快速总览
docker compose exec postgres \
psql -U nofx -d nofx -c "SELECT COUNT(*) FROM traders;"
```
3. **磁盘空间**
```bash
df -h # 确保磁盘未满
```
3. **数据库完整性:**
```bash
sqlite3 config.db "PRAGMA integrity_check;"
```
---
## 📊 如何捕获日志
@@ -437,15 +439,9 @@ docker compose logs -f backend
docker compose logs backend --tail=500 > backend_logs.txt
```
**手动/PM2:**
**手动运行:**
```bash
# 运行 ./nofx 的终端会显示日志
# PM2:
pm2 logs nofx --lines 100
# 保存到文件
pm2 logs nofx --lines 500 > backend_logs.txt
# 如果不是通过 Docker，而是手动运行 ./nofx，可直接在终端查看日志
```
---
@@ -532,13 +528,16 @@ docker compose restart frontend
```bash
# 检查数据库中的交易员
sqlite3 config.db "SELECT id, name, ai_model_id, exchange_id, is_running FROM traders;"
docker compose exec postgres \
psql -U nofx -d nofx -c "SELECT id, name, ai_model_id, exchange_id, is_running FROM traders;"
# 检查 AI 模型
sqlite3 config.db "SELECT id, name, model_type, enabled FROM ai_models;"
docker compose exec postgres \
psql -U nofx -d nofx -c "SELECT id, name, provider, enabled FROM ai_models;"
# 检查系统配置
sqlite3 config.db "SELECT key, value FROM system_config;"
docker compose exec postgres \
psql -U nofx -d nofx -c "SELECT key, value FROM system_config;"
```
---
@@ -572,12 +571,12 @@ sqlite3 config.db "SELECT key, value FROM system_config;"
# 停止所有服务
docker compose down
# 备份数据库（以防万一）
cp config.db config.db.backup
cp trading.db trading.db.backup
# 可选：备份 PostgreSQL 数据
docker compose exec postgres \
pg_dump -U nofx -d nofx > backup_nofx.sql
# 删除数据库（全新开始）
rm config.db trading.db
# 删除所有持久化卷（全新开始）
docker compose down -v
# 重启
docker compose up -d --build
docs/guides/faq.en.md
+4 -5
View File
@@ -152,18 +152,17 @@ Yes, to some extent. NOFX provides historical performance feedback in each decis
## Data & Privacy
### Where is my data stored?
All data is stored **locally** on your machine in SQLite databases:
- `config.db` - Trader configurations
- `trading.db` - Trade history
All data is stored **locally** in PostgreSQL (Docker volume `postgres_data`) plus:
- `decision_logs/` - AI decision records
### Is my API key secure?
API keys are stored in local databases. Never share your databases or `.env` files. We recommend using API keys with IP whitelist restrictions.
### Can I export my trading history?
Yes! Trading data is in SQLite format. You can query it directly:
Yes! Use `pg_dump` or `psql` to export data:
```bash
sqlite3 trading.db "SELECT * FROM trades;"
docker compose exec postgres \
psql -U nofx -d nofx -c "SELECT * FROM trades;"
```
---
docs/guides/faq.zh-CN.md
+4 -5
View File
@@ -152,18 +152,17 @@ docker compose up -d
## 数据与隐私
### 我的数据存储在哪里？
所有数据都**本地存储**在您的机器上，使用 SQLite 数据库：
- `config.db` - 交易员配置
- `trading.db` - 交易历史
所有数据都**本地存储**在 PostgreSQL（Docker 卷 `postgres_data`）中，另有：
- `decision_logs/` - AI 决策记录
### API 密钥安全吗？
API 密钥存储在本地数据库中。永远不要分享您的数据库或 `.env` 文件。我们建议使用带 IP 白名单限制的 API 密钥。
### 可以导出交易历史吗？
可以！交易数据是 SQLite 格式。您可以直接查询：
可以！使用 `pg_dump` 或 `psql` 导出数据：
```bash
sqlite3 trading.db "SELECT * FROM trades;"
docker compose exec postgres \
psql -U nofx -d nofx -c "SELECT * FROM trades;"
```
---
docs/i18n/en/PRIVACY POLICY.md
+111
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)
docs/i18n/en/TERMS OF SERVICE.md
+155
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.
docs/i18n/ja/PRIVACY POLICY.md
+111
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)
docs/i18n/ja/README.md
+1446
View File
File diff suppressed because it is too large Load Diff
docs/i18n/ja/TERMS OF SERVICE.md
+156
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との間の完全な合意を構成します。
docs/i18n/ru/PRIVACY POLICY.md
+111
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)
docs/i18n/ru/README.md
+99 -20
View File
@@ -3,10 +3,10 @@
[![Go Version](https://img.shields.io/badge/Go-1.21+-00ADD8?style=flat&logo=go)](https://golang.org/)
[![React](https://img.shields.io/badge/React-18+-61DAFB?style=flat&logo=react)](https://reactjs.org/)
[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-3178C6?style=flat&logo=typescript)](https://www.typescriptlang.org/)
[![License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
[![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-интерфейса)
- [⚠️ Важные Предупреждения о Рисках](#️-важные-предупреждения-о-рисках)
@@ -285,7 +288,7 @@ Docker автоматически обрабатывает все зависим
#### Шаг 1: Подготовьте конфигурацию
```bash
# Скопируйте шаблон конфигурации
cp config.example.jsonc config.json
cp config.json.example config.json
# Отредактируйте и заполните ваши API ключи
nano config.json # или используйте любой редактор
@@ -294,8 +297,8 @@ nano config.json # или используйте любой редактор
#### Шаг 2: Запуск в один клик
```bash
# Вариант 1: Используйте удобный скрипт (Рекомендуется)
chmod +x start.sh
./start.sh start --build
chmod +x scripts/start.sh
./scripts/start.sh start --build
# Вариант 2: Используйте docker compose напрямую
# Этот проект использует синтаксис Docker Compose V2 (с пробелами)
@@ -310,16 +313,17 @@ docker compose up -d --build
#### Управление вашей системой
```bash
./start.sh logs # Просмотреть логи
./start.sh status # Проверить статус
./start.sh stop # Остановить сервисы
./start.sh restart # Перезапустить сервисы
./scripts/start.sh logs # Просмотреть логи
./scripts/start.sh status # Проверить статус
./scripts/start.sh stop # Остановить сервисы
./scripts/start.sh restart # Перезапустить сервисы
```
**📖 Подробное руководство по развертыванию Docker, устранению неполадок и расширенной конфигурации:**
- **Русский**: См. документацию Docker (скоро будет доступно)
- **English**: See [DOCKER_DEPLOY.en.md](DOCKER_DEPLOY.en.md)
- **中文**: 查看 [DOCKER_DEPLOY.md](DOCKER_DEPLOY.md)
- **日本語**: [DOCKER_DEPLOY.ja.md](DOCKER_DEPLOY.ja.md)を参照
---
@@ -423,7 +427,7 @@ cd ..
**Шаг 1**: Скопируйте и переименуйте файл примера конфигурации
```bash
cp config.example.jsonc config.json
cp config.json.example config.json
```
**Шаг 2**: Отредактируйте `config.json` и заполните ваши API ключи
@@ -480,18 +484,93 @@ cp config.example.jsonc 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
{
@@ -524,9 +603,9 @@ cp config.example.jsonc config.json
---
#### 🔶 Альтернатива: Использование биржи Aster DEX
#### 🔶 Использование биржи Aster DEX
**NOFX также поддерживает Aster DEX** - децентрализованную биржу бессрочных фьючерсов, совместимую с Binance!
**NOFX поддерживает Aster DEX** - децентрализованную биржу бессрочных фьючерсов, совместимую с Binance!
**Почему выбрать Aster?**
- 🎯 API совместимый с Binance (легкая миграция)
docs/i18n/ru/TERMS OF SERVICE.md
+155
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 ОТНОСИТЕЛЬНО ПРЕДМЕТА ДОГОВОРА.
docs/i18n/uk/PRIVACY POLICY.md
+111
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)
docs/i18n/uk/README.md
+100 -21
View File
@@ -3,10 +3,10 @@
[![Go Version](https://img.shields.io/badge/Go-1.21+-00ADD8?style=flat&logo=go)](https://golang.org/)
[![React](https://img.shields.io/badge/React-18+-61DAFB?style=flat&logo=react)](https://reactjs.org/)
[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-3178C6?style=flat&logo=typescript)](https://www.typescriptlang.org/)
[![License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
[![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)
@@ -288,7 +291,7 @@ Docker автоматично обробляє всі залежності (Go,
#### Крок 1: Підготуйте конфігурацію
```bash
# Скопіюйте шаблон конфігурації
cp config.example.jsonc config.json
cp config.json.example config.json
# Відредагуйте та заповніть ваші API ключі
nano config.json # або використайте будь-який редактор
@@ -297,8 +300,8 @@ nano config.json # або використайте будь-який редак
#### Крок 2: Запуск в один клік
```bash
# Варіант 1: Використайте зручний скрипт (Рекомендується)
chmod +x start.sh
./start.sh start --build
chmod +x scripts/start.sh
./scripts/start.sh start --build
# Варіант 2: Використайте docker compose безпосередньо
# Цей проект використовує синтаксис Docker Compose V2 (з пробілами)
@@ -313,16 +316,17 @@ docker compose up -d --build
#### Керування вашою системою
```bash
./start.sh logs # Переглянути логи
./start.sh status # Перевірити статус
./start.sh stop # Зупинити сервіси
./start.sh restart # Перезапустити сервіси
./scripts/start.sh logs # Переглянути логи
./scripts/start.sh status # Перевірити статус
./scripts/start.sh stop # Зупинити сервіси
./scripts/start.sh restart # Перезапустити сервіси
```
**📖 Детальний посібник з розгортання Docker, усунення несправностей та розширеної конфігурації:**
- **Українська**: Дивіться документацію Docker (скоро буде доступно)
- **English**: See [DOCKER_DEPLOY.en.md](DOCKER_DEPLOY.en.md)
- **中文**: 查看 [DOCKER_DEPLOY.md](DOCKER_DEPLOY.md)
- **日本語**: [DOCKER_DEPLOY.ja.md](DOCKER_DEPLOY.ja.md)を参照
---
@@ -426,7 +430,7 @@ cd ..
**Крок 1**: Скопіюйте та перейменуйте файл прикладу конфігурації
```bash
cp config.example.jsonc config.json
cp config.json.example config.json
```
**Крок 2**: Відредагуйте `config.json` та заповніть ваші API ключі
@@ -483,18 +487,93 @@ cp config.example.jsonc 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
{
@@ -527,9 +606,9 @@ cp config.example.jsonc config.json
---
#### 🔶 Альтернатива: Використання біржі Aster DEX
#### 🔶 Використання біржі Aster DEX
**NOFX також підтримує Aster DEX** - децентралізовану біржу безстрокових ф'ючерсів, сумісну з Binance!
**NOFX підтримує Aster DEX** - децентралізовану біржу безстрокових ф'ючерсів, сумісну з Binance!
**Чому обрати Aster?**
- 🎯 API сумісний з Binance (легка міграція)
docs/i18n/uk/TERMS OF SERVICE.md
+155
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 ЩОДО ПРЕДМЕТА ДОГОВОРУ.
docs/i18n/zh-CN/PRIVACY POLICY.md
+111
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)
docs/i18n/zh-CN/README.md
+108 -28
View File
@@ -3,10 +3,10 @@
[![Go Version](https://img.shields.io/badge/Go-1.21+-00ADD8?style=flat&logo=go)](https://golang.org/)
[![React](https://img.shields.io/badge/React-18+-61DAFB?style=flat&logo=react)](https://reactjs.org/)
[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-3178C6?style=flat&logo=typescript)](https://www.typescriptlang.org/)
[![License](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
[![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自我学习示例)
@@ -283,7 +285,7 @@ Docker会自动处理所有依赖（Go、Node.js、TA-Lib）和环境配置，
#### 步骤1：准备配置文件
```bash
# 复制配置文件模板
cp config.example.jsonc config.json
cp config.json.example config.json
# 编辑并填入你的API密钥
nano config.json # 或使用其他编辑器
@@ -294,8 +296,8 @@ nano config.json # 或使用其他编辑器
#### 步骤2：一键启动
```bash
# 方式1：使用便捷脚本（推荐）
chmod +x start.sh
./start.sh start --build
chmod +x scripts/start.sh
./scripts/start.sh start --build
# 方式2：直接使用docker compose
@@ -310,15 +312,16 @@ docker compose up -d --build
#### 管理你的系统
```bash
./start.sh logs # 查看日志
./start.sh status # 检查状态
./start.sh stop # 停止服务
./start.sh restart # 重启服务
./scripts/start.sh logs # 查看日志
./scripts/start.sh status # 检查状态
./scripts/start.sh stop # 停止服务
./scripts/start.sh restart # 重启服务
```
**📖 详细的Docker部署教程、故障排查和高级配置：**
- **中文**: 查看 [DOCKER_DEPLOY.md](DOCKER_DEPLOY.md)
- **English**: See [DOCKER_DEPLOY.en.md](DOCKER_DEPLOY.en.md)
- **日本語**: [DOCKER_DEPLOY.ja.md](DOCKER_DEPLOY.ja.md)を参照
---
@@ -422,7 +425,7 @@ cd ..
~~**步骤1**：复制并重命名示例配置文件~~
```bash
cp config.example.jsonc config.json
cp config.json.example config.json
```
~~**步骤2**：编辑`config.json`填入您的API密钥~~
@@ -481,18 +484,82 @@ cp config.example.jsonc 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
{
@@ -503,8 +570,8 @@ cp config.example.jsonc 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,
@@ -516,18 +583,23 @@ cp config.example.jsonc 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（轻松迁移）
@@ -1262,7 +1334,15 @@ sudo apt-get install libta-lib0-dev
## 📄 开源协议
MIT License - 详见 [LICENSE](LICENSE) 文件
本项目采用 **GNU Affero 通用公共许可证 v3.0 (AGPL-3.0)** - 详见 [LICENSE](LICENSE) 文件
**这意味着什么：**
- ✅ 你可以使用、修改和分发此软件
- ✅ 你必须公开你修改版本的源代码
- ✅ 如果你在服务器上运行修改版本，必须向用户提供源代码
- ✅ 所有衍生作品也必须使用 AGPL-3.0 许可证
如需商业许可或有疑问,请联系维护者。
---
docs/i18n/zh-CN/TERMS OF SERVICE.md
+155
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 之间关于标的物的完整协议。
docs/prompt-guide.md
+1529
View File
File diff suppressed because it is too large Load Diff
docs/prompt-guide.zh-CN.md
+1530
View File
File diff suppressed because it is too large Load Diff
generate_beta_code.sh
-221
View File
@@ -1,221 +0,0 @@
#!/bin/bash
# 内测码生成脚本
# 生成6位不重复的内测码并写入 beta_codes.txt
BETA_CODES_FILE="beta_codes.txt"
COUNT=1
LIST_ONLY=false
CODE_LENGTH=6
# 字符集（避免易混淆字符：0/O, 1/I/l）
CHARSET="23456789abcdefghjkmnpqrstuvwxyz"
# 显示帮助信息
show_help() {
cat << EOF
用法: $0 [选项]
选项:
-c COUNT 生成内测码数量 (默认: 1)
-l 列出现有内测码
-f FILE 内测码文件路径 (默认: beta_codes.txt)
-h 显示此帮助信息
示例:
$0 -c 10 # 生成10个内测码
$0 -l # 列出现有内测码
$0 -f custom.txt -c 5 # 在自定义文件中生成5个内测码
EOF
}
# 生成随机内测码
generate_beta_code() {
local length="$1"
local charset="$2"
local code=""
for ((i=0; i<length; i++)); do
local random_index=$((RANDOM % ${#charset}))
code+="${charset:$random_index:1}"
done
echo "$code"
}
# 读取现有内测码
read_existing_codes() {
local file="$1"
if [ -f "$file" ]; then
grep -v '^$' "$file" 2>/dev/null | tr -d ' \t' | grep -v '^#' || true
fi
}
# 检查内测码是否已存在
code_exists() {
local code="$1"
local file="$2"
if [ -f "$file" ]; then
grep -Fxq "$code" "$file" 2>/dev/null
else
return 1
fi
}
# 添加内测码到文件
add_code_to_file() {
local code="$1"
local file="$2"
echo "$code" >> "$file"
}
# 验证内测码格式
validate_code() {
local code="$1"
# 检查长度
if [ ${#code} -ne $CODE_LENGTH ]; then
return 1
fi
# 检查字符是否都在允许的字符集中
if [[ ! "$code" =~ ^[$CHARSET]+$ ]]; then
return 1
fi
return 0
}
# 去重并排序内测码
dedupe_and_sort_codes() {
local file="$1"
if [ -f "$file" ]; then
# 过滤空行和注释，去重并排序
grep -v '^$' "$file" | grep -v '^#' | sort -u > "${file}.tmp" && mv "${file}.tmp" "$file"
fi
}
# 解析命令行参数
while getopts "c:lf:h" opt; do
case $opt in
c)
COUNT="$OPTARG"
if ! [[ "$COUNT" =~ ^[0-9]+$ ]] || [ "$COUNT" -lt 1 ]; then
echo "错误: count 必须是正整数" >&2
exit 1
fi
;;
l)
LIST_ONLY=true
;;
f)
BETA_CODES_FILE="$OPTARG"
;;
h)
show_help
exit 0
;;
\?)
echo "无效选项: -$OPTARG" >&2
echo "使用 -h 查看帮助信息" >&2
exit 1
;;
esac
done
# 如果是列出现有内测码
if [ "$LIST_ONLY" = true ]; then
if [ -f "$BETA_CODES_FILE" ]; then
existing_codes=$(read_existing_codes "$BETA_CODES_FILE")
if [ -z "$existing_codes" ]; then
echo "内测码列表为空"
else
count=$(echo "$existing_codes" | wc -l | tr -d ' ')
echo "当前内测码 ($count 个):"
echo "$existing_codes" | nl -w3 -s'. '
fi
else
echo "内测码文件不存在: $BETA_CODES_FILE"
fi
exit 0
fi
# 读取现有内测码
existing_codes=$(read_existing_codes "$BETA_CODES_FILE")
# 生成新内测码
new_codes=()
max_attempts=1000 # 防止无限循环
echo "正在生成 $COUNT 个内测码..."
for ((i=1; i<=COUNT; i++)); do
attempts=0
while [ $attempts -lt $max_attempts ]; do
code=$(generate_beta_code $CODE_LENGTH "$CHARSET")
# 验证格式
if ! validate_code "$code"; then
((attempts++))
continue
fi
# 检查是否已存在
if code_exists "$code" "$BETA_CODES_FILE"; then
((attempts++))
continue
fi
# 检查是否与本次生成的重复
duplicate=false
for existing_code in "${new_codes[@]}"; do
if [ "$code" = "$existing_code" ]; then
duplicate=true
break
fi
done
if [ "$duplicate" = false ]; then
new_codes+=("$code")
break
fi
((attempts++))
done
if [ $attempts -eq $max_attempts ]; then
echo "警告: 生成第 $i 个内测码时达到最大尝试次数，可能字符空间不足" >&2
break
fi
done
# 检查是否成功生成了内测码
if [ ${#new_codes[@]} -eq 0 ]; then
echo "未能生成任何新的内测码"
exit 1
fi
# 添加到文件
for code in "${new_codes[@]}"; do
add_code_to_file "$code" "$BETA_CODES_FILE"
done
# 去重并排序
dedupe_and_sort_codes "$BETA_CODES_FILE"
echo "成功生成 ${#new_codes[@]} 个内测码:"
printf ' %s\n' "${new_codes[@]}"
echo
echo "内测码文件: $BETA_CODES_FILE"
# 显示当前总数
if [ -f "$BETA_CODES_FILE" ]; then
total_count=$(read_existing_codes "$BETA_CODES_FILE" | wc -l | tr -d ' ')
echo "当前内测码总计: $total_count 个"
fi
# 显示文件头部信息（如果是新文件）
if [ ! -s "$BETA_CODES_FILE" ] || [ $(wc -l < "$BETA_CODES_FILE") -eq ${#new_codes[@]} ]; then
echo
echo "内测码规则："
echo "- 长度: $CODE_LENGTH 位"
echo "- 字符集: 数字 2-9, 小写字母 a-z (排除 0,1,i,l,o 避免混淆)"
echo "- 每个内测码唯一且不重复"
fi
go.mod
+17 -3
View File
@@ -4,15 +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/mattn/go-sqlite3 v1.14.16
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 (
@@ -26,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
@@ -39,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
@@ -50,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
@@ -70,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
@@ -77,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
)
go.sum
+55 -2
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=
@@ -32,6 +34,8 @@ github.com/decred/dcrd/crypto/blake256 v1.1.0 h1:zPMNGQCm0g4QTY27fOCorQW7EryeQ/U
github.com/decred/dcrd/crypto/blake256 v1.1.0/go.mod h1:2OfgNZ5wDpcsFmHmCK5gZTPcCXqlm2ArzUIkw9czNJo=
github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0 h1:NMZiJj8QnKe1LgsbDayM4UoHwbvwDRwnI3hwNaAHRnc=
github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.0/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40=
github.com/dustin/go-humanize v1.0.1 h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY=
github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto=
github.com/elastic/go-sysinfo v1.15.4 h1:A3zQcunCxik14MgXu39cXFXcIw2sFXZ0zL886eyiv1Q=
github.com/elastic/go-sysinfo v1.15.4/go.mod h1:ZBVXmqS368dOn/jvijV/zHLfakWTYHBZPk3G244lHrU=
github.com/elastic/go-windows v1.0.2 h1:yoLLsAsV5cfg9FLhZ9EXZ2n2sQFKeDYrHenkcivY4vI=
@@ -62,6 +66,8 @@ github.com/go-playground/universal-translator v0.18.1 h1:Bcnm0ZwsGyWbCzImXv+pAJn
github.com/go-playground/universal-translator v0.18.1/go.mod h1:xekY+UJKNuX9WP91TpwSH2VMlDf28Uj24BCp08ZFTUY=
github.com/go-playground/validator/v10 v10.27.0 h1:w8+XrWVMhGkxOaaowyKH35gFydVHOvC0/uWoy2Fzwn4=
github.com/go-playground/validator/v10 v10.27.0/go.mod h1:I5QpIEbmr8On7W0TktmJAumgzX4CA1XNl4ZmDuVHKKo=
github.com/go-telegram-bot-api/telegram-bot-api/v5 v5.5.1 h1:wG8n/XJQ07TmjbITcGiUaOtXxdrINDz1b0J1w0SzqDc=
github.com/go-telegram-bot-api/telegram-bot-api/v5 v5.5.1/go.mod h1:A2S0CWkNylc2phvKXWBBdD3K0iGnDBGbzRpISP2zBl8=
github.com/goccy/go-json v0.10.4 h1:JSwxQzIqKfmFX1swYPpUThQZp/Ka4wzJdK0LWVytLPM=
github.com/goccy/go-json v0.10.4/go.mod h1:oq7eo15ShAhp70Anwd5lgX2pLfOS3QCiwU/PULtXL6M=
github.com/goccy/go-yaml v1.18.0 h1:8W7wMFS12Pcas7KU+VVkaiCng+kG8QiFeFwzFb+rwuw=
@@ -80,8 +86,11 @@ github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX
github.com/google/gofuzz v1.0.0/go.mod h1:dBl0BpW6vV/+mYPU4Po3pmUjxk6FQPldtuIdl/M65Eg=
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/pprof v0.0.0-20250317173921-a4b03ec1a45e h1:ijClszYn+mADRFY17kjQEVQ1XRhq2/JR1M3sGqeJoxs=
github.com/google/pprof v0.0.0-20250317173921-a4b03ec1a45e/go.mod h1:boTsfXsheKC2y+lKOCMpSfarhxDeIzfZG1jqGcPl3cA=
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=
@@ -95,6 +104,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=
@@ -118,8 +128,6 @@ github.com/mattn/go-isatty v0.0.20 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWE
github.com/mattn/go-isatty v0.0.20/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3Y=
github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
github.com/mattn/go-sqlite3 v1.14.16 h1:yOQRA0RpS5PFz/oikGwBEqvAWhWg5ufRz4ETLjwpU1Y=
github.com/mattn/go-sqlite3 v1.14.16/go.mod h1:2eHXhiwb8IkHr+BDWZGa96P6+rkvnG63S2DGjv9HUNg=
github.com/minio/sha256-simd v1.0.0 h1:v1ta+49hkWZyvaKwrQB8elexRqm6Y0aMLjCNsrYxo6g=
github.com/minio/sha256-simd v1.0.0/go.mod h1:OuYzVNI5vcoYIAmbIvHPl3N3jUzVedXbKy5RFepssQM=
github.com/mitchellh/mapstructure v1.4.1 h1:CpVNEelQCZBooIPDn+AR3NpivK/TIKU8bDxdASFVQag=
@@ -128,6 +136,8 @@ github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421 h1:ZqeYNhU3OH
github.com/modern-go/concurrent v0.0.0-20180228061459-e0a39a4cb421/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
github.com/modern-go/reflect2 v1.0.2 h1:xBagoLtFs94CBntxluKeaWgTMpvLxC4ur3nMaC9Gz0M=
github.com/modern-go/reflect2 v1.0.2/go.mod h1:yWuevngMOJpCy52FWWMvUC8ws7m/LJsjYzDa0/r8luk=
github.com/ncruces/go-strftime v0.1.9 h1:bY0MQC28UADQmHmaF5dgpLmImcShSi2kHU9XLdhx/f4=
github.com/ncruces/go-strftime v0.1.9/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=
github.com/olekukonko/tablewriter v0.0.5 h1:P2Ga83D34wi1o9J6Wh1mRuqd4mF/x/lgBS7N7AbDhec=
github.com/olekukonko/tablewriter v0.0.5/go.mod h1:hPp6KlRPjbx+hW8ykQs1w3UBbZlj6HuIJcUGPhkA7kY=
github.com/pelletier/go-toml/v2 v2.2.4 h1:mye9XuhQ6gvn5h28+VilKrrPoQVanw5PMw/TB0t5Ec4=
@@ -144,6 +154,8 @@ github.com/quic-go/qpack v0.5.1 h1:giqksBPnT/HDtZ6VhtFKgoLOWmlyo9Ei6u9PqzIMbhI=
github.com/quic-go/qpack v0.5.1/go.mod h1:+PC4XFrEskIVkcLzpEkbLqq1uCoxPhQuvK5rH1ZgaEg=
github.com/quic-go/quic-go v0.54.0 h1:6s1YB9QotYI6Ospeiguknbp2Znb/jZYjZLRXn9kMQBg=
github.com/quic-go/quic-go v0.54.0/go.mod h1:e68ZEaCdyviluZmy44P6Iey98v/Wfz6HCjQEm+l8zTY=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE=
github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo=
github.com/rivo/uniseg v0.4.7 h1:WUdvkW8uEhrYfLC4ZzdpI2ztxP1I582+49Oc5Mq64VQ=
github.com/rivo/uniseg v0.4.7/go.mod h1:FN3SvrM+Zdj16jyLfmOkMNblXMcoc8DfTHruCPUcx88=
github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ=
@@ -155,6 +167,10 @@ github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible h1
github.com/shirou/gopsutil v3.21.4-0.20210419000835-c7a38de76ee5+incompatible/go.mod h1:5b4v6he4MtMOwMlS0TUMTu2PcXUg8+E1lC7eC3UO/RA=
github.com/shopspring/decimal v1.4.0 h1:bxl37RwXBklmTi0C79JfXCEBD1cqqHt0bbgBAGFp81k=
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=
@@ -167,6 +183,7 @@ github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpE
github.com/stretchr/objx v0.5.2 h1:xuMeJ0Sdp5ZMRXx/aWO6RZxdr3beISkG5/G/aIRr3pY=
github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA=
github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU=
github.com/stretchr/testify v1.8.1/go.mod h1:w2LPCIKwWwSfY2zedu0+kehJoqGctiVI29o6fzry7u4=
@@ -198,26 +215,36 @@ 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/exp v0.0.0-20250620022241-b7579e27df2b h1:M2rDM6z3Fhozi9O7NWsxAkg/yqS/lQJ6PmkyIV3YP+o=
golang.org/x/exp v0.0.0-20250620022241-b7579e27df2b/go.mod h1:3//PLf8L/X+8b4vuAfHzxeRUl04Adcb341+IGKfnqS8=
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=
@@ -228,3 +255,29 @@ gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA=
gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=
howett.net/plist v1.0.1 h1:37GdZ8tP09Q35o9ych3ehygcsL+HqKSwzctveSlarvM=
howett.net/plist v1.0.1/go.mod h1:lqaXoTrLY4hg8tnEzNru53gicrbv7rrk+2xJA/7hw9g=
modernc.org/cc/v4 v4.26.5 h1:xM3bX7Mve6G8K8b+T11ReenJOT+BmVqQj0FY5T4+5Y4=
modernc.org/cc/v4 v4.26.5/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL0=
modernc.org/ccgo/v4 v4.28.1 h1:wPKYn5EC/mYTqBO373jKjvX2n+3+aK7+sICCv4Fjy1A=
modernc.org/ccgo/v4 v4.28.1/go.mod h1:uD+4RnfrVgE6ec9NGguUNdhqzNIeeomeXf6CL0GTE5Q=
modernc.org/fileutil v1.3.40 h1:ZGMswMNc9JOCrcrakF1HrvmergNLAmxOPjizirpfqBA=
modernc.org/fileutil v1.3.40/go.mod h1:HxmghZSZVAz/LXcMNwZPA/DRrQZEVP9VX0V4LQGQFOc=
modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI=
modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito=
modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks=
modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI=
modernc.org/libc v1.66.10 h1:yZkb3YeLx4oynyR+iUsXsybsX4Ubx7MQlSYEw4yj59A=
modernc.org/libc v1.66.10/go.mod h1:8vGSEwvoUoltr4dlywvHqjtAqHBaw0j1jI7iFBTAr2I=
modernc.org/mathutil v1.7.1 h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU=
modernc.org/mathutil v1.7.1/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg=
modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI=
modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw=
modernc.org/opt v0.1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8=
modernc.org/opt v0.1.4/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns=
modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w=
modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE=
modernc.org/sqlite v1.40.0 h1:bNWEDlYhNPAUdUdBzjAvn8icAs/2gaKlj4vM+tQ6KdQ=
modernc.org/sqlite v1.40.0/go.mod h1:9fjQZ0mB1LLP0GYrp39oOJXx/I2sxEnZtzCmEQIKvGE=
modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0=
modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A=
modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y=
modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM=
hook/README.md
+270
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`
hook/hooks.go
+41
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
)
hook/http_client_hook.go
+23
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
}
hook/ip_hook.go
+19
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
}
hook/trader_hook.go
+42
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
}
logger/config.go
+64
View File
@@ -0,0 +1,64 @@
package logger
import (
"github.com/sirupsen/logrus"
)
// Config 日志配置（简化版）
type Config struct {
Level string `json:"level"` // 日志级别: debug, info, warn, error (默认: info)
Telegram *TelegramConfig `json:"telegram"` // Telegram推送配置（可选）
}
// TelegramConfig Telegram推送配置（简化版，高级参数使用默认值）
type TelegramConfig struct {
Enabled bool `json:"enabled"` // 是否启用（默认: false）
BotToken string `json:"bot_token"` // Bot Token
ChatID int64 `json:"chat_id"` // Chat ID
MinLevel string `json:"min_level"` // 最低日志级别，该级别及以上的日志会推送到Telegram（可选，默认: error）
}
// SetDefaults 设置默认值
func (c *Config) SetDefaults() {
if c.Level == "" {
c.Level = "info"
}
}
// GetLogrusLevels 返回要推送到Telegram的日志级别
// 根据配置的MinLevel返回该级别及以上的所有日志级别
// 如果未配置或配置无效，默认返回error, fatal, panic（向后兼容）
func (tc *TelegramConfig) GetLogrusLevels() []logrus.Level {
// 如果未配置，使用默认值error（向后兼容）
minLevelStr := tc.MinLevel
if minLevelStr == "" {
minLevelStr = "error"
}
// 解析配置的日志级别
minLevel, err := logrus.ParseLevel(minLevelStr)
if err != nil {
// 如果解析失败，使用默认值error（向后兼容）
minLevel = logrus.ErrorLevel
}
// 定义所有日志级别（从高到低：panic, fatal, error, warn, info, debug）
allLevels := []logrus.Level{
logrus.PanicLevel,
logrus.FatalLevel,
logrus.ErrorLevel,
logrus.WarnLevel,
logrus.InfoLevel,
logrus.DebugLevel,
}
// 返回所有大于等于minLevel的日志级别
var result []logrus.Level
for _, level := range allLevels {
if level <= minLevel {
result = append(result, level)
}
}
return result
}
logger/config.telegram.json
+33
View File
@@ -0,0 +1,33 @@
{
"traders": [
{
"id": "trader1",
"name": "AI Trader 1",
"enabled": true,
"ai_model": "deepseek",
"exchange": "binance",
"binance_api_key": "your_api_key",
"binance_secret_key": "your_secret_key",
"deepseek_key": "your_deepseek_key",
"initial_balance": 1000,
"scan_interval_minutes": 3
}
],
"use_default_coins": true,
"default_coins": ["BTCUSDT", "ETHUSDT", "SOLUSDT"],
"api_server_port": 8080,
"leverage": {
"btc_eth_leverage": 5,
"altcoin_leverage": 5
},
"log": {
"level": "info",
"telegram": {
"enabled": true,
"bot_token": "79472419:feafe231414",
"chat_id": -100323252626,
"min_level": "error"
}
},
"_comment": "日志配置说明：level 可选值为 debug/info/warn/error，默认 info。telegram 部分作为可选配置, Telegram 推送默认为 error/fatal/panic 级别，min_level 如果设置为warn，则推送warn级别及以上的日志"
}
logger/decision_logger.go
+198 -72
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 账户状态快照
@@ -50,9 +52,9 @@ type PositionSnapshot struct {
// DecisionAction 决策动作
type DecisionAction struct {
Action string `json:"action"` // open_long, open_short, close_long, close_short
Action string `json:"action"` // open_long, open_short, close_long, close_short, update_stop_loss, update_take_profit, partial_close
Symbol string `json:"symbol"` // 币种
Quantity float64 `json:"quantity"` // 数量
Quantity float64 `json:"quantity"` // 数量（部分平仓时使用）
Leverage int `json:"leverage"` // 杠杆（开仓时）
Price float64 `json:"price"` // 执行价格
OrderID int64 `json:"order_id"` // 订单ID
@@ -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)
}
@@ -243,8 +250,11 @@ func (l *DecisionLogger) GetStatistics() (*Statistics, error) {
switch action.Action {
case "open_long", "open_short":
stats.TotalOpenPositions++
case "close_long", "close_short":
case "close_long", "close_short", "auto_close_long", "auto_close_short":
stats.TotalClosePositions++
// 🔧 BUG FIX：partial_close 不計入 TotalClosePositions，避免重複計數
// case "partial_close": // 不計數，因為只有完全平倉才算一次
// update_stop_loss 和 update_take_profit 不計入統計
}
}
}
@@ -348,11 +358,22 @@ func (l *DecisionLogger) AnalyzePerformance(lookbackCycles int) (*PerformanceAna
symbol := action.Symbol
side := ""
if action.Action == "open_long" || action.Action == "close_long" {
if action.Action == "open_long" || action.Action == "close_long" || action.Action == "partial_close" || action.Action == "auto_close_long" {
side = "long"
} else if action.Action == "open_short" || action.Action == "close_short" {
} else if action.Action == "open_short" || action.Action == "close_short" || action.Action == "auto_close_short" {
side = "short"
}
// partial_close 需要根據持倉判斷方向
if action.Action == "partial_close" && side == "" {
for key, pos := range openPositions {
if posSymbol, _ := pos["side"].(string); key == symbol+"_"+posSymbol {
side = posSymbol
break
}
}
}
posKey := symbol + "_" + side
switch action.Action {
@@ -365,9 +386,10 @@ func (l *DecisionLogger) AnalyzePerformance(lookbackCycles int) (*PerformanceAna
"quantity": action.Quantity,
"leverage": action.Leverage,
}
case "close_long", "close_short":
case "close_long", "close_short", "auto_close_long", "auto_close_short":
// 移除已平仓记录
delete(openPositions, posKey)
// partial_close 不處理，保留持倉記錄
}
}
}
@@ -382,25 +404,41 @@ func (l *DecisionLogger) AnalyzePerformance(lookbackCycles int) (*PerformanceAna
symbol := action.Symbol
side := ""
if action.Action == "open_long" || action.Action == "close_long" {
if action.Action == "open_long" || action.Action == "close_long" || action.Action == "partial_close" || action.Action == "auto_close_long" {
side = "long"
} else if action.Action == "open_short" || action.Action == "close_short" {
} else if action.Action == "open_short" || action.Action == "close_short" || action.Action == "auto_close_short" {
side = "short"
}
// partial_close 需要根據持倉判斷方向
if action.Action == "partial_close" {
// 從 openPositions 中查找持倉方向
for key, pos := range openPositions {
if posSymbol, _ := pos["side"].(string); key == symbol+"_"+posSymbol {
side = posSymbol
break
}
}
}
posKey := symbol + "_" + side // 使用symbol_side作为key，区分多空持仓
switch action.Action {
case "open_long", "open_short":
// 更新开仓记录（可能已经在预填充时记录过了）
openPositions[posKey] = map[string]interface{}{
"side": side,
"openPrice": action.Price,
"openTime": action.Timestamp,
"quantity": action.Quantity,
"leverage": action.Leverage,
"side": side,
"openPrice": action.Price,
"openTime": action.Timestamp,
"quantity": action.Quantity,
"leverage": action.Leverage,
"remainingQuantity": action.Quantity, // 🔧 BUG FIX：追蹤剩餘數量
"accumulatedPnL": 0.0, // 🔧 BUG FIX：累積部分平倉盈虧
"partialCloseCount": 0, // 🔧 BUG FIX：部分平倉次數
"partialCloseVolume": 0.0, // 🔧 BUG FIX：部分平倉總量
}
case "close_long", "close_short":
case "close_long", "close_short", "partial_close", "auto_close_long", "auto_close_short":
// 查找对应的开仓记录（可能来自预填充或当前窗口）
if openPos, exists := openPositions[posKey]; exists {
openPrice := openPos["openPrice"].(float64)
@@ -409,71 +447,159 @@ func (l *DecisionLogger) AnalyzePerformance(lookbackCycles int) (*PerformanceAna
quantity := openPos["quantity"].(float64)
leverage := openPos["leverage"].(int)
// 计算实际盈亏（USDT）
// 合约交易 PnL 计算：quantity × 价格差
// 注意：杠杆不影响绝对盈亏，只影响保证金需求
// 🔧 BUG FIX：取得追蹤字段（若不存在則初始化）
remainingQty, _ := openPos["remainingQuantity"].(float64)
if remainingQty == 0 {
remainingQty = quantity // 兼容舊數據（沒有 remainingQuantity 字段）
}
accumulatedPnL, _ := openPos["accumulatedPnL"].(float64)
partialCloseCount, _ := openPos["partialCloseCount"].(int)
partialCloseVolume, _ := openPos["partialCloseVolume"].(float64)
// 对于 partial_close，使用实际平仓数量；否则使用剩余仓位数量
actualQuantity := remainingQty
if action.Action == "partial_close" {
actualQuantity = action.Quantity
}
// 计算本次平仓的盈亏（USDT）
var pnl float64
if side == "long" {
pnl = quantity * (action.Price - openPrice)
pnl = actualQuantity * (action.Price - openPrice)
} else {
pnl = quantity * (openPrice - action.Price)
pnl = actualQuantity * (openPrice - action.Price)
}
// 计算盈亏百分比（相对保证金）
positionValue := quantity * openPrice
marginUsed := positionValue / float64(leverage)
pnlPct := 0.0
if marginUsed > 0 {
pnlPct = (pnl / marginUsed) * 100
}
// 🔧 BUG FIX：處理 partial_close 聚合邏輯
if action.Action == "partial_close" {
// 累積盈虧和數量
accumulatedPnL += pnl
remainingQty -= actualQuantity
partialCloseCount++
partialCloseVolume += actualQuantity
// 记录交易结果
outcome := TradeOutcome{
Symbol: symbol,
Side: side,
Quantity: quantity,
Leverage: leverage,
OpenPrice: openPrice,
ClosePrice: action.Price,
PositionValue: positionValue,
MarginUsed: marginUsed,
PnL: pnl,
PnLPct: pnlPct,
Duration: action.Timestamp.Sub(openTime).String(),
OpenTime: openTime,
CloseTime: action.Timestamp,
}
// 更新 openPositions（保留持倉記錄，但更新追蹤數據）
openPos["remainingQuantity"] = remainingQty
openPos["accumulatedPnL"] = accumulatedPnL
openPos["partialCloseCount"] = partialCloseCount
openPos["partialCloseVolume"] = partialCloseVolume
analysis.RecentTrades = append(analysis.RecentTrades, outcome)
analysis.TotalTrades++
// 判斷是否已完全平倉
if remainingQty <= 0.0001 { // 使用小閾值避免浮點誤差
// ✅ 完全平倉：記錄為一筆完整交易
positionValue := quantity * openPrice
marginUsed := positionValue / float64(leverage)
pnlPct := 0.0
if marginUsed > 0 {
pnlPct = (accumulatedPnL / marginUsed) * 100
}
// 分类交易：盈利、亏损、持平（避免将pnl=0算入亏损）
if pnl > 0 {
analysis.WinningTrades++
analysis.AvgWin += pnl
} else if pnl < 0 {
analysis.LosingTrades++
analysis.AvgLoss += pnl
}
// pnl == 0 的交易不计入盈利也不计入亏损，但计入总交易数
outcome := TradeOutcome{
Symbol: symbol,
Side: side,
Quantity: quantity, // 使用原始總量
Leverage: leverage,
OpenPrice: openPrice,
ClosePrice: action.Price, // 最後一次平倉價格
PositionValue: positionValue,
MarginUsed: marginUsed,
PnL: accumulatedPnL, // 🔧 使用累積盈虧
PnLPct: pnlPct,
Duration: action.Timestamp.Sub(openTime).String(),
OpenTime: openTime,
CloseTime: action.Timestamp,
}
// 更新币种统计
if _, exists := analysis.SymbolStats[symbol]; !exists {
analysis.SymbolStats[symbol] = &SymbolPerformance{
Symbol: symbol,
analysis.RecentTrades = append(analysis.RecentTrades, outcome)
analysis.TotalTrades++ // 🔧 只在完全平倉時計數
// 分类交易
if accumulatedPnL > 0 {
analysis.WinningTrades++
analysis.AvgWin += accumulatedPnL
} else if accumulatedPnL < 0 {
analysis.LosingTrades++
analysis.AvgLoss += accumulatedPnL
}
// 更新币种统计
if _, exists := analysis.SymbolStats[symbol]; !exists {
analysis.SymbolStats[symbol] = &SymbolPerformance{
Symbol: symbol,
}
}
stats := analysis.SymbolStats[symbol]
stats.TotalTrades++
stats.TotalPnL += accumulatedPnL
if accumulatedPnL > 0 {
stats.WinningTrades++
} else if accumulatedPnL < 0 {
stats.LosingTrades++
}
// 刪除持倉記錄
delete(openPositions, posKey)
}
}
stats := analysis.SymbolStats[symbol]
stats.TotalTrades++
stats.TotalPnL += pnl
if pnl > 0 {
stats.WinningTrades++
} else if pnl < 0 {
stats.LosingTrades++
}
// ⚠️ 否則不做任何操作（等待後續 partial_close 或 full close）
// 移除已平仓记录
delete(openPositions, posKey)
} else {
// 🔧 完全平倉（close_long/close_short/auto_close）
// 如果之前有部分平倉，需要加上累積的 PnL
totalPnL := accumulatedPnL + pnl
positionValue := quantity * openPrice
marginUsed := positionValue / float64(leverage)
pnlPct := 0.0
if marginUsed > 0 {
pnlPct = (totalPnL / marginUsed) * 100
}
outcome := TradeOutcome{
Symbol: symbol,
Side: side,
Quantity: quantity, // 使用原始總量
Leverage: leverage,
OpenPrice: openPrice,
ClosePrice: action.Price,
PositionValue: positionValue,
MarginUsed: marginUsed,
PnL: totalPnL, // 🔧 包含之前部分平倉的 PnL
PnLPct: pnlPct,
Duration: action.Timestamp.Sub(openTime).String(),
OpenTime: openTime,
CloseTime: action.Timestamp,
}
analysis.RecentTrades = append(analysis.RecentTrades, outcome)
analysis.TotalTrades++
// 分类交易
if totalPnL > 0 {
analysis.WinningTrades++
analysis.AvgWin += totalPnL
} else if totalPnL < 0 {
analysis.LosingTrades++
analysis.AvgLoss += totalPnL
}
// 更新币种统计
if _, exists := analysis.SymbolStats[symbol]; !exists {
analysis.SymbolStats[symbol] = &SymbolPerformance{
Symbol: symbol,
}
}
stats := analysis.SymbolStats[symbol]
stats.TotalTrades++
stats.TotalPnL += totalPnL
if totalPnL > 0 {
stats.WinningTrades++
} else if totalPnL < 0 {
stats.LosingTrades++
}
// 刪除持倉記錄
delete(openPositions, posKey)
}
}
}
}
logger/logger.go
+210
View File
@@ -0,0 +1,210 @@
package logger
import (
"nofx/config"
"os"
"github.com/sirupsen/logrus"
)
var (
// Log 全局logger实例
Log *logrus.Logger
// telegramHook 保存hook引用，用于优雅关闭
telegramHook *TelegramHook
)
// ============================================================================
// 初始化函数
// ============================================================================
// Init 初始化全局logger
// 如果config为nil，使用默认配置（console输出，info级别）
func Init(cfg *Config) error {
Log = logrus.New()
// 如果没有配置，使用默认值
if cfg == nil {
cfg = &Config{Level: "info"}
}
// 设置默认值
cfg.SetDefaults()
// 设置日志级别
level, err := logrus.ParseLevel(cfg.Level)
if err != nil {
level = logrus.InfoLevel
}
Log.SetLevel(level)
// 设置格式化器（固定使用彩色文本格式）
Log.SetFormatter(&logrus.TextFormatter{
FullTimestamp: true,
TimestampFormat: "2006-01-02 15:04:05",
ForceColors: true,
})
// 设置输出目标（默认stdout）
Log.SetOutput(os.Stdout)
// 启用调用位置信息
Log.SetReportCaller(true)
// 添加Telegram Hook（可选）
if cfg.Telegram != nil && cfg.Telegram.Enabled {
if err := setupTelegramHook(cfg.Telegram); err != nil {
Log.Warnf("初始化Telegram推送失败，将继续使用普通日志: %v", err)
}
}
return nil
}
// setupTelegramHook 设置Telegram Hook
func setupTelegramHook(telegramCfg *TelegramConfig) error {
hook, err := NewTelegramHook(telegramCfg)
if err != nil {
return err
}
Log.AddHook(hook)
telegramHook = hook
Log.Info("✅ Telegram日志推送已启用")
return nil
}
// InitWithSimpleConfig 使用简化配置初始化logger
// 适用于只需要基本功能的场景
func InitWithSimpleConfig(level string) error {
return Init(&Config{Level: level})
}
// InitWithTelegram 使用Telegram配置初始化logger
func InitWithTelegram(botToken string, chatID int64) error {
return Init(&Config{
Level: "info",
Telegram: &TelegramConfig{
Enabled: true,
BotToken: botToken,
ChatID: chatID,
},
})
}
// InitFromLogConfig 从config.LogConfig初始化logger
func InitFromLogConfig(logConfig *config.LogConfig) error {
if logConfig == nil {
return InitWithSimpleConfig("info")
}
cfg := &Config{
Level: logConfig.Level,
}
if cfg.Level == "" {
cfg.Level = "info"
}
// 如果启用了Telegram，添加配置
if logConfig.Telegram != nil && logConfig.Telegram.Enabled {
if botToken := logConfig.Telegram.BotToken; botToken != "" && logConfig.Telegram.ChatID != 0 {
cfg.Telegram = &TelegramConfig{
Enabled: true,
BotToken: botToken,
ChatID: logConfig.Telegram.ChatID,
MinLevel: logConfig.Telegram.MinLevel,
}
}
}
return Init(cfg)
}
// InitFromParams 从参数初始化logger
// 适用于不依赖config包的场景
func InitFromParams(level string, telegramEnabled bool, botToken string, chatID int64) error {
cfg := &Config{Level: level}
if telegramEnabled && botToken != "" && chatID != 0 {
cfg.Telegram = &TelegramConfig{
Enabled: true,
BotToken: botToken,
ChatID: chatID,
}
}
return Init(cfg)
}
// Shutdown 优雅关闭logger（主要用于关闭Telegram发送器）
func Shutdown() {
if telegramHook != nil {
telegramHook.Stop()
telegramHook = nil
}
}
// ============================================================================
// 日志记录函数
// ============================================================================
// WithFields 创建带字段的logger entry
func WithFields(fields logrus.Fields) *logrus.Entry {
return Log.WithFields(fields)
}
// WithField 创建带单个字段的logger entry
func WithField(key string, value interface{}) *logrus.Entry {
return Log.WithField(key, value)
}
// add debug, info, warn
func Debug(args ...interface{}) {
Log.Debug(args...)
}
func Info(args ...interface{}) {
Log.Info(args...)
}
func Warn(args ...interface{}) {
Log.Warn(args...)
}
func Debugf(format string, args ...interface{}) {
Log.Debugf(format, args...)
}
func Infof(format string, args ...interface{}) {
Log.Infof(format, args...)
}
func Warnf(format string, args ...interface{}) {
Log.Warnf(format, args...)
}
func Error(args ...interface{}) {
Log.Error(args...)
}
func Errorf(format string, args ...interface{}) {
Log.Errorf(format, args...)
}
func Fatal(args ...interface{}) {
Log.Fatal(args...)
}
func Fatalf(format string, args ...interface{}) {
Log.Fatalf(format, args...)
}
func Panic(args ...interface{}) {
Log.Panic(args...)
}
func Panicf(format string, args ...interface{}) {
Log.Panicf(format, args...)
}
logger/telegram_hook.go
+158
View File
@@ -0,0 +1,158 @@
package logger
import (
"fmt"
"runtime"
"strings"
"github.com/sirupsen/logrus"
)
// TelegramHook 实现logrus.Hook接口，将日志推送到Telegram
type TelegramHook struct {
sender *TelegramSender
levels []logrus.Level
enabled bool
}
// NewTelegramHook 创建Telegram Hook
func NewTelegramHook(config *TelegramConfig) (*TelegramHook, error) {
if !config.Enabled {
return &TelegramHook{enabled: false}, nil
}
if config.BotToken == "" || config.ChatID == 0 {
return nil, fmt.Errorf("telegram配置不完整: bot_token和chat_id不能为空")
}
// 创建发送器（使用默认参数）
sender, err := NewTelegramSender(config.BotToken, config.ChatID)
if err != nil {
return nil, fmt.Errorf("创建telegram发送器失败: %w", err)
}
hook := &TelegramHook{
sender: sender,
levels: config.GetLogrusLevels(),
enabled: true,
}
return hook, nil
}
// Levels 返回需要触发的日志级别
func (h *TelegramHook) Levels() []logrus.Level {
if !h.enabled {
return []logrus.Level{}
}
return h.levels
}
// Fire 当日志触发时调用
func (h *TelegramHook) Fire(entry *logrus.Entry) error {
if !h.enabled {
return nil
}
// 格式化消息
message := h.formatMessage(entry)
// 异步发送（非阻塞）
h.sender.SendAsync(message)
return nil
}
// formatMessage 格式化日志消息为Telegram格式
func (h *TelegramHook) formatMessage(entry *logrus.Entry) string {
// 级别emoji
levelEmoji := h.getLevelEmoji(entry.Level)
// 基本信息
var builder strings.Builder
builder.WriteString(fmt.Sprintf("%s *%s*: 系统日志警报\n", levelEmoji, strings.ToUpper(entry.Level.String())))
builder.WriteString(fmt.Sprintf("📝 消息: `%s`\n", escapeMarkdown(entry.Message)))
// 字段信息
if len(entry.Data) > 0 {
builder.WriteString("📊 字段:\n")
for key, value := range entry.Data {
builder.WriteString(fmt.Sprintf(" • %s: `%v`\n", key, value))
}
}
// 调用位置
if entry.HasCaller() {
file := entry.Caller.File
// 只保留相对路径
if idx := strings.Index(file, "nofx/"); idx >= 0 {
file = file[idx:]
}
builder.WriteString(fmt.Sprintf("📍 位置: `%s:%d`\n", file, entry.Caller.Line))
} else {
// 如果entry没有caller，手动获取
if _, file, line, ok := runtime.Caller(8); ok {
if idx := strings.Index(file, "nofx/"); idx >= 0 {
file = file[idx:]
}
builder.WriteString(fmt.Sprintf("📍 位置: `%s:%d`\n", file, line))
}
}
// 时间戳
builder.WriteString(fmt.Sprintf("🕐 时间: `%s`", entry.Time.Format("2006-01-02 15:04:05")))
return builder.String()
}
// getLevelEmoji 获取日志级别对应的emoji
func (h *TelegramHook) getLevelEmoji(level logrus.Level) string {
switch level {
case logrus.PanicLevel:
return "🔴"
case logrus.FatalLevel:
return "🔴"
case logrus.ErrorLevel:
return "🟠"
case logrus.WarnLevel:
return "🟡"
case logrus.InfoLevel:
return "🟢"
case logrus.DebugLevel:
return "🔵"
default:
return "⚪"
}
}
// escapeMarkdown 转义Markdown特殊字符
func escapeMarkdown(text string) string {
replacer := strings.NewReplacer(
"_", "\\_",
"*", "\\*",
"[", "\\[",
"]", "\\]",
"(", "\\(",
")", "\\)",
"~", "\\~",
"`", "\\`",
">", "\\>",
"#", "\\#",
"+", "\\+",
"-", "\\-",
"=", "\\=",
"|", "\\|",
"{", "\\{",
"}", "\\}",
".", "\\.",
"!", "\\!",
)
return replacer.Replace(text)
}
// Stop 停止Hook（优雅关闭）
func (h *TelegramHook) Stop() {
if h.enabled && h.sender != nil {
h.sender.Stop()
}
}

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