+
+
+### 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 📊 Detailed Coverage Report (click to expand)
+ +{coverage_report} + +起動をスキップする場合は`false`に設定 | `true`または`false` | ✅ はい | +| `ai_model` | 使用するAIプロバイダー | `"deepseek"`または`"qwen"`または`"custom"` | ✅ はい | +| `exchange` | 使用する取引所 | `"binance"`または`"hyperliquid"`または`"aster"` | ✅ はい | +| `binance_api_key` | Binance APIキー | `"abc123..."` | Binance使用時に必須 | +| `binance_secret_key` | Binanceシークレットキー | `"xyz789..."` | Binance使用時に必須 | +| `hyperliquid_private_key` | Hyperliquid秘密鍵
⚠️ `0x`プレフィックスを削除 | `"your_key..."` | Hyperliquid使用時に必須 | +| `hyperliquid_wallet_addr` | Hyperliquidウォレットアドレス | `"0xabc..."` | Hyperliquid使用時に必須 | +| `hyperliquid_testnet` | テストネットを使用 | `true`または`false` | ❌ いいえ（デフォルトはfalse） | +| `use_qwen` | Qwenを使用するかどうか | `true`または`false` | ✅ はい | +| `deepseek_key` | DeepSeek APIキー | `"sk-xxx"` | DeepSeek使用時 | +| `qwen_key` | Qwen APIキー | `"sk-xxx"` | Qwen使用時 | +| `initial_balance` | 損益計算の開始残高 | `1000.0` | ✅ はい | +| `scan_interval_minutes` | 判断を行う頻度 | `3`（3-5推奨） | ✅ はい | +| **`leverage`** | **レバレッジ設定（v2.0.3+）** | 下記参照 | ✅ はい | +| `btc_eth_leverage` | BTC/ETHの最大レバレッジ
⚠️ サブアカウント：≤5x | `5`（デフォルト、安全）
`50`（メインアカウント最大） | ✅ はい | +| `altcoin_leverage` | アルトコインの最大レバレッジ
⚠️ サブアカウント：≤5x | `5`（デフォルト、安全）
`20`（メインアカウント最大） | ✅ はい | +| `use_default_coins` | 組み込みコインリストを使用
**✨ スマートデフォルト：`true`**（v2.0.2+）
API URLが提供されていない場合自動有効化 | `true`または省略 | ❌ いいえ
（オプション、自動デフォルト） | +| `coin_pool_api_url` | カスタムコインプールAPI
*`use_default_coins: false`の場合のみ必要* | `""`（空） | ❌ いいえ | +| `oi_top_api_url` | 建玉API
*オプション補足データ* | `""`（空） | ❌ いいえ | +| `api_server_port` | Webダッシュボードポート | `8080` | ✅ はい | + +**デフォルト取引コイン**（`use_default_coins: true`の場合）： +- BTC、ETH、SOL、BNB、XRP、DOGE、ADA、HYPE + +--- + +#### ⚙️ レバレッジ設定（v2.0.3+） + +**レバレッジ設定とは？** + +レバレッジ設定は、AIが各取引で使用できる最大レバレッジを制御します。これは、特にレバレッジ制限があるBinanceサブアカウントでリスク管理に重要です。 + +**設定形式：** + +```json +"leverage": { + "btc_eth_leverage": 5, // BTCとETHの最大レバレッジ + "altcoin_leverage": 5 // その他すべてのコインの最大レバレッジ +} +``` + +**⚠️ 重要：Binanceサブアカウント制限** + +- **サブアカウント**: Binanceにより**≤5xレバレッジ**に制限 +- **メインアカウント**: 最大20x（アルトコイン）または50x（BTC/ETH）を使用可能 +- サブアカウントを使用していてレバレッジを>5xに設定すると、取引は**失敗**し、エラーが表示されます：`Subaccounts are restricted from using leverage greater than 5x` + +**推奨設定：** + +| アカウントタイプ | BTC/ETHレバレッジ | アルトコインレバレッジ | リスクレベル | +|-------------|------------------|------------------|------------| +| **サブアカウント** | `5` | `5` | ✅ 安全（デフォルト） | +| **メイン（保守的）** | `10` | `10` | 🟡 中程度 | +| **メイン（積極的）** | `20` | `15` | 🔴 高 | +| **メイン（最大）** | `50` | `20` | 🔴🔴 非常に高 | + +**例：** + +**安全な設定（サブアカウントまたは保守的）：** +```json +"leverage": { + "btc_eth_leverage": 5, + "altcoin_leverage": 5 +} +``` + +**積極的な設定（メインアカウントのみ）：** +```json +"leverage": { + "btc_eth_leverage": 20, + "altcoin_leverage": 15 +} +``` + +**AIのレバレッジ使用方法：** + +- AIは設定された最大値まで**1xから任意のレバレッジを選択**できます +- たとえば、`altcoin_leverage: 20`の場合、AIは市場条件に基づいて5x、10x、または20xを使用することを決定する可能性があります +- 設定は固定値ではなく**上限**を設定します +- AIはレバレッジを選択する際にボラティリティ、リスクリワード比率、アカウント残高を考慮します + +--- + +#### ⚠️ 重要：`use_default_coins`フィールド + +**スマートデフォルト動作（v2.0.2+）：** + +次の場合、システムは自動的に`use_default_coins: true`をデフォルトにします： +- config.jsonにこのフィールドを含めていない、または +- `false`に設定したが`coin_pool_api_url`を提供していない + +これにより初心者に優しくなります！このフィールドを完全に省略することもできます。 + +**設定例：** + +✅ **オプション1：明示的に設定（明確性のため推奨）** +```json +"use_default_coins": true, +"coin_pool_api_url": "", +"oi_top_api_url": "" +``` + +✅ **オプション2：フィールドを省略（デフォルトコインを自動使用）** +```json +// "use_default_coins"を含めないだけ +"coin_pool_api_url": "", +"oi_top_api_url": "" +``` + +⚙️ **高度：外部APIを使用** +```json +"use_default_coins": false, +"coin_pool_api_url": "http://your-api.com/coins", +"oi_top_api_url": "http://your-api.com/oi" +``` + +--- + +### 6. システムを実行 + +#### 🚀 システムの起動（2ステップ） + +システムには別々に実行される**2つの部分**があります： +1. **バックエンド**（AIトレーディングブレイン + API） +2. **フロントエンド**（監視用Webダッシュボード） + +--- + +#### **ステップ1：バックエンドを起動** + +ターミナルを開いて実行： + +```bash +# プログラムをビルド（初回のみ、またはコード変更後） +go build -o nofx + +# バックエンドを起動 +./nofx +``` + +**表示されるべきもの：** + +``` +🚀 启动自动交易系统... +✓ Trader [my_trader] 已初始化 +✓ API服务器启动在端口 8080 +📊 开始交易监控... +``` + +**⚠️ エラーが表示される場合：** + +| エラーメッセージ | 解決策 | +|--------------|----------| +| `invalid API key` | config.jsonのBinance APIキーを確認 | +| `TA-Lib not found` | `brew install ta-lib`を実行（macOS） | +| `port 8080 already in use` | config.jsonの`api_server_port`を変更 | +| `DeepSeek API error` | DeepSeek APIキーと残高を確認 | + +**✅ バックエンドが正しく実行されているとき：** +- エラーメッセージなし +- "开始交易监控..."が表示される +- システムがアカウント残高を表示 +- このターミナルウィンドウを開いたままにしてください！ + +--- + +#### **ステップ2：フロントエンドを起動** + +**新しいターミナルウィンドウ**を開き（最初のものは実行したまま）、次を実行： + +```bash +cd web +npm run dev +``` + +**表示されるべきもの：** + +``` +VITE v5.x.x ready in xxx ms + +➜ Local: http://localhost:3000/ +➜ Network: use --host to expose +``` + +**✅ フロントエンドが実行されているとき：** +- "Local: http://localhost:3000/"メッセージ +- エラーメッセージなし +- このターミナルウィンドウも開いたままにしてください！ + +--- + +#### **ステップ3：ダッシュボードにアクセス** + +Webブラウザを開いて次にアクセス： + +**🌐 http://localhost:3000** + +**表示されるもの：** +- 📊 リアルタイムアカウント残高 +- 📈 オープンポジション（ある場合） +- 🤖 AI判断ログ +- 📉 エクイティカーブチャート + +**初回のヒント：** +- 最初のAI判断まで3-5分かかることがあります +- 初期判断は「観望」（待機）と言う場合があります - これは正常です +- AIは最初に市場状況を分析する必要があります + +--- + +### 7. システムを監視 + +**監視すべきもの：** + +✅ **健全なシステムの兆候：** +- バックエンドターミナルが3-5分ごとに判断サイクルを表示 +- 継続的なエラーメッセージなし +- アカウント残高の更新 +- Webダッシュボードの自動更新 + +⚠️ **警告の兆候：** +- 繰り返されるAPIエラー +- 10分以上判断なし +- 残高の急速な減少 + +**システムステータスの確認：** + +```bash +# 新しいターミナルウィンドウで +curl http://localhost:8080/health +``` + +戻り値：`{"status":"ok"}` + +--- + +### 8. システムを停止 + +**グレースフルシャットダウン（推奨）：** + +1. **バックエンドターミナル**（最初のもの）に移動 +2. `Ctrl+C`を押す +3. "系统已停止"メッセージを待つ +4. **フロントエンドターミナル**（2番目のもの）に移動 +5. `Ctrl+C`を押す + +**⚠️ 重要：** +- 常にバックエンドを最初に停止 +- ターミナルを閉じる前に確認を待つ +- 強制終了しない（ターミナルを直接閉じない） + +--- + +## 📖 AI判断フロー + +各判断サイクル（デフォルト3分）で、システムは以下のインテリジェントプロセスを実行します： + +``` +┌──────────────────────────────────────────────────────────┐ +│ 1. 📊 過去パフォーマンスを分析（過去20サイクル） │ +├──────────────────────────────────────────────────────────┤ +│ ✓ 総合勝率、平均利益、損益比を計算 │ +│ ✓ コインごとの統計（勝率、平均損益（USDT）） │ +│ ✓ 最高/最悪パフォーマンスコインを特定 │ +│ ✓ 正確なPnLを含む最後の5取引の詳細をリスト │ +│ ✓ リスク調整パフォーマンスのシャープレシオを計算 │ +│ 📌 NEW（v2.0.2）：レバレッジを含む正確なUSDT PnL │ +└──────────────────────────────────────────────────────────┘ + ↓ +┌──────────────────────────────────────────────────────────┐ +│ 2. 💰 アカウントステータスを取得 │ +├──────────────────────────────────────────────────────────┤ +│ • 総エクイティと利用可能残高 │ +│ • オープンポジション数と未実現損益 │ +│ • 証拠金使用率（AIは最大90%を管理） │ +│ • 日次損益追跡とドローダウン監視 │ +└──────────────────────────────────────────────────────────┘ + ↓ +┌──────────────────────────────────────────────────────────┐ +│ 3. 🔍 既存ポジションを分析（ある場合） │ +├──────────────────────────────────────────────────────────┤ +│ • 各ポジションについて、最新の市場データを取得 │ +│ • リアルタイムのテクニカル指標を計算： │ +│ - 3分K線：RSI(7)、MACD、EMA20 │ +│ - 4時間K線：RSI(14)、EMA20/50、ATR │ +│ • ポジション保有期間を追跡（例：「2時間15分」） │ +│ 📌 NEW（v2.0.2）：各ポジションの保有期間を表示 │ +│ • 表示：エントリー価格、現在価格、損益%、期間 │ +│ • AIが評価：保持するかクローズするか？ │ +└──────────────────────────────────────────────────────────┘ + ↓ +┌──────────────────────────────────────────────────────────┐ +│ 4. 🎯 新しい機会を評価（候補コイン） │ +├──────────────────────────────────────────────────────────┤ +│ • コインプールを取得（2モード）： │ +│ 🌟 デフォルトモード：BTC、ETH、SOL、BNB、XRPなど │ +│ ⚙️ 高度モード：AI500（上位20）+ OI Top（上位20） │ +│ • 候補コインをマージして重複削除 │ +│ • フィルター：低流動性を削除（<1500万USD OI値） │ +│ • 市場データ + テクニカル指標をバッチ取得 │ +│ • ボラティリティ、トレンド強度、出来高急増を計算 │ +└──────────────────────────────────────────────────────────┘ + ↓ +┌──────────────────────────────────────────────────────────┐ +│ 5. 🧠 AI総合判断（DeepSeek/Qwen） │ +├──────────────────────────────────────────────────────────┤ +│ • 過去フィードバックをレビュー： │ +│ - 最近の勝率と利益率 │ +│ - 最高/最悪コインパフォーマンス │ +│ - 繰り返しミスを回避 │ +│ • すべての生シーケンスデータを分析： │ +│ - 3分価格シーケンス、4時間K線シーケンス │ +│ - 完全な指標シーケンス（最新のみではない） │ +│ 📌 NEW（v2.0.2）：AIは分析の完全な自由を持つ │ +│ • 思考連鎖（CoT）推論プロセス │ +│ • 構造化された判断を出力： │ +│ - アクション：close_long/close_short/open_long/open_short│ +│ - コインシンボル、数量、レバレッジ │ +│ - ストップロスとテイクプロフィットレベル（≥1:2比率） │ +│ • 判断：待機/保持/クローズ/オープン │ +└──────────────────────────────────────────────────────────┘ + ↓ +┌──────────────────────────────────────────────────────────┐ +│ 6. ⚡ 取引を実行 │ +├──────────────────────────────────────────────────────────┤ +│ • 優先順位：既存をクローズ → その後新規をオープン │ +│ • 実行前のリスクチェック： │ +│ - ポジションサイズ制限（アルトコイン1.5x、BTC 10x） │ +│ - 重複ポジションなし（同じコイン + 方向） │ +│ - 証拠金使用量が90%制限内 │ +│ • Binance LOT_SIZE精度を自動取得して適用 │ +│ • Binance Futures APIで注文を実行 │ +│ • クローズ後：すべての保留注文を自動キャンセル │ +│ • 実際の実行価格と注文IDを記録 │ +│ 📌 期間計算のためにポジションオープン時間を追跡 │ +└──────────────────────────────────────────────────────────┘ + ↓ +┌──────────────────────────────────────────────────────────┐ +│ 7. 📝 完全なログを記録してパフォーマンスを更新 │ +├──────────────────────────────────────────────────────────┤ +│ • decision_logs/{trader_id}/に判断ログを保存 │ +│ • ログには以下が含まれます： │ +│ - 完全な思考連鎖（CoT） │ +│ - すべての市場データを含む入力プロンプト │ +│ - 構造化された判断JSON │ +│ - アカウントスナップショット（残高、ポジション、証拠金）│ +│ - 実行結果（成功/失敗、価格） │ +│ • パフォーマンスデータベースを更新： │ +│ - symbol_sideキーでオープン/クローズペアをマッチ │ +│ 📌 NEW：ロング/ショート競合を防止 │ +│ - 正確なUSDT PnLを計算： │ +│ PnL = ポジション価値 × 価格変化% × レバレッジ │ +│ 📌 NEW：数量 + レバレッジを考慮 │ +│ - 保存：数量、レバレッジ、オープン時間、クローズ時間 │ +│ - 更新：勝率、利益率、シャープレシオ │ +│ • パフォーマンスデータは次のサイクルにフィードバック │ +└──────────────────────────────────────────────────────────┘ + ↓ + （3-5分ごとに繰り返し） +``` + +### v2.0.2の主な改善点 + +**📌 ポジション期間追跡：** +- システムが各ポジションの保有期間を追跡 +- ユーザープロンプトに表示：「持仓时长2小时15分钟」 +- AIが出口タイミングについてより良い判断を下すのに役立つ + +**📌 正確なPnL計算：** +- 以前：パーセンテージのみ（100U@5% = 1000U@5% = 両方とも「5.0」と表示） +- 現在：実際のUSDT利益 = ポジション価値 × 価格変化 × レバレッジ +- 例：1000 USDT × 5% × 20x = 1000 USDT実際の利益 + +**📌 AI自由度の向上：** +- AIはすべての生シーケンスデータを自由に分析可能 +- 事前定義された指標の組み合わせに制限されない +- 独自のトレンド分析、サポート/レジスタンス計算を実行可能 + +**📌 改善されたポジション追跡：** +- `symbol_side`キーを使用（例：「BTCUSDT_long」） +- ロングとショートの両方を保有する際の競合を防止 +- 完全なデータを保存：数量、レバレッジ、オープン/クローズ時間 + +--- + +## 🧠 AI自己学習の例 + +### 過去フィードバック（プロンプトに自動追加） + +```markdown +## 📊 過去パフォーマンスフィードバック + +### 総合パフォーマンス +- **総取引数**: 15（利益：8 | 損失：7） +- **勝率**: 53.3% +- **平均利益**: +3.2% | 平均損失：-2.1% +- **損益比**: 1.52:1 + +### 最近の取引 +1. BTCUSDT LONG: 95000.0000 → 97500.0000 = +2.63% ✓ +2. ETHUSDT SHORT: 3500.0000 → 3450.0000 = +1.43% ✓ +3. SOLUSDT LONG: 185.0000 → 180.0000 = -2.70% ✗ +4. BNBUSDT LONG: 610.0000 → 625.0000 = +2.46% ✓ +5. ADAUSDT LONG: 0.8500 → 0.8300 = -2.35% ✗ + +### コインパフォーマンス +- **最高**: BTCUSDT（勝率75%、平均+2.5%） +- **最悪**: SOLUSDT（勝率25%、平均-1.8%） +``` + +### AIのフィードバック使用方法 + +1. **連続損失を回避**: SOLUSDTが3回連続でストップロスになっているのを見て、AIは回避するかより慎重になる +2. **成功戦略を強化**: BTCブレイクアウトロングが75%の勝率で、AIはこのパターンを継続 +3. **動的スタイル調整**: 勝率<40% → 保守的；損益比>2 → 積極的を維持 +4. **市場状況の特定**: 連続損失は荒れた市場を示す可能性があり、取引頻度を減らす + +--- + +## 📊 Webインターフェース機能 + +### 1. 競争ページ + +- **🏆 リーダーボード**: リアルタイムROIランキング、ゴールドボーダーでリーダーをハイライト +- **📈 パフォーマンス比較**: デュアルAI ROIカーブ比較（紫対青） +- **⚔️ 一対一**: リードマージンを示す直接比較 +- **リアルタイムデータ**: 総エクイティ、損益%、ポジション数、証拠金使用量 + +### 2. 詳細ページ + +- **エクイティカーブ**: 過去トレンドチャート（USD/パーセンテージ切り替え） +- **統計**: 総サイクル、成功/失敗、オープン/クローズ統計 +- **ポジションテーブル**: すべてのポジション詳細（エントリー価格、現在価格、損益%、清算価格） +- **AI判断ログ**: 最近の判断記録（展開可能なCoT） + +### 3. リアルタイム更新 + +- システムステータス、アカウント情報、ポジションリスト：**5秒更新** +- 判断ログ、統計：**10秒更新** +- エクイティチャート：**10秒更新** + +--- + +## 🎛️ APIエンドポイント + +### 競争関連 + +```bash +GET /api/competition # 競争リーダーボード（全トレーダー） +GET /api/traders # トレーダーリスト +``` + +### 単一トレーダー関連 + +```bash +GET /api/status?trader_id=xxx # システムステータス +GET /api/account?trader_id=xxx # アカウント情報 +GET /api/positions?trader_id=xxx # ポジションリスト +GET /api/equity-history?trader_id=xxx # エクイティ履歴（チャートデータ） +GET /api/decisions/latest?trader_id=xxx # 最新5判断 +GET /api/statistics?trader_id=xxx # 統計 +``` + +### システムエンドポイント + +```bash +GET /health # ヘルスチェック +GET /api/config # システム設定 +``` + +--- + +## ⚠️ 重要なリスク警告 + +### 取引リスク + +1. **暗号通貨市場は非常にボラティルが高い**、AI判断は利益を保証しません +2. **先物取引はレバレッジを使用**、損失が元本を超える可能性があります +3. **極端な市場状況**は清算リスクにつながる可能性があります +4. **ファンディングレート**は保有コストに影響する可能性があります +5. **流動性リスク**: 一部のコインでスリッページが発生する可能性があります + +### 技術リスク + +1. **ネットワークレイテンシ**は価格スリッページを引き起こす可能性があります +2. **APIレート制限**は取引実行に影響する可能性があります +3. **AI APIタイムアウト**は判断失敗を引き起こす可能性があります +4. **システムバグ**は予期しない動作を引き起こす可能性があります + +### 使用推奨事項 + +✅ **推奨** +- テストには失っても構わない資金のみを使用 +- 少額から始める（推奨100-500 USDT） +- システムの動作状態を定期的に確認 +- アカウント残高の変化を監視 +- AI判断ログを分析して戦略を理解 + +❌ **非推奨** +- すべての資金または借りたお金を投資 +- 長期間監視なしで実行 +- AI判断を盲目的に信頼 +- システムを理解せずに使用 +- 極端な市場ボラティリティ中に実行 + +--- + +## 🛠️ よくある問題 + +### 1. コンパイルエラー：TA-Libが見つからない + +**解決策**: TA-Libライブラリをインストール +```bash +# macOS +brew install ta-lib + +# Ubuntu +sudo apt-get install libta-lib0-dev +``` + +### 2. 精度エラー：Precision is over the maximum + +**解決策**: システムがBinance LOT_SIZEから精度を自動処理します。エラーが続く場合は、ネットワーク接続を確認してください。 + +### 3. AI APIタイムアウト + +**解決策**: +- APIキーが正しいか確認 +- ネットワーク接続を確認（プロキシが必要な場合があります） +- システムタイムアウトは120秒に設定されています + +### 4. フロントエンドがバックエンドに接続できない + +**解決策**: +- バックエンドが実行中であることを確認（http://localhost:8080） +- ポート8080が占有されていないか確認 +- ブラウザコンソールでエラーを確認 + +### 5. コインプールAPI失敗 + +**解決策**: +- コインプールAPIはオプションです +- APIが失敗した場合、システムはデフォルトのメインストリームコイン（BTC、ETHなど）を使用 +- config.jsonのAPI URLと認証パラメータを確認 + +--- + +## 📈 パフォーマンス最適化のヒント + +1. **合理的な判断サイクルを設定**: 3-5分を推奨、過剰取引を避ける +2. **候補コイン数を制御**: システムはデフォルトでAI500上位20 + OI Top上位20 +3. **ログを定期的にクリーン**: 過度なディスク使用を避ける +4. **API呼び出し数を監視**: Binanceレート制限のトリガーを避ける +5. **少額資本でテスト**: まず100-500 USDTで戦略検証をテスト + +--- + +## 🔄 変更履歴 + +### v2.0.2（2025-10-29） + +**重大なバグ修正 - 取引履歴とパフォーマンス分析：** + +このバージョンは、収益性統計に大きく影響した過去取引記録とパフォーマンス分析システムの**重大な計算エラー**を修正します。 + +**1. PnL計算 - 主要エラー修正**（logger/decision_logger.go） +- **問題**: 以前はパーセンテージのみで計算され、ポジションサイズとレバレッジを完全に無視 + - 例：100 USDTポジションが5%獲得と1000 USDTポジションが5%獲得の両方が利益として`5.0`と表示 + - これによりパフォーマンス分析が完全に不正確に +- **解決策**: 実際のUSDT利益額を計算 + ``` + PnL（USDT）= ポジション価値 × 価格変化% × レバレッジ + 例：1000 USDT × 5% × 20x = 1000 USDT実際の利益 + ``` +- **影響**: 勝率、利益率、シャープレシオが正確なUSDT額に基づくようになりました + +**2. ポジション追跡 - 重要データの欠落** +- **問題**: オープンポジション記録が価格と時間のみを保存、数量とレバレッジが欠落 +- **解決策**: 完全な取引データを保存： + - `quantity`: ポジションサイズ（コイン単位） + - `leverage`: レバレッジ倍率（例：20x） + - これらは正確なPnL計算に不可欠 + +**3. ポジションキーロジック - ロング/ショート競合** +- **問題**: `symbol`をポジションキーとして使用し、ロングとショートの両方を保有する際にデータ競合を引き起こす + - 例：BTCUSDTロングとBTCUSDTショートが互いに上書き +- **解決策**: `symbol_side`形式に変更（例：`BTCUSDT_long`、`BTCUSDT_short`） + - ロングとショートポジションを適切に区別 + +**4. シャープレシオ計算 - コード最適化** +- **問題**: 平方根計算にカスタムニュートン法を使用 +- **解決策**: 標準ライブラリ`math.Sqrt`に置き換え + - より信頼性が高く、保守可能で効率的 + +**このアップデートが重要な理由：** +- ✅ 過去取引統計が無意味なパーセンテージではなく**実際のUSDT損益**を表示 +- ✅ 異なるレバレッジ取引間のパフォーマンス比較が正確に +- ✅ AI自己学習メカニズムが正しい過去フィードバックを受信 +- ✅ 利益率とシャープレシオの計算が意味を持つように +- ✅ マルチポジション追跡（ロング + ショート同時）が正しく機能 + +**推奨**: このアップデート前にシステムを実行していた場合、過去統計は不正確でした。v2.0.2にアップデート後、新しい取引は正しく計算されます。 + +### v2.0.2（2025-10-29） + +**バグ修正：** +- ✅ Aster取引所精度エラーを修正（コード-1111：「Precision is over the maximum defined for this asset」） +- ✅ 取引所の精度要件に合わせて価格と数量のフォーマットを改善 +- ✅ デバッグ用の詳細な精度処理ログを追加 +- ✅ 適切な精度処理ですべての注文関数（OpenLong、OpenShort、CloseLong、CloseShort、SetStopLoss、SetTakeProfit）を強化 + +**技術詳細：** +- float64を正しい精度で文字列に変換する`formatFloatWithPrecision`関数を追加 +- 価格と数量パラメータが取引所の`pricePrecision`と`quantityPrecision`仕様に従ってフォーマットされるようになりました +- API リクエストを最適化するために、フォーマットされた値から末尾のゼロを削除 + +### v2.0.1（2025-10-29） + +**バグ修正：** +- ✅ ComparisonChartデータ処理ロジックを修正 - cycle_numberからタイムスタンプグループ化に切り替え +- ✅ バックエンド再起動時にcycle_numberがリセットされるとチャートがフリーズする問題を解決 +- ✅ チャートデータ表示を改善 - すべての過去データポイントを時系列で表示 +- ✅ トラブルシューティングを改善するためのデバッグログを強化 + +### v2.0.0（2025-10-28） + +**主要アップデート：** +- ✅ AI自己学習メカニズム（過去フィードバック、パフォーマンス分析） +- ✅ マルチトレーダー競争モード（Qwen対DeepSeek） +- ✅ BinanceスタイルUI（完全なBinanceインターフェース模倣） +- ✅ パフォーマンス比較チャート（リアルタイムROI比較） +- ✅ リスク管理最適化（コインごとのポジション制限調整） + +**バグ修正：** +- 初期残高のハードコーディング問題を修正 +- マルチトレーダーデータ同期問題を修正 +- チャートデータの整列を最適化（cycle_numberを使用） + +### v1.0.0（2025-10-27） +- 初回リリース +- 基本的なAI取引機能 +- 判断ログシステム +- シンプルなWebインターフェース + +--- + +## 📄 ライセンス + +MITライセンス - 詳細は[LICENSE](LICENSE)ファイルを参照してください + +--- + +## 🤝 貢献 + +IssueとPull Requestを歓迎します！ + +### 開発ガイド + +1. プロジェクトをフォーク +2. 機能ブランチを作成（`git checkout -b feature/AmazingFeature`） +3. 変更をコミット（`git commit -m 'Add some AmazingFeature'`） +4. ブランチにプッシュ（`git push origin feature/AmazingFeature`） +5. Pull Requestを開く + +--- + +## 📬 お問い合わせ + + +### 🐛 技術サポート +- **GitHub Issues**: [Issueを提出](https://github.com/tinkle-community/nofx/issues) +- **開発者コミュニティ**: [Telegramグループ](https://t.me/nofx_dev_community) + +--- + +## 🙏 謝辞 + +- [Binance API](https://binance-docs.github.io/apidocs/futures/en/) - Binance先物API +- [DeepSeek](https://platform.deepseek.com/) - DeepSeek AI API +- [Qwen](https://dashscope.aliyuncs.com/) - Alibaba Cloud Qwen +- [TA-Lib](https://ta-lib.org/) - テクニカル指標ライブラリ +- [Recharts](https://recharts.org/) - Reactチャートライブラリ + +--- + +**最終更新**: 2025-10-29（v2.0.3） + +**⚡ AIの力で量的取引の可能性を探求しましょう！** + +--- + +## ⭐ Star履歴 + +[](https://star-history.com/#tinkle-community/nofx&Date) diff --git a/README.md b/README.md index f76b9067..ad86dfa6 100644 --- a/README.md +++ b/README.md @@ -3,14 +3,14 @@ [](https://golang.org/) [](https://reactjs.org/) [](https://www.typescriptlang.org/) -[](LICENSE) +[](LICENSE) [](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. --- diff --git a/api/crypto_handler.go b/api/crypto_handler.go new file mode 100644 index 00000000..f5a5890b --- /dev/null +++ b/api/crypto_handler.go @@ -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 +} diff --git a/api/register_otp_test.go b/api/register_otp_test.go new file mode 100644 index 00000000..dcd13288 --- /dev/null +++ b/api/register_otp_test.go @@ -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) + }) + } +} diff --git a/api/server.go b/api/server.go index 94ae4a60..b3f67f11 100644 --- a/api/server.go +++ b/api/server.go @@ -1,14 +1,19 @@ package api import ( + "context" "encoding/json" "fmt" "log" + "net" "net/http" "nofx/auth" "nofx/config" + "nofx/crypto" "nofx/decision" + "nofx/hook" "nofx/manager" + "nofx/trader" "strconv" "strings" "time" @@ -20,13 +25,15 @@ import ( // Server HTTP API服务器 type Server struct { router *gin.Engine + httpServer *http.Server traderManager *manager.TraderManager database *config.Database + cryptoHandler *CryptoHandler port int } // NewServer 创建API服务器 -func NewServer(traderManager *manager.TraderManager, database *config.Database, port int) *Server { +func NewServer(traderManager *manager.TraderManager, database *config.Database, cryptoService *crypto.CryptoService, port int) *Server { // 设置为Release模式（减少日志输出） gin.SetMode(gin.ReleaseMode) @@ -35,10 +42,14 @@ func NewServer(traderManager *manager.TraderManager, database *config.Database, // 启用CORS router.Use(corsMiddleware()) + // 创建加密处理器 + cryptoHandler := NewCryptoHandler(cryptoService) + s := &Server{ router: router, traderManager: traderManager, database: database, + cryptoHandler: cryptoHandler, port: port, } @@ -72,23 +83,23 @@ func (s *Server) setupRoutes() { // 健康检查 api.Any("/health", s.handleHealth) - // 认证相关路由（无需认证） - api.POST("/register", s.handleRegister) - api.POST("/login", s.handleLogin) - api.POST("/verify-otp", s.handleVerifyOTP) - api.POST("/complete-registration", s.handleCompleteRegistration) + // 管理员登录（管理员模式下使用，公共） // 系统支持的模型和交易所（无需认证） api.GET("/supported-models", s.handleGetSupportedModels) api.GET("/supported-exchanges", s.handleGetSupportedExchanges) - // 系统配置（无需认证） + // 系统配置（无需认证，用于前端判断是否管理员模式/注册是否开启） api.GET("/config", s.handleGetSystemConfig) + // 加密相关接口（无需认证） + api.GET("/crypto/public-key", s.cryptoHandler.HandleGetPublicKey) + api.POST("/crypto/decrypt", s.cryptoHandler.HandleDecryptSensitiveData) + // 系统提示词模板管理（无需认证） api.GET("/prompt-templates", s.handleGetPromptTemplates) api.GET("/prompt-templates/:name", s.handleGetPromptTemplate) - + // 公开的竞赛数据（无需认证） api.GET("/traders", s.handlePublicTraderList) api.GET("/competition", s.handlePublicCompetition) @@ -97,9 +108,21 @@ func (s *Server) setupRoutes() { api.POST("/equity-history-batch", s.handleEquityHistoryBatch) api.GET("/traders/:id/public-config", s.handleGetPublicTraderConfig) + // 认证相关路由（无需认证） + api.POST("/register", s.handleRegister) + api.POST("/login", s.handleLogin) + api.POST("/verify-otp", s.handleVerifyOTP) + api.POST("/complete-registration", s.handleCompleteRegistration) + // 需要认证的路由 protected := api.Group("/", s.authMiddleware()) { + // 注销（加入黑名单） + protected.POST("/logout", s.handleLogout) + + // 服务器IP查询（需要认证，用于白名单配置） + protected.GET("/server-ip", s.handleGetServerIP) + // AI交易员管理 protected.GET("/my-traders", s.handleTraderList) protected.GET("/traders/:id/config", s.handleGetTraderConfig) @@ -109,6 +132,7 @@ func (s *Server) setupRoutes() { protected.POST("/traders/:id/start", s.handleStartTrader) protected.POST("/traders/:id/stop", s.handleStopTrader) protected.PUT("/traders/:id/prompt", s.handleUpdateTraderPrompt) + protected.POST("/traders/:id/sync-balance", s.handleSyncBalance) // AI模型配置 protected.GET("/models", s.handleGetModelConfigs) @@ -168,13 +192,12 @@ func (s *Server) handleGetSystemConfig(c *gin.Context) { if val, err := strconv.Atoi(altcoinLeverageStr); err == nil && val > 0 { altcoinLeverage = val } - + // 获取内测模式配置 betaModeStr, _ := s.database.GetSystemConfig("beta_mode") betaMode := betaModeStr == "true" c.JSON(http.StatusOK, gin.H{ - "admin_mode": auth.IsAdminMode(), "beta_mode": betaMode, "default_coins": defaultCoins, "btc_eth_leverage": btcEthLeverage, @@ -182,6 +205,144 @@ func (s *Server) handleGetSystemConfig(c *gin.Context) { }) } +// handleGetServerIP 获取服务器IP地址（用于白名单配置） +func (s *Server) handleGetServerIP(c *gin.Context) { + + // 首先尝试从Hook获取用户专用IP + userIP := hook.HookExec[hook.IpResult](hook.GETIP, c.GetString("user_id")) + if userIP != nil && userIP.Error() == nil { + c.JSON(http.StatusOK, gin.H{ + "public_ip": userIP.GetResult(), + "message": "请将此IP地址添加到白名单中", + }) + return + } + + // 尝试通过第三方API获取公网IP + publicIP := getPublicIPFromAPI() + + // 如果第三方API失败，从网络接口获取第一个公网IP + if publicIP == "" { + publicIP = getPublicIPFromInterface() + } + + // 如果还是没有获取到，返回错误 + if publicIP == "" { + c.JSON(http.StatusInternalServerError, gin.H{"error": "无法获取公网IP地址"}) + return + } + + c.JSON(http.StatusOK, gin.H{ + "public_ip": publicIP, + "message": "请将此IP地址添加到白名单中", + }) +} + +// getPublicIPFromAPI 通过第三方API获取公网IP +func getPublicIPFromAPI() string { + // 尝试多个公网IP查询服务 + services := []string{ + "https://api.ipify.org?format=text", + "https://icanhazip.com", + "https://ifconfig.me", + } + + client := &http.Client{ + Timeout: 5 * time.Second, + } + + for _, service := range services { + resp, err := client.Get(service) + if err != nil { + continue + } + defer resp.Body.Close() + + if resp.StatusCode == http.StatusOK { + body := make([]byte, 128) + n, err := resp.Body.Read(body) + if err != nil && err.Error() != "EOF" { + continue + } + + ip := strings.TrimSpace(string(body[:n])) + // 验证是否为有效的IP地址 + if net.ParseIP(ip) != nil { + return ip + } + } + } + + return "" +} + +// getPublicIPFromInterface 从网络接口获取第一个公网IP +func getPublicIPFromInterface() string { + interfaces, err := net.Interfaces() + if err != nil { + return "" + } + + for _, iface := range interfaces { + // 跳过未启用的接口和回环接口 + if iface.Flags&net.FlagUp == 0 || iface.Flags&net.FlagLoopback != 0 { + continue + } + + addrs, err := iface.Addrs() + if err != nil { + continue + } + + for _, addr := range addrs { + var ip net.IP + switch v := addr.(type) { + case *net.IPNet: + ip = v.IP + case *net.IPAddr: + ip = v.IP + } + + if ip == nil || ip.IsLoopback() { + continue + } + + // 只考虑IPv4地址 + if ip.To4() != nil { + ipStr := ip.String() + // 排除私有IP地址范围 + if !isPrivateIP(ip) { + return ipStr + } + } + } + } + + return "" +} + +// isPrivateIP 判断是否为私有IP地址 +func isPrivateIP(ip net.IP) bool { + // 私有IP地址范围： + // 10.0.0.0/8 + // 172.16.0.0/12 + // 192.168.0.0/16 + privateRanges := []string{ + "10.0.0.0/8", + "172.16.0.0/12", + "192.168.0.0/16", + } + + for _, cidr := range privateRanges { + _, subnet, _ := net.ParseCIDR(cidr) + if subnet.Contains(ip) { + return true + } + } + + return false +} + // getTraderFromQuery 从query参数获取trader func (s *Server) getTraderFromQuery(c *gin.Context) (*manager.TraderManager, string, error) { userID := c.GetString("user_id") @@ -239,6 +400,16 @@ type ModelConfig struct { CustomAPIURL string `json:"customApiUrl,omitempty"` } +// SafeModelConfig 安全的模型配置结构（不包含敏感信息） +type SafeModelConfig struct { + ID string `json:"id"` + Name string `json:"name"` + Provider string `json:"provider"` + Enabled bool `json:"enabled"` + CustomAPIURL string `json:"customApiUrl"` // 自定义API URL（通常不敏感） + CustomModelName string `json:"customModelName"` // 自定义模型名（不敏感） +} + type ExchangeConfig struct { ID string `json:"id"` Name string `json:"name"` @@ -249,6 +420,18 @@ type ExchangeConfig struct { Testnet bool `json:"testnet,omitempty"` } +// SafeExchangeConfig 安全的交易所配置结构（不包含敏感信息） +type SafeExchangeConfig struct { + ID string `json:"id"` + Name string `json:"name"` + Type string `json:"type"` // "cex" or "dex" + Enabled bool `json:"enabled"` + Testnet bool `json:"testnet,omitempty"` + HyperliquidWalletAddr string `json:"hyperliquidWalletAddr"` // Hyperliquid钱包地址（不敏感） + AsterUser string `json:"asterUser"` // Aster用户名（不敏感） + AsterSigner string `json:"asterSigner"` // Aster签名者（不敏感） +} + type UpdateModelConfigRequest struct { Models map[string]struct { Enabled bool `json:"enabled"` @@ -343,8 +526,75 @@ func (s *Server) handleCreateTrader(c *gin.Context) { // 设置扫描间隔默认值 scanIntervalMinutes := req.ScanIntervalMinutes - if scanIntervalMinutes <= 0 { - scanIntervalMinutes = 3 // 默认3分钟 + if scanIntervalMinutes < 3 { + scanIntervalMinutes = 3 // 默认3分钟，且不允许小于3 + } + + // ✨ 查询交易所实际余额，覆盖用户输入 + actualBalance := req.InitialBalance // 默认使用用户输入 + exchanges, err := s.database.GetExchanges(userID) + if err != nil { + log.Printf("⚠️ 获取交易所配置失败，使用用户输入的初始资金: %v", err) + } + + // 查找匹配的交易所配置 + var exchangeCfg *config.ExchangeConfig + for _, ex := range exchanges { + if ex.ID == req.ExchangeID { + exchangeCfg = ex + break + } + } + + if exchangeCfg == nil { + log.Printf("⚠️ 未找到交易所 %s 的配置，使用用户输入的初始资金", req.ExchangeID) + } else if !exchangeCfg.Enabled { + log.Printf("⚠️ 交易所 %s 未启用，使用用户输入的初始资金", req.ExchangeID) + } else { + // 根据交易所类型创建临时 trader 查询余额 + var tempTrader trader.Trader + var createErr error + + switch req.ExchangeID { + case "binance": + tempTrader = trader.NewFuturesTrader(exchangeCfg.APIKey, exchangeCfg.SecretKey, userID) + case "hyperliquid": + tempTrader, createErr = trader.NewHyperliquidTrader( + exchangeCfg.APIKey, // private key + exchangeCfg.HyperliquidWalletAddr, + exchangeCfg.Testnet, + ) + case "aster": + tempTrader, createErr = trader.NewAsterTrader( + exchangeCfg.AsterUser, + exchangeCfg.AsterSigner, + exchangeCfg.AsterPrivateKey, + ) + default: + log.Printf("⚠️ 不支持的交易所类型: %s，使用用户输入的初始资金", req.ExchangeID) + } + + if createErr != nil { + log.Printf("⚠️ 创建临时 trader 失败，使用用户输入的初始资金: %v", createErr) + } else if tempTrader != nil { + // 查询实际余额 + balanceInfo, balanceErr := tempTrader.GetBalance() + if balanceErr != nil { + log.Printf("⚠️ 查询交易所余额失败，使用用户输入的初始资金: %v", balanceErr) + } else { + // 提取可用余额 + if availableBalance, ok := balanceInfo["available_balance"].(float64); ok && availableBalance > 0 { + actualBalance = availableBalance + log.Printf("✓ 查询到交易所实际余额: %.2f USDT (用户输入: %.2f USDT)", actualBalance, req.InitialBalance) + } else if totalBalance, ok := balanceInfo["balance"].(float64); ok && totalBalance > 0 { + // 有些交易所可能只返回 balance 字段 + actualBalance = totalBalance + log.Printf("✓ 查询到交易所实际余额: %.2f USDT (用户输入: %.2f USDT)", actualBalance, req.InitialBalance) + } else { + log.Printf("⚠️ 无法从余额信息中提取可用余额，使用用户输入的初始资金") + } + } + } } // 创建交易员配置（数据库实体） @@ -354,7 +604,7 @@ func (s *Server) handleCreateTrader(c *gin.Context) { Name: req.Name, AIModelID: req.AIModelID, ExchangeID: req.ExchangeID, - InitialBalance: req.InitialBalance, + InitialBalance: actualBalance, // 使用实际查询的余额 BTCETHLeverage: btcEthLeverage, AltcoinLeverage: altcoinLeverage, TradingSymbols: req.TradingSymbols, @@ -369,16 +619,16 @@ func (s *Server) handleCreateTrader(c *gin.Context) { } // 保存到数据库 - err := s.database.CreateTrader(trader) + err = s.database.CreateTrader(trader) if err != nil { c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("创建交易员失败: %v", err)}) return } // 立即将新交易员加载到TraderManager中 - err = s.traderManager.LoadUserTraders(s.database, userID) + err = s.traderManager.LoadTraderByID(s.database, userID, traderID) if err != nil { - log.Printf("⚠️ 加载用户交易员到内存失败: %v", err) + log.Printf("⚠️ 加载交易员到内存失败: %v", err) // 这里不返回错误，因为交易员已经成功创建到数据库 } @@ -394,17 +644,18 @@ func (s *Server) handleCreateTrader(c *gin.Context) { // UpdateTraderRequest 更新交易员请求 type UpdateTraderRequest struct { - Name string `json:"name" binding:"required"` - AIModelID string `json:"ai_model_id" binding:"required"` - ExchangeID string `json:"exchange_id" binding:"required"` - InitialBalance float64 `json:"initial_balance"` - ScanIntervalMinutes int `json:"scan_interval_minutes"` - BTCETHLeverage int `json:"btc_eth_leverage"` - AltcoinLeverage int `json:"altcoin_leverage"` - TradingSymbols string `json:"trading_symbols"` - CustomPrompt string `json:"custom_prompt"` - OverrideBasePrompt bool `json:"override_base_prompt"` - IsCrossMargin *bool `json:"is_cross_margin"` + Name string `json:"name" binding:"required"` + AIModelID string `json:"ai_model_id" binding:"required"` + ExchangeID string `json:"exchange_id" binding:"required"` + InitialBalance float64 `json:"initial_balance"` + ScanIntervalMinutes int `json:"scan_interval_minutes"` + BTCETHLeverage int `json:"btc_eth_leverage"` + AltcoinLeverage int `json:"altcoin_leverage"` + TradingSymbols string `json:"trading_symbols"` + CustomPrompt string `json:"custom_prompt"` + OverrideBasePrompt bool `json:"override_base_prompt"` + SystemPromptTemplate string `json:"system_prompt_template"` + IsCrossMargin *bool `json:"is_cross_margin"` } // handleUpdateTrader 更新交易员配置 @@ -458,6 +709,14 @@ func (s *Server) handleUpdateTrader(c *gin.Context) { scanIntervalMinutes := req.ScanIntervalMinutes if scanIntervalMinutes <= 0 { scanIntervalMinutes = existingTrader.ScanIntervalMinutes // 保持原值 + } else if scanIntervalMinutes < 3 { + scanIntervalMinutes = 3 + } + + // 设置提示词模板，允许更新 + systemPromptTemplate := req.SystemPromptTemplate + if systemPromptTemplate == "" { + systemPromptTemplate = existingTrader.SystemPromptTemplate // 如果请求中没有提供，保持原值 } // 更新交易员配置 @@ -473,7 +732,7 @@ func (s *Server) handleUpdateTrader(c *gin.Context) { TradingSymbols: req.TradingSymbols, CustomPrompt: req.CustomPrompt, OverrideBasePrompt: req.OverrideBasePrompt, - SystemPromptTemplate: existingTrader.SystemPromptTemplate, // 保持原值 + SystemPromptTemplate: systemPromptTemplate, IsCrossMargin: isCrossMargin, ScanIntervalMinutes: scanIntervalMinutes, IsRunning: existingTrader.IsRunning, // 保持原值 @@ -487,9 +746,9 @@ func (s *Server) handleUpdateTrader(c *gin.Context) { } // 重新加载交易员到内存 - err = s.traderManager.LoadUserTraders(s.database, userID) + err = s.traderManager.LoadTraderByID(s.database, userID, traderID) if err != nil { - log.Printf("⚠️ 重新加载用户交易员到内存失败: %v", err) + log.Printf("⚠️ 重新加载交易员到内存失败: %v", err) } log.Printf("✓ 更新交易员成功: %s (模型: %s, 交易所: %s)", req.Name, req.AIModelID, req.ExchangeID) @@ -531,14 +790,17 @@ func (s *Server) handleDeleteTrader(c *gin.Context) { func (s *Server) handleStartTrader(c *gin.Context) { userID := c.GetString("user_id") traderID := c.Param("id") - + // 校验交易员是否属于当前用户 - _, _, _, err := s.database.GetTraderConfig(userID, traderID) + traderRecord, _, _, err := s.database.GetTraderConfig(userID, traderID) if err != nil { c.JSON(http.StatusNotFound, gin.H{"error": "交易员不存在或无访问权限"}) return } - + + // 获取模板名称 + templateName := traderRecord.SystemPromptTemplate + trader, err := s.traderManager.GetTrader(traderID) if err != nil { c.JSON(http.StatusNotFound, gin.H{"error": "交易员不存在"}) @@ -552,6 +814,9 @@ func (s *Server) handleStartTrader(c *gin.Context) { return } + // 重新加载系统提示词模板（确保使用最新的硬盘文件） + s.reloadPromptTemplatesWithLog(templateName) + // 启动交易员 go func() { log.Printf("▶️ 启动交易员 %s (%s)", traderID, trader.GetName()) @@ -574,14 +839,14 @@ func (s *Server) handleStartTrader(c *gin.Context) { func (s *Server) handleStopTrader(c *gin.Context) { userID := c.GetString("user_id") traderID := c.Param("id") - + // 校验交易员是否属于当前用户 _, _, _, err := s.database.GetTraderConfig(userID, traderID) if err != nil { c.JSON(http.StatusNotFound, gin.H{"error": "交易员不存在或无访问权限"}) return } - + trader, err := s.traderManager.GetTrader(traderID) if err != nil { c.JSON(http.StatusNotFound, gin.H{"error": "交易员不存在"}) @@ -641,6 +906,113 @@ func (s *Server) handleUpdateTraderPrompt(c *gin.Context) { c.JSON(http.StatusOK, gin.H{"message": "自定义prompt已更新"}) } +// handleSyncBalance 同步交易所余额到initial_balance（选项B：手动同步 + 选项C：智能检测） +func (s *Server) handleSyncBalance(c *gin.Context) { + userID := c.GetString("user_id") + traderID := c.Param("id") + + log.Printf("🔄 用户 %s 请求同步交易员 %s 的余额", userID, traderID) + + // 从数据库获取交易员配置（包含交易所信息） + traderConfig, _, exchangeCfg, err := s.database.GetTraderConfig(userID, traderID) + if err != nil { + c.JSON(http.StatusNotFound, gin.H{"error": "交易员不存在"}) + return + } + + if exchangeCfg == nil || !exchangeCfg.Enabled { + c.JSON(http.StatusBadRequest, gin.H{"error": "交易所未配置或未启用"}) + return + } + + // 创建临时 trader 查询余额 + var tempTrader trader.Trader + var createErr error + + switch traderConfig.ExchangeID { + case "binance": + tempTrader = trader.NewFuturesTrader(exchangeCfg.APIKey, exchangeCfg.SecretKey, userID) + case "hyperliquid": + tempTrader, createErr = trader.NewHyperliquidTrader( + exchangeCfg.APIKey, + exchangeCfg.HyperliquidWalletAddr, + exchangeCfg.Testnet, + ) + case "aster": + tempTrader, createErr = trader.NewAsterTrader( + exchangeCfg.AsterUser, + exchangeCfg.AsterSigner, + exchangeCfg.AsterPrivateKey, + ) + default: + c.JSON(http.StatusBadRequest, gin.H{"error": "不支持的交易所类型"}) + return + } + + if createErr != nil { + log.Printf("⚠️ 创建临时 trader 失败: %v", createErr) + c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("连接交易所失败: %v", createErr)}) + return + } + + // 查询实际余额 + balanceInfo, balanceErr := tempTrader.GetBalance() + if balanceErr != nil { + log.Printf("⚠️ 查询交易所余额失败: %v", balanceErr) + c.JSON(http.StatusInternalServerError, gin.H{"error": fmt.Sprintf("查询余额失败: %v", balanceErr)}) + return + } + + // 提取可用余额 + var actualBalance float64 + if availableBalance, ok := balanceInfo["available_balance"].(float64); ok && availableBalance > 0 { + actualBalance = availableBalance + } else if availableBalance, ok := balanceInfo["availableBalance"].(float64); ok && availableBalance > 0 { + actualBalance = availableBalance + } else if totalBalance, ok := balanceInfo["balance"].(float64); ok && totalBalance > 0 { + actualBalance = totalBalance + } else { + c.JSON(http.StatusInternalServerError, gin.H{"error": "无法获取可用余额"}) + return + } + + oldBalance := traderConfig.InitialBalance + + // ✅ 选项C：智能检测余额变化 + changePercent := ((actualBalance - oldBalance) / oldBalance) * 100 + changeType := "增加" + if changePercent < 0 { + changeType = "减少" + } + + log.Printf("✓ 查询到交易所实际余额: %.2f USDT (当前配置: %.2f USDT, 变化: %.2f%%)", + actualBalance, oldBalance, changePercent) + + // 更新数据库中的 initial_balance + err = s.database.UpdateTraderInitialBalance(userID, traderID, actualBalance) + if err != nil { + log.Printf("❌ 更新initial_balance失败: %v", err) + c.JSON(http.StatusInternalServerError, gin.H{"error": "更新余额失败"}) + return + } + + // 重新加载交易员到内存 + err = s.traderManager.LoadTraderByID(s.database, userID, traderID) + if err != nil { + log.Printf("⚠️ 重新加载交易员到内存失败: %v", err) + } + + log.Printf("✅ 已同步余额: %.2f → %.2f USDT (%s %.2f%%)", oldBalance, actualBalance, changeType, changePercent) + + c.JSON(http.StatusOK, gin.H{ + "message": "余额同步成功", + "old_balance": oldBalance, + "new_balance": actualBalance, + "change_percent": changePercent, + "change_type": changeType, + }) +} + // handleGetModelConfigs 获取AI模型配置 func (s *Server) handleGetModelConfigs(c *gin.Context) { userID := c.GetString("user_id") @@ -653,18 +1025,69 @@ func (s *Server) handleGetModelConfigs(c *gin.Context) { } log.Printf("✅ 找到 %d 个AI模型配置", len(models)) - c.JSON(http.StatusOK, models) + // 转换为安全的响应结构，移除敏感信息 + safeModels := make([]SafeModelConfig, len(models)) + for i, model := range models { + safeModels[i] = SafeModelConfig{ + ID: model.ID, + Name: model.Name, + Provider: model.Provider, + Enabled: model.Enabled, + CustomAPIURL: model.CustomAPIURL, + CustomModelName: model.CustomModelName, + } + } + + c.JSON(http.StatusOK, safeModels) } -// handleUpdateModelConfigs 更新AI模型配置 +// handleUpdateModelConfigs 更新AI模型配置（仅支持加密数据） func (s *Server) handleUpdateModelConfigs(c *gin.Context) { userID := c.GetString("user_id") - var req UpdateModelConfigRequest - if err := c.ShouldBindJSON(&req); err != nil { - c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) + + // 读取原始请求体 + bodyBytes, err := c.GetRawData() + if err != nil { + c.JSON(http.StatusBadRequest, gin.H{"error": "读取请求体失败"}) return } + // 解析加密的 payload + var encryptedPayload crypto.EncryptedPayload + if err := json.Unmarshal(bodyBytes, &encryptedPayload); err != nil { + log.Printf("❌ 解析加密载荷失败: %v", err) + c.JSON(http.StatusBadRequest, gin.H{"error": "请求格式错误，必须使用加密传输"}) + return + } + + // 验证是否为加密数据 + if encryptedPayload.WrappedKey == "" { + log.Printf("❌ 检测到非加密请求 (UserID: %s)", userID) + c.JSON(http.StatusBadRequest, gin.H{ + "error": "此接口仅支持加密传输，请使用加密客户端", + "code": "ENCRYPTION_REQUIRED", + "message": "Encrypted transmission is required for security reasons", + }) + return + } + + // 解密数据 + decrypted, err := s.cryptoHandler.cryptoService.DecryptSensitiveData(&encryptedPayload) + if err != nil { + log.Printf("❌ 解密模型配置失败 (UserID: %s): %v", userID, err) + c.JSON(http.StatusBadRequest, gin.H{"error": "解密数据失败"}) + return + } + + // 解析解密后的数据 + var req UpdateModelConfigRequest + if err := json.Unmarshal([]byte(decrypted), &req); err != nil { + log.Printf("❌ 解析解密数据失败: %v", err) + c.JSON(http.StatusBadRequest, gin.H{"error": "解析解密数据失败"}) + return + } + log.Printf("🔓 已解密模型配置数据 (UserID: %s)", userID) + // 更新每个模型的配置 for modelID, modelData := range req.Models { err := s.database.UpdateAIModel(userID, modelID, modelData.Enabled, modelData.APIKey, modelData.CustomAPIURL, modelData.CustomModelName) @@ -675,13 +1098,13 @@ func (s *Server) handleUpdateModelConfigs(c *gin.Context) { } // 重新加载该用户的所有交易员，使新配置立即生效 - err := s.traderManager.LoadUserTraders(s.database, userID) + err = s.traderManager.LoadUserTraders(s.database, userID) if err != nil { log.Printf("⚠️ 重新加载用户交易员到内存失败: %v", err) // 这里不返回错误，因为模型配置已经成功更新到数据库 } - log.Printf("✓ AI模型配置已更新: %+v", req.Models) + log.Printf("✓ AI模型配置已更新: %+v", SanitizeModelConfigForLog(req.Models)) c.JSON(http.StatusOK, gin.H{"message": "模型配置已更新"}) } @@ -697,18 +1120,71 @@ func (s *Server) handleGetExchangeConfigs(c *gin.Context) { } log.Printf("✅ 找到 %d 个交易所配置", len(exchanges)) - c.JSON(http.StatusOK, exchanges) + // 转换为安全的响应结构，移除敏感信息 + safeExchanges := make([]SafeExchangeConfig, len(exchanges)) + for i, exchange := range exchanges { + safeExchanges[i] = SafeExchangeConfig{ + ID: exchange.ID, + Name: exchange.Name, + Type: exchange.Type, + Enabled: exchange.Enabled, + Testnet: exchange.Testnet, + HyperliquidWalletAddr: exchange.HyperliquidWalletAddr, + AsterUser: exchange.AsterUser, + AsterSigner: exchange.AsterSigner, + } + } + + c.JSON(http.StatusOK, safeExchanges) } -// handleUpdateExchangeConfigs 更新交易所配置 +// handleUpdateExchangeConfigs 更新交易所配置（仅支持加密数据） func (s *Server) handleUpdateExchangeConfigs(c *gin.Context) { userID := c.GetString("user_id") - var req UpdateExchangeConfigRequest - if err := c.ShouldBindJSON(&req); err != nil { - c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) + + // 读取原始请求体 + bodyBytes, err := c.GetRawData() + if err != nil { + c.JSON(http.StatusBadRequest, gin.H{"error": "读取请求体失败"}) return } + // 解析加密的 payload + var encryptedPayload crypto.EncryptedPayload + if err := json.Unmarshal(bodyBytes, &encryptedPayload); err != nil { + log.Printf("❌ 解析加密载荷失败: %v", err) + c.JSON(http.StatusBadRequest, gin.H{"error": "请求格式错误，必须使用加密传输"}) + return + } + + // 验证是否为加密数据 + if encryptedPayload.WrappedKey == "" { + log.Printf("❌ 检测到非加密请求 (UserID: %s)", userID) + c.JSON(http.StatusBadRequest, gin.H{ + "error": "此接口仅支持加密传输，请使用加密客户端", + "code": "ENCRYPTION_REQUIRED", + "message": "Encrypted transmission is required for security reasons", + }) + return + } + + // 解密数据 + decrypted, err := s.cryptoHandler.cryptoService.DecryptSensitiveData(&encryptedPayload) + if err != nil { + log.Printf("❌ 解密交易所配置失败 (UserID: %s): %v", userID, err) + c.JSON(http.StatusBadRequest, gin.H{"error": "解密数据失败"}) + return + } + + // 解析解密后的数据 + var req UpdateExchangeConfigRequest + if err := json.Unmarshal([]byte(decrypted), &req); err != nil { + log.Printf("❌ 解析解密数据失败: %v", err) + c.JSON(http.StatusBadRequest, gin.H{"error": "解析解密数据失败"}) + return + } + log.Printf("🔓 已解密交易所配置数据 (UserID: %s)", userID) + // 更新每个交易所的配置 for exchangeID, exchangeData := range req.Exchanges { err := s.database.UpdateExchange(userID, exchangeID, exchangeData.Enabled, exchangeData.APIKey, exchangeData.SecretKey, exchangeData.Testnet, exchangeData.HyperliquidWalletAddr, exchangeData.AsterUser, exchangeData.AsterSigner, exchangeData.AsterPrivateKey) @@ -719,13 +1195,13 @@ func (s *Server) handleUpdateExchangeConfigs(c *gin.Context) { } // 重新加载该用户的所有交易员，使新配置立即生效 - err := s.traderManager.LoadUserTraders(s.database, userID) + err = s.traderManager.LoadUserTraders(s.database, userID) if err != nil { log.Printf("⚠️ 重新加载用户交易员到内存失败: %v", err) // 这里不返回错误，因为交易所配置已经成功更新到数据库 } - log.Printf("✓ 交易所配置已更新: %+v", req.Exchanges) + log.Printf("✓ 交易所配置已更新: %+v", SanitizeExchangeConfigForLog(req.Exchanges)) c.JSON(http.StatusOK, gin.H{"message": "交易所配置已更新"}) } @@ -791,19 +1267,12 @@ func (s *Server) handleTraderList(c *gin.Context) { } } - // AIModelID 应该已经是 provider（如 "deepseek"），直接使用 - // 如果是旧数据格式（如 "admin_deepseek"），提取 provider 部分 - aiModelID := trader.AIModelID - // 兼容旧数据：如果包含下划线，提取最后一部分作为 provider - if strings.Contains(aiModelID, "_") { - parts := strings.Split(aiModelID, "_") - aiModelID = parts[len(parts)-1] - } - + // 返回完整的 AIModelID（如 "admin_deepseek"），不要截断 + // 前端需要完整 ID 来验证模型是否存在（与 handleGetTraderConfig 保持一致） result = append(result, map[string]interface{}{ "trader_id": trader.ID, "trader_name": trader.Name, - "ai_model": aiModelID, + "ai_model": trader.AIModelID, // 使用完整 ID "exchange_id": trader.ExchangeID, "is_running": isRunning, "initial_balance": trader.InitialBalance, @@ -842,21 +1311,22 @@ func (s *Server) handleGetTraderConfig(c *gin.Context) { aiModelID := traderConfig.AIModelID result := map[string]interface{}{ - "trader_id": traderConfig.ID, - "trader_name": traderConfig.Name, - "ai_model": aiModelID, - "exchange_id": traderConfig.ExchangeID, - "initial_balance": traderConfig.InitialBalance, - "scan_interval_minutes": traderConfig.ScanIntervalMinutes, - "btc_eth_leverage": traderConfig.BTCETHLeverage, - "altcoin_leverage": traderConfig.AltcoinLeverage, - "trading_symbols": traderConfig.TradingSymbols, - "custom_prompt": traderConfig.CustomPrompt, - "override_base_prompt": traderConfig.OverrideBasePrompt, - "is_cross_margin": traderConfig.IsCrossMargin, - "use_coin_pool": traderConfig.UseCoinPool, - "use_oi_top": traderConfig.UseOITop, - "is_running": isRunning, + "trader_id": traderConfig.ID, + "trader_name": traderConfig.Name, + "ai_model": aiModelID, + "exchange_id": traderConfig.ExchangeID, + "initial_balance": traderConfig.InitialBalance, + "scan_interval_minutes": traderConfig.ScanIntervalMinutes, + "btc_eth_leverage": traderConfig.BTCETHLeverage, + "altcoin_leverage": traderConfig.AltcoinLeverage, + "trading_symbols": traderConfig.TradingSymbols, + "custom_prompt": traderConfig.CustomPrompt, + "override_base_prompt": traderConfig.OverrideBasePrompt, + "system_prompt_template": traderConfig.SystemPromptTemplate, + "is_cross_margin": traderConfig.IsCrossMargin, + "use_coin_pool": traderConfig.UseCoinPool, + "use_oi_top": traderConfig.UseOITop, + "is_running": isRunning, } c.JSON(http.StatusOK, result) @@ -978,7 +1448,15 @@ func (s *Server) handleLatestDecisions(c *gin.Context) { return } - records, err := trader.GetDecisionLogger().GetLatestRecords(5) + // 从 query 参数读取 limit，默认 5，最大 50 + limit := 5 + if limitStr := c.Query("limit"); limitStr != "" { + if l, err := strconv.Atoi(limitStr); err == nil && l > 0 && l <= 50 { + limit = l + } + } + + records, err := trader.GetDecisionLogger().GetLatestRecords(limit) if err != nil { c.JSON(http.StatusInternalServerError, gin.H{ "error": fmt.Sprintf("获取决策日志失败: %v", err), @@ -1157,14 +1635,6 @@ func (s *Server) handlePerformance(c *gin.Context) { // authMiddleware JWT认证中间件 func (s *Server) authMiddleware() gin.HandlerFunc { return func(c *gin.Context) { - // 如果是管理员模式，直接使用admin用户 - if auth.IsAdminMode() { - c.Set("user_id", "admin") - c.Set("email", "admin@localhost") - c.Next() - return - } - authHeader := c.GetHeader("Authorization") if authHeader == "" { c.JSON(http.StatusUnauthorized, gin.H{"error": "缺少Authorization头"}) @@ -1180,8 +1650,17 @@ func (s *Server) authMiddleware() gin.HandlerFunc { return } + tokenString := tokenParts[1] + + // 黑名单检查 + if auth.IsTokenBlacklisted(tokenString) { + c.JSON(http.StatusUnauthorized, gin.H{"error": "token已失效，请重新登录"}) + c.Abort() + return + } + // 验证JWT token - claims, err := auth.ValidateJWT(tokenParts[1]) + claims, err := auth.ValidateJWT(tokenString) if err != nil { c.JSON(http.StatusUnauthorized, gin.H{"error": "无效的token: " + err.Error()}) c.Abort() @@ -1195,8 +1674,37 @@ func (s *Server) authMiddleware() gin.HandlerFunc { } } +// handleLogout 将当前token加入黑名单 +func (s *Server) handleLogout(c *gin.Context) { + authHeader := c.GetHeader("Authorization") + if authHeader == "" { + c.JSON(http.StatusUnauthorized, gin.H{"error": "缺少Authorization头"}) + return + } + parts := strings.Split(authHeader, " ") + if len(parts) != 2 || parts[0] != "Bearer" { + c.JSON(http.StatusUnauthorized, gin.H{"error": "无效的Authorization格式"}) + return + } + tokenString := parts[1] + claims, err := auth.ValidateJWT(tokenString) + if err != nil { + c.JSON(http.StatusUnauthorized, gin.H{"error": "无效的token"}) + return + } + var exp time.Time + if claims.ExpiresAt != nil { + exp = claims.ExpiresAt.Time + } else { + exp = time.Now().Add(24 * time.Hour) + } + auth.BlacklistToken(tokenString, exp) + c.JSON(http.StatusOK, gin.H{"message": "已登出"}) +} + // handleRegister 处理用户注册请求 func (s *Server) handleRegister(c *gin.Context) { + var req struct { Email string `json:"email" binding:"required,email"` Password string `json:"password" binding:"required,min=6"` @@ -1230,8 +1738,21 @@ func (s *Server) handleRegister(c *gin.Context) { } // 检查邮箱是否已存在 - _, err := s.database.GetUserByEmail(req.Email) + existingUser, err := s.database.GetUserByEmail(req.Email) if err == nil { + // 如果用户未完成OTP验证，允许重新获取OTP（支持中断后恢复注册） + if !existingUser.OTPVerified { + qrCodeURL := auth.GetOTPQRCodeURL(existingUser.OTPSecret, req.Email) + c.JSON(http.StatusOK, gin.H{ + "user_id": existingUser.ID, + "email": req.Email, + "otp_secret": existingUser.OTPSecret, + "qr_code_url": qrCodeURL, + "message": "检测到未完成的注册，请继续完成OTP设置", + }) + return + } + // 用户已完成验证，拒绝重复注册 c.JSON(http.StatusConflict, gin.H{"error": "邮箱已被注册"}) return } @@ -1426,6 +1947,50 @@ func (s *Server) handleVerifyOTP(c *gin.Context) { }) } +// handleResetPassword 重置密码（通过邮箱 + OTP 验证） +func (s *Server) handleResetPassword(c *gin.Context) { + var req struct { + Email string `json:"email" binding:"required,email"` + NewPassword string `json:"new_password" binding:"required,min=6"` + OTPCode string `json:"otp_code" binding:"required"` + } + + if err := c.ShouldBindJSON(&req); err != nil { + c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()}) + return + } + + // 查询用户 + user, err := s.database.GetUserByEmail(req.Email) + if err != nil { + c.JSON(http.StatusNotFound, gin.H{"error": "邮箱不存在"}) + return + } + + // 验证 OTP + if !auth.VerifyOTP(user.OTPSecret, req.OTPCode) { + c.JSON(http.StatusBadRequest, gin.H{"error": "Google Authenticator 验证码错误"}) + return + } + + // 生成新密码哈希 + newPasswordHash, err := auth.HashPassword(req.NewPassword) + if err != nil { + c.JSON(http.StatusInternalServerError, gin.H{"error": "密码处理失败"}) + return + } + + // 更新密码 + err = s.database.UpdateUserPassword(user.ID, newPasswordHash) + if err != nil { + c.JSON(http.StatusInternalServerError, gin.H{"error": "密码更新失败"}) + return + } + + log.Printf("✓ 用户 %s 密码已重置", user.Email) + c.JSON(http.StatusOK, gin.H{"message": "密码重置成功，请使用新密码登录"}) +} + // initUserDefaultConfigs 为新用户初始化默认的模型和交易所配置 func (s *Server) initUserDefaultConfigs(userID string) error { // 注释掉自动创建默认配置，让用户手动添加 @@ -1457,7 +2022,22 @@ func (s *Server) handleGetSupportedExchanges(c *gin.Context) { return } - c.JSON(http.StatusOK, exchanges) + // 转换为安全的响应结构，移除敏感信息 + safeExchanges := make([]SafeExchangeConfig, len(exchanges)) + for i, exchange := range exchanges { + safeExchanges[i] = SafeExchangeConfig{ + ID: exchange.ID, + Name: exchange.Name, + Type: exchange.Type, + Enabled: exchange.Enabled, + Testnet: exchange.Testnet, + HyperliquidWalletAddr: "", // 默认配置不包含钱包地址 + AsterUser: "", // 默认配置不包含用户信息 + AsterSigner: "", + } + } + + c.JSON(http.StatusOK, safeExchanges) } // Start 启动服务器 @@ -1489,7 +2069,26 @@ func (s *Server) Start() error { log.Printf(" • GET /api/performance?trader_id=xxx - 指定trader的AI学习表现分析") log.Println() - return s.router.Run(addr) + // 创建 http.Server 以支持 graceful shutdown + s.httpServer = &http.Server{ + Addr: addr, + Handler: s.router, + } + + return s.httpServer.ListenAndServe() +} + +// Shutdown 优雅关闭 API 服务器 +func (s *Server) Shutdown() error { + if s.httpServer == nil { + return nil + } + + // 设置 5 秒超时 + ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second) + defer cancel() + + return s.httpServer.Shutdown(ctx) } // handleGetPromptTemplates 获取所有系统提示词模板列表 @@ -1581,7 +2180,7 @@ func (s *Server) handlePublicCompetition(c *gin.Context) { }) return } - + c.JSON(http.StatusOK, competition) } @@ -1594,7 +2193,7 @@ func (s *Server) handleTopTraders(c *gin.Context) { }) return } - + c.JSON(http.StatusOK, topTraders) } @@ -1603,7 +2202,7 @@ func (s *Server) handleEquityHistoryBatch(c *gin.Context) { var requestBody struct { TraderIDs []string `json:"trader_ids"` } - + // 尝试解析POST请求的JSON body if err := c.ShouldBindJSON(&requestBody); err != nil { // 如果JSON解析失败，尝试从query参数获取（兼容GET请求） @@ -1617,13 +2216,13 @@ func (s *Server) handleEquityHistoryBatch(c *gin.Context) { }) return } - + traders, ok := topTraders["traders"].([]map[string]interface{}) if !ok { c.JSON(http.StatusInternalServerError, gin.H{"error": "交易员数据格式错误"}) return } - + // 提取trader IDs traderIDs := make([]string, 0, len(traders)) for _, trader := range traders { @@ -1631,24 +2230,24 @@ func (s *Server) handleEquityHistoryBatch(c *gin.Context) { traderIDs = append(traderIDs, traderID) } } - + result := s.getEquityHistoryForTraders(traderIDs) c.JSON(http.StatusOK, result) return } - + // 解析逗号分隔的trader IDs requestBody.TraderIDs = strings.Split(traderIDsParam, ",") for i := range requestBody.TraderIDs { requestBody.TraderIDs[i] = strings.TrimSpace(requestBody.TraderIDs[i]) } } - + // 限制最多20个交易员，防止请求过大 if len(requestBody.TraderIDs) > 20 { requestBody.TraderIDs = requestBody.TraderIDs[:20] } - + result := s.getEquityHistoryForTraders(requestBody.TraderIDs) c.JSON(http.StatusOK, result) } @@ -1658,31 +2257,31 @@ func (s *Server) getEquityHistoryForTraders(traderIDs []string) map[string]inter result := make(map[string]interface{}) histories := make(map[string]interface{}) errors := make(map[string]string) - + for _, traderID := range traderIDs { if traderID == "" { continue } - + trader, err := s.traderManager.GetTrader(traderID) if err != nil { errors[traderID] = "交易员不存在" continue } - + // 获取历史数据（用于对比展示，限制数据量） records, err := trader.GetDecisionLogger().GetLatestRecords(500) if err != nil { errors[traderID] = fmt.Sprintf("获取历史数据失败: %v", err) continue } - + // 构建收益率历史数据 history := make([]map[string]interface{}, 0, len(records)) for _, record := range records { // 计算总权益（余额+未实现盈亏） totalEquity := record.AccountState.TotalBalance + record.AccountState.TotalUnrealizedProfit - + history = append(history, map[string]interface{}{ "timestamp": record.Timestamp, "total_equity": totalEquity, @@ -1690,16 +2289,16 @@ func (s *Server) getEquityHistoryForTraders(traderIDs []string) map[string]inter "balance": record.AccountState.TotalBalance, }) } - + histories[traderID] = history } - + result["histories"] = histories result["count"] = len(histories) if len(errors) > 0 { result["errors"] = errors } - + return result } @@ -1734,3 +2333,16 @@ func (s *Server) handleGetPublicTraderConfig(c *gin.Context) { c.JSON(http.StatusOK, result) } +// reloadPromptTemplatesWithLog 重新加载提示词模板并记录日志 +func (s *Server) reloadPromptTemplatesWithLog(templateName string) { + if err := decision.ReloadPromptTemplates(); err != nil { + log.Printf("⚠️ 重新加载提示词模板失败: %v", err) + return + } + + if templateName == "" { + log.Printf("✓ 已重新加载系统提示词模板 [当前使用: default (未指定，使用默认)]") + } else { + log.Printf("✓ 已重新加载系统提示词模板 [当前使用: %s]", templateName) + } +} diff --git a/api/server_test.go b/api/server_test.go new file mode 100644 index 00000000..6b6b83c1 --- /dev/null +++ b/api/server_test.go @@ -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) + } +} diff --git a/api/utils.go b/api/utils.go new file mode 100644 index 00000000..4f871ef0 --- /dev/null +++ b/api/utils.go @@ -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 +} diff --git a/api/utils_test.go b/api/utils_test.go new file mode 100644 index 00000000..fb4976ff --- /dev/null +++ b/api/utils_test.go @@ -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) + } + }) + } +} diff --git a/auth/auth.go b/auth/auth.go index 89c58e5c..85fa184f 100644 --- a/auth/auth.go +++ b/auth/auth.go @@ -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声明 diff --git a/bootstrap/README.md b/bootstrap/README.md new file mode 100644 index 00000000..4db4b260 --- /dev/null +++ b/bootstrap/README.md @@ -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 项目内部模块，遵循项目整体许可证。 diff --git a/bootstrap/bootstrap.go b/bootstrap/bootstrap.go new file mode 100644 index 00000000..ee756113 --- /dev/null +++ b/bootstrap/bootstrap.go @@ -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) +} diff --git a/bootstrap/context.go b/bootstrap/context.go new file mode 100644 index 00000000..3616d004 --- /dev/null +++ b/bootstrap/context.go @@ -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 +} diff --git a/bootstrap/hook_builder.go b/bootstrap/hook_builder.go new file mode 100644 index 00000000..5d88d175 --- /dev/null +++ b/bootstrap/hook_builder.go @@ -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 +} diff --git a/bootstrap/init_hook.go b/bootstrap/init_hook.go new file mode 100644 index 00000000..d31283c5 --- /dev/null +++ b/bootstrap/init_hook.go @@ -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 +} diff --git a/config.json.example b/config.json.example index fefa1673..1c7406d0 100644 --- a/config.json.example +++ b/config.json.example @@ -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" + } } \ No newline at end of file diff --git a/config/config.go b/config/config.go index 37a537db..81ff3cea 100644 --- a/config/config.go +++ b/config/config.go @@ -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 } diff --git a/config/database.go b/config/database.go index 719fd07f..5977ae3c 100644 --- a/config/database.go +++ b/config/database.go @@ -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 +} diff --git a/config/database_test.go b/config/database_test.go new file mode 100644 index 00000000..99ac03f3 --- /dev/null +++ b/config/database_test.go @@ -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) + } +} diff --git a/config/test_rsa_key.pem.pub b/config/test_rsa_key.pem.pub new file mode 100644 index 00000000..a9f89eeb --- /dev/null +++ b/config/test_rsa_key.pem.pub @@ -0,0 +1,9 @@ +-----BEGIN PUBLIC KEY----- +MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4Y666RzY5LLi6PiYL+vC +7+fcr122Fd8BC7IdqUSYKQ33Nsi9J7J5fDgcMf7ZAnIBpxMV7+e1KEoiwtGmxwHj +mYo0ZV0E6JXdiK26S052+Shquri0IXkwGFraDuNKqmGrj6vZuXtq2L2gdSyZCxrI +veN9g6LxBvLBP1Rx7UEmZeyokRYvChcxAQXuS/0br44BOHGtwAElk6AGLISz55AG +oM40b3ktiza+8THKMz3GiylQQYpBltbM3yAXPlnXJ2MtUZiaHNhEQI4++PMvEErN +Izm8cIgcvUAXJ5vBfa4kD0kSgBJFuEQ2im3qcWTuEPRKztEeJDY7XAVHc1Xy6d4N +vQIDAQAB +-----END PUBLIC KEY----- diff --git a/crypto/crypto.go b/crypto/crypto.go new file mode 100644 index 00000000..9a29480f --- /dev/null +++ b/crypto/crypto.go @@ -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 +} diff --git a/crypto/encryption.go b/crypto/encryption.go new file mode 100644 index 00000000..73d1b5ba --- /dev/null +++ b/crypto/encryption.go @@ -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 +} diff --git a/crypto/encryption_test.go b/crypto/encryption_test.go new file mode 100644 index 00000000..1e65a962 --- /dev/null +++ b/crypto/encryption_test.go @@ -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 +} diff --git a/crypto/secure_storage.go b/crypto/secure_storage.go new file mode 100644 index 00000000..b168f9f8 --- /dev/null +++ b/crypto/secure_storage.go @@ -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 +} diff --git a/decision/engine.go b/decision/engine.go index df48d534..bef863df 100644 --- a/decision/engine.go +++ b/decision/engine.go @@ -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)
起動をスキップする場合は`false`に設定 | `true`または`false` | ✅ はい | +| `ai_model` | 使用するAIプロバイダー | `"deepseek"`または`"qwen"`または`"custom"` | ✅ はい | +| `exchange` | 使用する取引所 | `"binance"`または`"hyperliquid"`または`"aster"` | ✅ はい | +| `binance_api_key` | Binance APIキー | `"abc123..."` | Binance使用時に必須 | +| `binance_secret_key` | Binanceシークレットキー | `"xyz789..."` | Binance使用時に必須 | +| `hyperliquid_private_key` | Hyperliquid秘密鍵
⚠️ `0x`プレフィックスを削除 | `"your_key..."` | Hyperliquid使用時に必須 | +| `hyperliquid_wallet_addr` | Hyperliquidウォレットアドレス | `"0xabc..."` | Hyperliquid使用時に必須 | +| `hyperliquid_testnet` | テストネットを使用 | `true`または`false` | ❌ いいえ（デフォルトはfalse） | +| `use_qwen` | Qwenを使用するかどうか | `true`または`false` | ✅ はい | +| `deepseek_key` | DeepSeek APIキー | `"sk-xxx"` | DeepSeek使用時 | +| `qwen_key` | Qwen APIキー | `"sk-xxx"` | Qwen使用時 | +| `initial_balance` | 損益計算の開始残高 | `1000.0` | ✅ はい | +| `scan_interval_minutes` | 判断を行う頻度 | `3`（3-5推奨） | ✅ はい | +| **`leverage`** | **レバレッジ設定（v2.0.3+）** | 下記参照 | ✅ はい | +| `btc_eth_leverage` | BTC/ETHの最大レバレッジ
⚠️ サブアカウント：≤5x | `5`（デフォルト、安全）
`50`（メインアカウント最大） | ✅ はい | +| `altcoin_leverage` | アルトコインの最大レバレッジ
⚠️ サブアカウント：≤5x | `5`（デフォルト、安全）
`20`（メインアカウント最大） | ✅ はい | +| `use_default_coins` | 組み込みコインリストを使用
**✨ スマートデフォルト：`true`**（v2.0.2+）
API URLが提供されていない場合自動有効化 | `true`または省略 | ❌ いいえ
（オプション、自動デフォルト） | +| `coin_pool_api_url` | カスタムコインプールAPI
*`use_default_coins: false`の場合のみ必要* | `""`（空） | ❌ いいえ | +| `oi_top_api_url` | 建玉API
*オプション補足データ* | `""`（空） | ❌ いいえ | +| `api_server_port` | Webダッシュボードポート | `8080` | ✅ はい | + +**デフォルト取引コイン**（`use_default_coins: true`の場合）： +- BTC、ETH、SOL、BNB、XRP、DOGE、ADA、HYPE + +--- + +#### ⚙️ レバレッジ設定（v2.0.3+） + +**レバレッジ設定とは？** + +レバレッジ設定は、AIが各取引で使用できる最大レバレッジを制御します。これは、特にレバレッジ制限があるBinanceサブアカウントでリスク管理に重要です。 + +**設定形式：** + +```json +"leverage": { + "btc_eth_leverage": 5, // BTCとETHの最大レバレッジ + "altcoin_leverage": 5 // その他すべてのコインの最大レバレッジ +} +``` + +**⚠️ 重要：Binanceサブアカウント制限** + +- **サブアカウント**: Binanceにより**≤5xレバレッジ**に制限 +- **メインアカウント**: 最大20x（アルトコイン）または50x（BTC/ETH）を使用可能 +- サブアカウントを使用していてレバレッジを>5xに設定すると、取引は**失敗**し、エラーが表示されます：`Subaccounts are restricted from using leverage greater than 5x` + +**推奨設定：** + +| アカウントタイプ | BTC/ETHレバレッジ | アルトコインレバレッジ | リスクレベル | +|-------------|------------------|------------------|------------| +| **サブアカウント** | `5` | `5` | ✅ 安全（デフォルト） | +| **メイン（保守的）** | `10` | `10` | 🟡 中程度 | +| **メイン（積極的）** | `20` | `15` | 🔴 高 | +| **メイン（最大）** | `50` | `20` | 🔴🔴 非常に高 | + +**例：** + +**安全な設定（サブアカウントまたは保守的）：** +```json +"leverage": { + "btc_eth_leverage": 5, + "altcoin_leverage": 5 +} +``` + +**積極的な設定（メインアカウントのみ）：** +```json +"leverage": { + "btc_eth_leverage": 20, + "altcoin_leverage": 15 +} +``` + +**AIのレバレッジ使用方法：** + +- AIは設定された最大値まで**1xから任意のレバレッジを選択**できます +- たとえば、`altcoin_leverage: 20`の場合、AIは市場条件に基づいて5x、10x、または20xを使用することを決定する可能性があります +- 設定は固定値ではなく**上限**を設定します +- AIはレバレッジを選択する際にボラティリティ、リスクリワード比率、アカウント残高を考慮します + +--- + +#### ⚠️ 重要：`use_default_coins`フィールド + +**スマートデフォルト動作（v2.0.2+）：** + +次の場合、システムは自動的に`use_default_coins: true`をデフォルトにします： +- config.jsonにこのフィールドを含めていない、または +- `false`に設定したが`coin_pool_api_url`を提供していない + +これにより初心者に優しくなります！このフィールドを完全に省略することもできます。 + +**設定例：** + +✅ **オプション1：明示的に設定（明確性のため推奨）** +```json +"use_default_coins": true, +"coin_pool_api_url": "", +"oi_top_api_url": "" +``` + +✅ **オプション2：フィールドを省略（デフォルトコインを自動使用）** +```json +// "use_default_coins"を含めないだけ +"coin_pool_api_url": "", +"oi_top_api_url": "" +``` + +⚙️ **高度：外部APIを使用** +```json +"use_default_coins": false, +"coin_pool_api_url": "http://your-api.com/coins", +"oi_top_api_url": "http://your-api.com/oi" +``` + +--- + +### 6. システムを実行 + +#### 🚀 システムの起動（2ステップ） + +システムには別々に実行される**2つの部分**があります： +1. **バックエンド**（AIトレーディングブレイン + API） +2. **フロントエンド**（監視用Webダッシュボード） + +--- + +#### **ステップ1：バックエンドを起動** + +ターミナルを開いて実行： + +```bash +# プログラムをビルド（初回のみ、またはコード変更後） +go build -o nofx + +# バックエンドを起動 +./nofx +``` + +**表示されるべきもの：** + +``` +🚀 启动自动交易系统... +✓ Trader [my_trader] 已初始化 +✓ API服务器启动在端口 8080 +📊 开始交易监控... +``` + +**⚠️ エラーが表示される場合：** + +| エラーメッセージ | 解決策 | +|--------------|----------| +| `invalid API key` | config.jsonのBinance APIキーを確認 | +| `TA-Lib not found` | `brew install ta-lib`を実行（macOS） | +| `port 8080 already in use` | config.jsonの`api_server_port`を変更 | +| `DeepSeek API error` | DeepSeek APIキーと残高を確認 | + +**✅ バックエンドが正しく実行されているとき：** +- エラーメッセージなし +- "开始交易监控..."が表示される +- システムがアカウント残高を表示 +- このターミナルウィンドウを開いたままにしてください！ + +--- + +#### **ステップ2：フロントエンドを起動** + +**新しいターミナルウィンドウ**を開き（最初のものは実行したまま）、次を実行： + +```bash +cd web +npm run dev +``` + +**表示されるべきもの：** + +``` +VITE v5.x.x ready in xxx ms + +➜ Local: http://localhost:3000/ +➜ Network: use --host to expose +``` + +**✅ フロントエンドが実行されているとき：** +- "Local: http://localhost:3000/"メッセージ +- エラーメッセージなし +- このターミナルウィンドウも開いたままにしてください！ + +--- + +#### **ステップ3：ダッシュボードにアクセス** + +Webブラウザを開いて次にアクセス： + +**🌐 http://localhost:3000** + +**表示されるもの：** +- 📊 リアルタイムアカウント残高 +- 📈 オープンポジション（ある場合） +- 🤖 AI判断ログ +- 📉 エクイティカーブチャート + +**初回のヒント：** +- 最初のAI判断まで3-5分かかることがあります +- 初期判断は「観望」（待機）と言う場合があります - これは正常です +- AIは最初に市場状況を分析する必要があります + +--- + +### 7. システムを監視 + +**監視すべきもの：** + +✅ **健全なシステムの兆候：** +- バックエンドターミナルが3-5分ごとに判断サイクルを表示 +- 継続的なエラーメッセージなし +- アカウント残高の更新 +- Webダッシュボードの自動更新 + +⚠️ **警告の兆候：** +- 繰り返されるAPIエラー +- 10分以上判断なし +- 残高の急速な減少 + +**システムステータスの確認：** + +```bash +# 新しいターミナルウィンドウで +curl http://localhost:8080/health +``` + +戻り値：`{"status":"ok"}` + +--- + +### 8. システムを停止 + +**グレースフルシャットダウン（推奨）：** + +1. **バックエンドターミナル**（最初のもの）に移動 +2. `Ctrl+C`を押す +3. "系统已停止"メッセージを待つ +4. **フロントエンドターミナル**（2番目のもの）に移動 +5. `Ctrl+C`を押す + +**⚠️ 重要：** +- 常にバックエンドを最初に停止 +- ターミナルを閉じる前に確認を待つ +- 強制終了しない（ターミナルを直接閉じない） + +--- + +## 📖 AI判断フロー + +各判断サイクル（デフォルト3分）で、システムは以下のインテリジェントプロセスを実行します： + +``` +┌──────────────────────────────────────────────────────────┐ +│ 1. 📊 過去パフォーマンスを分析（過去20サイクル） │ +├──────────────────────────────────────────────────────────┤ +│ ✓ 総合勝率、平均利益、損益比を計算 │ +│ ✓ コインごとの統計（勝率、平均損益（USDT）） │ +│ ✓ 最高/最悪パフォーマンスコインを特定 │ +│ ✓ 正確なPnLを含む最後の5取引の詳細をリスト │ +│ ✓ リスク調整パフォーマンスのシャープレシオを計算 │ +│ 📌 NEW（v2.0.2）：レバレッジを含む正確なUSDT PnL │ +└──────────────────────────────────────────────────────────┘ + ↓ +┌──────────────────────────────────────────────────────────┐ +│ 2. 💰 アカウントステータスを取得 │ +├──────────────────────────────────────────────────────────┤ +│ • 総エクイティと利用可能残高 │ +│ • オープンポジション数と未実現損益 │ +│ • 証拠金使用率（AIは最大90%を管理） │ +│ • 日次損益追跡とドローダウン監視 │ +└──────────────────────────────────────────────────────────┘ + ↓ +┌──────────────────────────────────────────────────────────┐ +│ 3. 🔍 既存ポジションを分析（ある場合） │ +├──────────────────────────────────────────────────────────┤ +│ • 各ポジションについて、最新の市場データを取得 │ +│ • リアルタイムのテクニカル指標を計算： │ +│ - 3分K線：RSI(7)、MACD、EMA20 │ +│ - 4時間K線：RSI(14)、EMA20/50、ATR │ +│ • ポジション保有期間を追跡（例：「2時間15分」） │ +│ 📌 NEW（v2.0.2）：各ポジションの保有期間を表示 │ +│ • 表示：エントリー価格、現在価格、損益%、期間 │ +│ • AIが評価：保持するかクローズするか？ │ +└──────────────────────────────────────────────────────────┘ + ↓ +┌──────────────────────────────────────────────────────────┐ +│ 4. 🎯 新しい機会を評価（候補コイン） │ +├──────────────────────────────────────────────────────────┤ +│ • コインプールを取得（2モード）： │ +│ 🌟 デフォルトモード：BTC、ETH、SOL、BNB、XRPなど │ +│ ⚙️ 高度モード：AI500（上位20）+ OI Top（上位20） │ +│ • 候補コインをマージして重複削除 │ +│ • フィルター：低流動性を削除（<1500万USD OI値） │ +│ • 市場データ + テクニカル指標をバッチ取得 │ +│ • ボラティリティ、トレンド強度、出来高急増を計算 │ +└──────────────────────────────────────────────────────────┘ + ↓ +┌──────────────────────────────────────────────────────────┐ +│ 5. 🧠 AI総合判断（DeepSeek/Qwen） │ +├──────────────────────────────────────────────────────────┤ +│ • 過去フィードバックをレビュー： │ +│ - 最近の勝率と利益率 │ +│ - 最高/最悪コインパフォーマンス │ +│ - 繰り返しミスを回避 │ +│ • すべての生シーケンスデータを分析： │ +│ - 3分価格シーケンス、4時間K線シーケンス │ +│ - 完全な指標シーケンス（最新のみではない） │ +│ 📌 NEW（v2.0.2）：AIは分析の完全な自由を持つ │ +│ • 思考連鎖（CoT）推論プロセス │ +│ • 構造化された判断を出力： │ +│ - アクション：close_long/close_short/open_long/open_short│ +│ - コインシンボル、数量、レバレッジ │ +│ - ストップロスとテイクプロフィットレベル（≥1:2比率） │ +│ • 判断：待機/保持/クローズ/オープン │ +└──────────────────────────────────────────────────────────┘ + ↓ +┌──────────────────────────────────────────────────────────┐ +│ 6. ⚡ 取引を実行 │ +├──────────────────────────────────────────────────────────┤ +│ • 優先順位：既存をクローズ → その後新規をオープン │ +│ • 実行前のリスクチェック： │ +│ - ポジションサイズ制限（アルトコイン1.5x、BTC 10x） │ +│ - 重複ポジションなし（同じコイン + 方向） │ +│ - 証拠金使用量が90%制限内 │ +│ • Binance LOT_SIZE精度を自動取得して適用 │ +│ • Binance Futures APIで注文を実行 │ +│ • クローズ後：すべての保留注文を自動キャンセル │ +│ • 実際の実行価格と注文IDを記録 │ +│ 📌 期間計算のためにポジションオープン時間を追跡 │ +└──────────────────────────────────────────────────────────┘ + ↓ +┌──────────────────────────────────────────────────────────┐ +│ 7. 📝 完全なログを記録してパフォーマンスを更新 │ +├──────────────────────────────────────────────────────────┤ +│ • decision_logs/{trader_id}/に判断ログを保存 │ +│ • ログには以下が含まれます： │ +│ - 完全な思考連鎖（CoT） │ +│ - すべての市場データを含む入力プロンプト │ +│ - 構造化された判断JSON │ +│ - アカウントスナップショット（残高、ポジション、証拠金）│ +│ - 実行結果（成功/失敗、価格） │ +│ • パフォーマンスデータベースを更新： │ +│ - symbol_sideキーでオープン/クローズペアをマッチ │ +│ 📌 NEW：ロング/ショート競合を防止 │ +│ - 正確なUSDT PnLを計算： │ +│ PnL = ポジション価値 × 価格変化% × レバレッジ │ +│ 📌 NEW：数量 + レバレッジを考慮 │ +│ - 保存：数量、レバレッジ、オープン時間、クローズ時間 │ +│ - 更新：勝率、利益率、シャープレシオ │ +│ • パフォーマンスデータは次のサイクルにフィードバック │ +└──────────────────────────────────────────────────────────┘ + ↓ + （3-5分ごとに繰り返し） +``` + +### v2.0.2の主な改善点 + +**📌 ポジション期間追跡：** +- システムが各ポジションの保有期間を追跡 +- ユーザープロンプトに表示：「持仓时长2小时15分钟」 +- AIが出口タイミングについてより良い判断を下すのに役立つ + +**📌 正確なPnL計算：** +- 以前：パーセンテージのみ（100U@5% = 1000U@5% = 両方とも「5.0」と表示） +- 現在：実際のUSDT利益 = ポジション価値 × 価格変化 × レバレッジ +- 例：1000 USDT × 5% × 20x = 1000 USDT実際の利益 + +**📌 AI自由度の向上：** +- AIはすべての生シーケンスデータを自由に分析可能 +- 事前定義された指標の組み合わせに制限されない +- 独自のトレンド分析、サポート/レジスタンス計算を実行可能 + +**📌 改善されたポジション追跡：** +- `symbol_side`キーを使用（例：「BTCUSDT_long」） +- ロングとショートの両方を保有する際の競合を防止 +- 完全なデータを保存：数量、レバレッジ、オープン/クローズ時間 + +--- + +## 🧠 AI自己学習の例 + +### 過去フィードバック（プロンプトに自動追加） + +```markdown +## 📊 過去パフォーマンスフィードバック + +### 総合パフォーマンス +- **総取引数**: 15（利益：8 | 損失：7） +- **勝率**: 53.3% +- **平均利益**: +3.2% | 平均損失：-2.1% +- **損益比**: 1.52:1 + +### 最近の取引 +1. BTCUSDT LONG: 95000.0000 → 97500.0000 = +2.63% ✓ +2. ETHUSDT SHORT: 3500.0000 → 3450.0000 = +1.43% ✓ +3. SOLUSDT LONG: 185.0000 → 180.0000 = -2.70% ✗ +4. BNBUSDT LONG: 610.0000 → 625.0000 = +2.46% ✓ +5. ADAUSDT LONG: 0.8500 → 0.8300 = -2.35% ✗ + +### コインパフォーマンス +- **最高**: BTCUSDT（勝率75%、平均+2.5%） +- **最悪**: SOLUSDT（勝率25%、平均-1.8%） +``` + +### AIのフィードバック使用方法 + +1. **連続損失を回避**: SOLUSDTが3回連続でストップロスになっているのを見て、AIは回避するかより慎重になる +2. **成功戦略を強化**: BTCブレイクアウトロングが75%の勝率で、AIはこのパターンを継続 +3. **動的スタイル調整**: 勝率<40% → 保守的；損益比>2 → 積極的を維持 +4. **市場状況の特定**: 連続損失は荒れた市場を示す可能性があり、取引頻度を減らす + +--- + +## 📊 Webインターフェース機能 + +### 1. 競争ページ + +- **🏆 リーダーボード**: リアルタイムROIランキング、ゴールドボーダーでリーダーをハイライト +- **📈 パフォーマンス比較**: デュアルAI ROIカーブ比較（紫対青） +- **⚔️ 一対一**: リードマージンを示す直接比較 +- **リアルタイムデータ**: 総エクイティ、損益%、ポジション数、証拠金使用量 + +### 2. 詳細ページ + +- **エクイティカーブ**: 過去トレンドチャート（USD/パーセンテージ切り替え） +- **統計**: 総サイクル、成功/失敗、オープン/クローズ統計 +- **ポジションテーブル**: すべてのポジション詳細（エントリー価格、現在価格、損益%、清算価格） +- **AI判断ログ**: 最近の判断記録（展開可能なCoT） + +### 3. リアルタイム更新 + +- システムステータス、アカウント情報、ポジションリスト：**5秒更新** +- 判断ログ、統計：**10秒更新** +- エクイティチャート：**10秒更新** + +--- + +## 🎛️ APIエンドポイント + +### 競争関連 + +```bash +GET /api/competition # 競争リーダーボード（全トレーダー） +GET /api/traders # トレーダーリスト +``` + +### 単一トレーダー関連 + +```bash +GET /api/status?trader_id=xxx # システムステータス +GET /api/account?trader_id=xxx # アカウント情報 +GET /api/positions?trader_id=xxx # ポジションリスト +GET /api/equity-history?trader_id=xxx # エクイティ履歴（チャートデータ） +GET /api/decisions/latest?trader_id=xxx # 最新5判断 +GET /api/statistics?trader_id=xxx # 統計 +``` + +### システムエンドポイント + +```bash +GET /health # ヘルスチェック +GET /api/config # システム設定 +``` + +--- + +## ⚠️ 重要なリスク警告 + +### 取引リスク + +1. **暗号通貨市場は非常にボラティルが高い**、AI判断は利益を保証しません +2. **先物取引はレバレッジを使用**、損失が元本を超える可能性があります +3. **極端な市場状況**は清算リスクにつながる可能性があります +4. **ファンディングレート**は保有コストに影響する可能性があります +5. **流動性リスク**: 一部のコインでスリッページが発生する可能性があります + +### 技術リスク + +1. **ネットワークレイテンシ**は価格スリッページを引き起こす可能性があります +2. **APIレート制限**は取引実行に影響する可能性があります +3. **AI APIタイムアウト**は判断失敗を引き起こす可能性があります +4. **システムバグ**は予期しない動作を引き起こす可能性があります + +### 使用推奨事項 + +✅ **推奨** +- テストには失っても構わない資金のみを使用 +- 少額から始める（推奨100-500 USDT） +- システムの動作状態を定期的に確認 +- アカウント残高の変化を監視 +- AI判断ログを分析して戦略を理解 + +❌ **非推奨** +- すべての資金または借りたお金を投資 +- 長期間監視なしで実行 +- AI判断を盲目的に信頼 +- システムを理解せずに使用 +- 極端な市場ボラティリティ中に実行 + +--- + +## 🛠️ よくある問題 + +### 1. コンパイルエラー：TA-Libが見つからない + +**解決策**: TA-Libライブラリをインストール +```bash +# macOS +brew install ta-lib + +# Ubuntu +sudo apt-get install libta-lib0-dev +``` + +### 2. 精度エラー：Precision is over the maximum + +**解決策**: システムがBinance LOT_SIZEから精度を自動処理します。エラーが続く場合は、ネットワーク接続を確認してください。 + +### 3. AI APIタイムアウト + +**解決策**: +- APIキーが正しいか確認 +- ネットワーク接続を確認（プロキシが必要な場合があります） +- システムタイムアウトは120秒に設定されています + +### 4. フロントエンドがバックエンドに接続できない + +**解決策**: +- バックエンドが実行中であることを確認（http://localhost:8080） +- ポート8080が占有されていないか確認 +- ブラウザコンソールでエラーを確認 + +### 5. コインプールAPI失敗 + +**解決策**: +- コインプールAPIはオプションです +- APIが失敗した場合、システムはデフォルトのメインストリームコイン（BTC、ETHなど）を使用 +- config.jsonのAPI URLと認証パラメータを確認 + +--- + +## 📈 パフォーマンス最適化のヒント + +1. **合理的な判断サイクルを設定**: 3-5分を推奨、過剰取引を避ける +2. **候補コイン数を制御**: システムはデフォルトでAI500上位20 + OI Top上位20 +3. **ログを定期的にクリーン**: 過度なディスク使用を避ける +4. **API呼び出し数を監視**: Binanceレート制限のトリガーを避ける +5. **少額資本でテスト**: まず100-500 USDTで戦略検証をテスト + +--- + +## 🔄 変更履歴 + +### v2.0.2（2025-10-29） + +**重大なバグ修正 - 取引履歴とパフォーマンス分析：** + +このバージョンは、収益性統計に大きく影響した過去取引記録とパフォーマンス分析システムの**重大な計算エラー**を修正します。 + +**1. PnL計算 - 主要エラー修正**（logger/decision_logger.go） +- **問題**: 以前はパーセンテージのみで計算され、ポジションサイズとレバレッジを完全に無視 + - 例：100 USDTポジションが5%獲得と1000 USDTポジションが5%獲得の両方が利益として`5.0`と表示 + - これによりパフォーマンス分析が完全に不正確に +- **解決策**: 実際のUSDT利益額を計算 + ``` + PnL（USDT）= ポジション価値 × 価格変化% × レバレッジ + 例：1000 USDT × 5% × 20x = 1000 USDT実際の利益 + ``` +- **影響**: 勝率、利益率、シャープレシオが正確なUSDT額に基づくようになりました + +**2. ポジション追跡 - 重要データの欠落** +- **問題**: オープンポジション記録が価格と時間のみを保存、数量とレバレッジが欠落 +- **解決策**: 完全な取引データを保存： + - `quantity`: ポジションサイズ（コイン単位） + - `leverage`: レバレッジ倍率（例：20x） + - これらは正確なPnL計算に不可欠 + +**3. ポジションキーロジック - ロング/ショート競合** +- **問題**: `symbol`をポジションキーとして使用し、ロングとショートの両方を保有する際にデータ競合を引き起こす + - 例：BTCUSDTロングとBTCUSDTショートが互いに上書き +- **解決策**: `symbol_side`形式に変更（例：`BTCUSDT_long`、`BTCUSDT_short`） + - ロングとショートポジションを適切に区別 + +**4. シャープレシオ計算 - コード最適化** +- **問題**: 平方根計算にカスタムニュートン法を使用 +- **解決策**: 標準ライブラリ`math.Sqrt`に置き換え + - より信頼性が高く、保守可能で効率的 + +**このアップデートが重要な理由：** +- ✅ 過去取引統計が無意味なパーセンテージではなく**実際のUSDT損益**を表示 +- ✅ 異なるレバレッジ取引間のパフォーマンス比較が正確に +- ✅ AI自己学習メカニズムが正しい過去フィードバックを受信 +- ✅ 利益率とシャープレシオの計算が意味を持つように +- ✅ マルチポジション追跡（ロング + ショート同時）が正しく機能 + +**推奨**: このアップデート前にシステムを実行していた場合、過去統計は不正確でした。v2.0.2にアップデート後、新しい取引は正しく計算されます。 + +### v2.0.2（2025-10-29） + +**バグ修正：** +- ✅ Aster取引所精度エラーを修正（コード-1111：「Precision is over the maximum defined for this asset」） +- ✅ 取引所の精度要件に合わせて価格と数量のフォーマットを改善 +- ✅ デバッグ用の詳細な精度処理ログを追加 +- ✅ 適切な精度処理ですべての注文関数（OpenLong、OpenShort、CloseLong、CloseShort、SetStopLoss、SetTakeProfit）を強化 + +**技術詳細：** +- float64を正しい精度で文字列に変換する`formatFloatWithPrecision`関数を追加 +- 価格と数量パラメータが取引所の`pricePrecision`と`quantityPrecision`仕様に従ってフォーマットされるようになりました +- API リクエストを最適化するために、フォーマットされた値から末尾のゼロを削除 + +### v2.0.1（2025-10-29） + +**バグ修正：** +- ✅ ComparisonChartデータ処理ロジックを修正 - cycle_numberからタイムスタンプグループ化に切り替え +- ✅ バックエンド再起動時にcycle_numberがリセットされるとチャートがフリーズする問題を解決 +- ✅ チャートデータ表示を改善 - すべての過去データポイントを時系列で表示 +- ✅ トラブルシューティングを改善するためのデバッグログを強化 + +### v2.0.0（2025-10-28） + +**主要アップデート：** +- ✅ AI自己学習メカニズム（過去フィードバック、パフォーマンス分析） +- ✅ マルチトレーダー競争モード（Qwen対DeepSeek） +- ✅ BinanceスタイルUI（完全なBinanceインターフェース模倣） +- ✅ パフォーマンス比較チャート（リアルタイムROI比較） +- ✅ リスク管理最適化（コインごとのポジション制限調整） + +**バグ修正：** +- 初期残高のハードコーディング問題を修正 +- マルチトレーダーデータ同期問題を修正 +- チャートデータの整列を最適化（cycle_numberを使用） + +### v1.0.0（2025-10-27） +- 初回リリース +- 基本的なAI取引機能 +- 判断ログシステム +- シンプルなWebインターフェース + +--- + +## 📄 ライセンス + +MITライセンス - 詳細は[LICENSE](LICENSE)ファイルを参照してください + +--- + +## 🤝 貢献 + +IssueとPull Requestを歓迎します！ + +### 開発ガイド + +1. プロジェクトをフォーク +2. 機能ブランチを作成（`git checkout -b feature/AmazingFeature`） +3. 変更をコミット（`git commit -m 'Add some AmazingFeature'`） +4. ブランチにプッシュ（`git push origin feature/AmazingFeature`） +5. Pull Requestを開く + +--- + +## 📬 お問い合わせ + + +### 🐛 技術サポート +- **GitHub Issues**: [Issueを提出](https://github.com/tinkle-community/nofx/issues) +- **開発者コミュニティ**: [Telegramグループ](https://t.me/nofx_dev_community) + +--- + +## 🙏 謝辞 + +- [Binance API](https://binance-docs.github.io/apidocs/futures/en/) - Binance先物API +- [DeepSeek](https://platform.deepseek.com/) - DeepSeek AI API +- [Qwen](https://dashscope.aliyuncs.com/) - Alibaba Cloud Qwen +- [TA-Lib](https://ta-lib.org/) - テクニカル指標ライブラリ +- [Recharts](https://recharts.org/) - Reactチャートライブラリ + +--- + +**最終更新**: 2025-10-29（v2.0.3） + +**⚡ AIの力で量的取引の可能性を探求しましょう！** + +--- + +## ⭐ Star履歴 + +[](https://star-history.com/#tinkle-community/nofx&Date) diff --git a/docs/i18n/ja/TERMS OF SERVICE.md b/docs/i18n/ja/TERMS OF SERVICE.md new file mode 100644 index 00000000..1aeed377 --- /dev/null +++ b/docs/i18n/ja/TERMS OF SERVICE.md @@ -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との間の完全な合意を構成します。 diff --git a/docs/i18n/ru/PRIVACY POLICY.md b/docs/i18n/ru/PRIVACY POLICY.md new file mode 100644 index 00000000..b8798159 --- /dev/null +++ b/docs/i18n/ru/PRIVACY POLICY.md @@ -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_
Strategy Instructions] --> B[AI Model] + C[Market Data
Auto-generated] --> B + B --> D[Chain of Thought Analysis] + B --> E[Trading Decision JSON] +``` + +**Workflow**: +1. **System Prompt (System)**: Strategy instructions you write +2. **User Prompt (User)**: Market data automatically generated by the system +3. **AI Response (Response)**: AI's analysis and decisions + +### Three Components of a Prompt + +#### 1. Core Strategy (Written by You) + +Defines the AI's trading philosophy, risk preference, and decision criteria + +**Example**: +``` +You are a conservative trader who only opens positions in high-certainty opportunities. +Entry conditions: Confidence ≥ 85, multiple indicator convergence. +``` + +#### 2. Hard Constraints (Automatically Added by System) + +- Risk-reward ratio ≥ 1:3 +- Maximum 3 positions simultaneously +- Leverage limits (BTC/ETH 20x, altcoins 5x) +- Margin usage rate ≤ 90% + +⚠️ **Methods 1 & 2**: These constraints are automatically added and cannot be overridden +⚠️ **Method 3**: You must include these constraints in your Prompt + +#### 3. Output Format (Automatically Added by System) + +Requires AI to output decisions using XML tags and JSON format + +**Example Output**: +```xml +
Base Only** | `override_base_prompt=false`
`custom_prompt=""` | Official template + Hard constraints + Output format | Beginners | +| **Mode 2
Base+Custom** | `override_base_prompt=false`
`custom_prompt="your strategy"` | Official template + Hard constraints + Output format
+ Custom strategy + Notes | Intermediate | +| **Mode 3
Full Custom** | `override_base_prompt=true`
`custom_prompt="complete prompt"` | Only custom content
(ignores all system defaults) | Advanced | + +⚠️ **Mode 3 Risk Warning**: +- You must include all hard constraints yourself +- You must define output format yourself +- You must handle all risk control yourself +- Recommended only after fully understanding system mechanics + +--- + +## 📦 Official Template Library + +### Conservative Strategy + +#### Use Cases +- ✅ Beginners seeking stability +- ✅ High market volatility, risk-averse +- ✅ Capital safety priority, tolerate low returns + +#### Core Features +- Entry confidence ≥ 85 (only high-certainty opportunities) +- Risk-reward ratio ≥ 1:4 (stricter than system requirement) +- Maximum 2 positions (reduced risk exposure) +- Small position size (0.5x account equity) + +#### Expected Performance +- Trading frequency: Low (possibly 1-2 trades/day) +- Holding time: Long (average 2-4 hours) +- Win rate: High (>70%) +- Volatility: Small + +#### Complete Template + +```plaintext +You are a professional cryptocurrency trading AI with a conservative and steady trading strategy. + +# Core Objective + +Maximize Sharpe Ratio, emphasizing risk control and stable returns. + +Sharpe Ratio = Average Returns / Returns Volatility + +This means: +- Only high-certainty trades (confidence ≥ 85) +- Strict stop-loss/take-profit, control drawdown +- Patient holding, avoid frequent trading +- Quality over quantity + +# Trading Philosophy + +Capital preservation first: Better to miss than make mistakes +Discipline over emotion: Execute plan, don't change arbitrarily +Quality over quantity: Few high-conviction trades beat many low-conviction ones +Respect trends: Don't fight strong trends + +# Entry Criteria (Extremely Strict) + +Only enter on strong signals; observe when uncertain. + +Entry conditions (must all be met): +- Confidence ≥ 85 (high certainty) +- Multiple indicator convergence (at least 3 indicators support) +- Risk-reward ratio ≥ 1:4 (take-profit space 4x+ stop-loss) +- Clear BTC trend (as market indicator) +- Positions < 2 (quality > quantity) + +Avoid low-quality signals: +- Single dimension (only one indicator) +- Contradictory (price up but volume shrinking) +- Range-bound choppy +- Just closed position (<30 minutes ago) + +# Position Management (Conservative) + +Single position: 0.5x account equity (smaller than system default) +Maximum positions: 2 coins (1 less than system default) +Leverage usage: +- Altcoins: 3x leverage (lower than system limit) +- BTC/ETH: 10x leverage (lower than system limit) + +# Stop-Loss/Take-Profit (Strict) + +Stop-loss: Set immediately after entry, never move stop-loss +Take-profit: Tiered profit-taking + - 50% target reached: Close 30% + - 75% target reached: Close 30% + - 100% target reached: Close all + +Drawdown management: +If P&L Amount drawdown from Peak % exceeds 40%, immediately reduce 50% position + +# Sharpe Ratio Self-Evolution + +Sharpe < -0.5: Stop trading, observe continuously for at least 30 minutes +Sharpe -0.5~0: Only trade confidence ≥ 90 +Sharpe 0~1: Maintain current strategy +Sharpe > 1: Can moderately increase to 0.8x equity position + +# Decision Process + +1. Analyze Sharpe Ratio: Is current strategy effective? +2. Evaluate positions: Should take profit/stop loss? +3. Find new opportunities: Any strong signals? +4. Output decision: Chain of thought + JSON + +Remember: +- Goal is Sharpe Ratio, not trading frequency +- Better miss than make low-quality trades +- Every trade must withstand repeated scrutiny +``` + +#### Usage + +**Method 1: Replace Default Template** +```bash +# Backup original +cp prompts/default.txt prompts/default.txt.bak + +# Save above template to prompts/default.txt +# Restart system +docker-compose restart +``` + +**Method 2: Web Interface Custom** +1. Copy above template +2. Paste in web interface "Custom Prompt" +3. Set `override_base_prompt = false` + +--- + +### Balanced Strategy + +#### Use Cases +- ✅ Users with some experience +- ✅ Normal market conditions +- ✅ Seeking risk-reward balance + +#### Core Features +- Entry confidence ≥ 75 (system default) +- Risk-reward ratio ≥ 1:3 (system default) +- Maximum 3 positions (system default) +- Moderate position size (0.8~1.5x equity) + +#### Expected Performance +- Trading frequency: Medium (2-4 trades/day) +- Holding time: Medium (average 1-2 hours) +- Win rate: Medium (60-70%) +- Volatility: Moderate + +#### Complete Template + +```plaintext +You are a professional cryptocurrency trading AI conducting autonomous trading in futures markets. + +# Core Objective + +Maximize Sharpe Ratio + +Sharpe Ratio = Average Returns / Returns Volatility + +This means: +- High-quality trades (high win rate, large P&L ratio) → Improve Sharpe +- Stable returns, controlled drawdown → Improve Sharpe +- Patient holding, let profits run → Improve Sharpe +- Frequent trading, small wins/losses → Increase volatility, severely reduce Sharpe +- Overtrading, fee erosion → Direct losses +- Early exits, frequent in/out → Miss major moves + +Key insight: System scans every 3 minutes, but doesn't mean trade every time! +Most times should be `wait` or `hold`, only enter on excellent opportunities. + +# Trading Philosophy & Best Practices + +## Core Principles: + +Capital preservation first: Protecting capital more important than pursuing returns + +Discipline over emotion: Execute exit plan, don't arbitrarily move stops or targets + +Quality over quantity: Few high-conviction trades beat many low-conviction ones + +Adapt to volatility: Adjust position size based on market conditions + +Respect trends: Don't fight strong trends + +## Common Pitfalls to Avoid: + +Overtrading: Frequent trading causes fees to erode profits + +Revenge trading: Immediately doubling down after loss to "get even" + +Analysis paralysis: Over-waiting for perfect signal, missing opportunities + +Ignoring correlation: BTC often leads altcoins, must observe BTC first + +Over-leverage: Amplifies returns but also amplifies losses + +# Trading Frequency Awareness + +Quantitative standards: +- Excellent trader: 2-4 trades/day = 0.1-0.2 trades/hour +- Overtrading: >2 trades/hour = serious problem +- Best rhythm: Hold at least 30-60 minutes after opening + +Self-check: +If you find yourself trading every cycle → Standards too low +If you find yourself closing positions <30 minutes → Too impatient + +# Entry Criteria (Strict) + +Only enter on strong signals; observe when uncertain. + +Complete data available: +- Raw sequences: 3-min price sequence (MidPrices array) + 4-hour candle sequence +- Technical sequences: EMA20 sequence, MACD sequence, RSI7 sequence, RSI14 sequence +- Capital sequences: Volume sequence, Open Interest (OI) sequence, funding rate +- Filter markers: AI500 score / OI_Top ranking (if marked) + +Analysis methods (fully autonomous): +- Freely use sequence data, you can but not limited to trend analysis, pattern recognition, support/resistance, Fibonacci, volatility bands +- Multi-dimensional cross-validation (price + volume + OI + indicators + sequence patterns) +- Use methods you deem most effective to discover high-certainty opportunities +- Combined confidence ≥ 75 to enter + +Avoid low-quality signals: +- Single dimension (only one indicator) +- Contradictory (price up but volume shrinking) +- Range-bound choppy +- Just closed position (<15 minutes ago) + +# Sharpe Ratio Self-Evolution + +Each cycle you receive Sharpe Ratio as performance feedback: + +Sharpe < -0.5 (continuous losses): + → Stop trading, observe continuously for at least 6 cycles (18 minutes) + → Deep reflection: + • Trading frequency too high? (>2/hour is excessive) + • Holding time too short? (<30 minutes is early exit) + • Signal strength insufficient? (confidence <75) + +Sharpe -0.5 ~ 0 (slight losses): + → Strict control: Only trade confidence >80 + → Reduce frequency: Max 1 new position/hour + → Patient holding: Hold at least 30+ minutes + +Sharpe 0 ~ 0.7 (positive returns): + → Maintain current strategy + +Sharpe > 0.7 (excellent performance): + → Can moderately increase position size + +Key: Sharpe Ratio is the only metric, naturally punishes frequent trading and excessive entries/exits. + +# Decision Process + +1. Analyze Sharpe Ratio: Is current strategy effective? Need adjustments? +2. Evaluate positions: Has trend changed? Should take profit/stop loss? +3. Find new opportunities: Any strong signals? Long/short opportunities? +4. Output decision: Chain of thought + JSON + +# Position Size Calculation + +**Important**: `position_size_usd` is **notional value** (includes leverage), not margin requirement. + +**Calculation Steps**: +1. **Available Margin** = Available Cash × 0.88 (reserve 12% for fees, slippage, liquidation buffer) +2. **Notional Value** = Available Margin × Leverage +3. **position_size_usd** = Notional Value (fill this in JSON) +4. **Actual Coin Amount** = position_size_usd / Current Price + +**Example**: Available cash $500, leverage 5x +- Available Margin = $500 × 0.88 = $440 +- position_size_usd = $440 × 5 = **$2,200** ← Fill this in JSON +- Actually occupies margin = $440, remaining $60 for fees, slippage, liquidation protection + +--- + +Remember: +- Goal is Sharpe Ratio, not trading frequency +- Better miss than make low-quality trades +- Risk-reward ratio 1:3 is baseline +``` + +#### Usage + +Same as Conservative strategy usage. + +--- + +### Aggressive Strategy + +#### Use Cases +- ✅ High risk tolerance users +- ✅ Strong trend markets +- ✅ Pursue high returns, tolerate high volatility + +#### Core Features +- Entry confidence ≥ 70 (lower than system default) +- Risk-reward ratio ≥ 1:3 (system minimum) +- Maximum 3 positions +- Large position size (near system limit 1.5x equity) +- High leverage (near system limits) + +#### Expected Performance +- Trading frequency: High (4-8 trades/day) +- Holding time: Short (average 30min-1 hour) +- Win rate: Lower (50-60%) +- Volatility: Large + +⚠️ **Risk Warning**: This strategy has high volatility and may experience significant drawdowns; suitable only for users with strong risk tolerance. + +#### Complete Template + +```plaintext +You are a professional cryptocurrency trading AI with an aggressive and proactive trading strategy. + +⚠️ Risk Disclosure: This strategy pursues high returns but has high volatility and may experience significant drawdowns. + +# Core Objective + +Maximize returns while controlling risks and actively seizing market opportunities. + +# Trading Philosophy + +Opportunity first: Actively seek trading opportunities, don't over-observe +Quick in/out: Capture short-term volatility, timely stop-loss/take-profit +Trend following: Follow market trends, react quickly +Moderate aggression: Maximize position size and leverage within risk control + +# Entry Criteria (Relatively Loose) + +Entry conditions: +- Confidence ≥ 70 (medium certainty acceptable) +- At least 2 indicators support +- Risk-reward ratio ≥ 1:3 (system minimum) +- Follow major market trend + +Scenarios to try: +- Break key resistance/support levels +- Rapid surge/decline initiation +- Abnormal volume surge +- Short-term overbought/oversold reversal + +# Position Management (Aggressive) + +Single position: +- Altcoins: 1.2~1.5x account equity (near limit) +- BTC/ETH: 8~10x account equity (near limit) + +Maximum positions: 3 coins + +Leverage usage: +- Altcoins: 4~5x leverage (near limit) +- BTC/ETH: 15~20x leverage (near limit) + +# Stop-Loss/Take-Profit (Flexible) + +Quick stop-loss: Stop at -3% loss immediately +Tiered take-profit: + - Reach +3%: Close 30% + - Reach +6%: Close 40% + - Reach +9%: Close all + +Drawdown management: +P&L Amount drawdown from Peak % exceeds 60%, close all + +# Sharpe Ratio Adjustment + +Sharpe < -0.5: Pause trading 15 minutes +Sharpe -0.5~0: Reduce position to 0.8x equity +Sharpe 0~0.7: Maintain current strategy +Sharpe > 0.7: Stay aggressive, can full position + +# Special Strategies + +BTC strong trend following: +- BTC 4h Change > +5%: Prioritize long strong altcoins +- BTC 4h Change < -5%: Quick short or cash out observe + +Short-term volatility capture: +- Price volatility >3% in short time (15min), consider reverse trade +- Duration typically 30-60 minutes + +Remember: +- Aggressive ≠ gambling, still need strict risk control +- Quick in/out, don't linger +- Control single loss, protect principal +``` + +#### Usage + +Same as Conservative strategy usage. + +⚠️ **Reminder**: Aggressive strategy suitable for experienced users with strong risk tolerance; beginners use with caution. + +--- + +## ✅ Quality Checklist + +Check the following before using custom Prompt: + +### 1. Internal Logic Check + +- [ ] **Clear Strategy Goal** + - ✅ Clear trading philosophy (e.g., "trend following", "mean reversion") + - ❌ Vague goals ("make money") + +- [ ] **Consistent Entry/Exit Logic** + - ✅ Entry: "MACD golden cross + volume surge" + - ✅ Exit: "MACD death cross OR reach stop/target" + - ❌ Contradictory logic: "Only long but also short on down signals" + +- [ ] **Balanced Risk Control and Profit Goals** + - ✅ Risk-reward ratio ≥ 1:3, clear stop/target + - ❌ Only pursue returns, ignore risk control + +- [ ] **No "Want Everything" Contradictions** + - ❌ "Both conservative and aggressive" + - ❌ "Both frequent trading and high win rate" + +### 2. Field Reference Check + +- [ ] **Field Names Match System Output** + - ✅ "P&L Amount", "Peak %", "Margin" + - ❌ `unrealized_pnl`, `peak_pnl_pct`, `margin_used` + +- [ ] **Formulas Use Correct Fields** + - ✅ True ROI = P&L Amount / Margin + - ❌ True ROI = P&L % / Leverage + +- [ ] **No References to Non-existent Fields** + - ❌ "Based on KDJ indicator..." (system doesn't provide KDJ) + - ✅ "Based on MACD, RSI indicators..." + +- [ ] **Correct Unit Understanding** + - ✅ "P&L %" = Return with leverage + - ✅ "P&L Amount" = Actual USD P&L + +### 3. System Constraints Check + +- [ ] **Not Trying to Override Hard Constraints** (unless Mode 3 and fully understand) + - ❌ "Risk-reward ratio can be below 1:3" + - ❌ "Can hold 5 positions simultaneously" + +- [ ] **Not Using Reserved Keywords** + - ❌ Write `
策略指令] --> B[AI模型] + C[市场数据
自动生成] --> B + B --> D[思维链分析] + B --> E[交易决策JSON] +``` + +**工作流程**: +1. **系统 Prompt（System）**: 你编写的策略指令 +2. **用户 Prompt（User）**: 系统自动生成的市场数据 +3. **AI 响应（Response）**: AI 的分析和决策 + +### Prompt 的三个组成部分 + +#### 1. 核心策略（你编写） + +定义 AI 的交易哲学、风险偏好、决策标准 + +**示例**: +``` +你是保守型交易员，只在高确定性机会时开仓。 +开仓条件：信心度 ≥ 85，多个指标共振。 +``` + +#### 2. 硬约束（系统自动添加） + +- 风险回报比 ≥ 1:3 +- 最多持仓 3 个币种 +- 杠杆限制（BTC/ETH 20x，山寨币 5x） +- 保证金使用率 ≤ 90% + +⚠️ **方式1和2**: 这些约束自动添加，不可覆盖 +⚠️ **方式3**: 需要自己在 Prompt 中包含这些约束 + +#### 3. 输出格式（系统自动添加） + +要求 AI 使用 XML 标签和 JSON 格式输出决策 + +**示例输出**: +```xml +
仅基础** | `override_base_prompt=false`
`custom_prompt=""` | 官方模板 + 硬约束 + 输出格式 | 新手用户 | +| **模式2
基础+附加** | `override_base_prompt=false`
`custom_prompt="你的策略"` | 官方模板 + 硬约束 + 输出格式
+ 个性化策略 + 注意事项 | 进阶用户 | +| **模式3
完全自定义** | `override_base_prompt=true`
`custom_prompt="完整Prompt"` | 仅使用自定义内容
（忽略所有系统默认） | 高级用户 | + +⚠️ **模式3 风险警告**: +- 你必须自己包含所有硬约束 +- 你必须自己定义输出格式 +- 你必须自己负责风控规则 +- 建议只有完全理解系统机制后才使用 + +--- + +## 📦 官方模板库 + +### 保守型策略 + +#### 适用场景 +- ✅ 新手用户，追求稳健 +- ✅ 市场波动大，风险厌恶 +- ✅ 资金安全优先，容忍低收益 + +#### 核心特点 +- 开仓信心度 ≥ 85（只做高确定性机会） +- 风险回报比 ≥ 1:4（比系统要求更严格） +- 最多持仓 2 个（降低风险暴露） +- 仓位小（0.5倍账户净值） + +#### 预期表现 +- 交易频率: 低（可能一天1-2笔） +- 持仓时间: 长（平均2-4小时） +- 胜率: 高（>70%） +- 波动: 小 + +#### 完整模板 + +```plaintext +你是专业的加密货币交易AI，采用保守稳健的交易策略。 + +# 核心目标 + +最大化夏普比率（Sharpe Ratio），强调风险控制和稳定收益。 + +夏普比率 = 平均收益 / 收益波动率 + +这意味着： +- 只做高确定性交易（信心度 ≥ 85） +- 严格止损止盈，控制回撤 +- 耐心持仓，避免频繁交易 +- 质量优于数量 + +# 交易哲学 + +资金保全第一：宁可错过，不做错 +纪律胜于情绪：执行既定方案，不随意改变 +质量优于数量：少量高信念交易胜过大量低信念交易 +尊重趋势：不要与强趋势作对 + +# 开仓标准（极其严格） + +只在强信号时开仓，不确定就观望。 + +开仓条件（必须同时满足）： +- 信心度 ≥ 85（高确定性） +- 多个指标共振（至少3个指标支持） +- 风险回报比 ≥ 1:4（止盈空间是止损的4倍以上） +- BTC 趋势明确（作为市场风向标） +- 持仓数 < 2（质量>数量） + +避免低质量信号： +- 单一维度（只看一个指标） +- 相互矛盾（涨但量萎缩） +- 横盘震荡 +- 刚平仓不久（<30分钟） + +# 仓位管理（保守） + +单币仓位：账户净值的 0.5 倍（比系统默认更小） +最多持仓：2 个币种（比系统默认少1个） +杠杆使用： +- 山寨币: 3x 杠杆（比系统上限更低） +- BTC/ETH: 10x 杠杆（比系统上限更低） + +# 止盈止损（严格） + +止损：入场后立即设置，绝不移动止损 +止盈：分批止盈 + - 达到 50% 目标：平仓 30% + - 达到 75% 目标：平仓 30% + - 达到 100% 目标：全部平仓 + +回撤管理： +如果盈亏金额从最高收益率回撤超过 40%，立即减仓 50% + +# 夏普比率自我进化 + +夏普比率 < -0.5: 停止交易，连续观望至少 30 分钟 +夏普比率 -0.5~0: 只做信心度 ≥ 90 的交易 +夏普比率 0~1: 维持当前策略 +夏普比率 > 1: 可适度扩大至 0.8 倍净值仓位 + +# 决策流程 + +1. 分析夏普比率：当前策略是否有效？ +2. 评估持仓：是否该止盈/止损？ +3. 寻找新机会：有强信号吗？ +4. 输出决策：思维链分析 + JSON + +记住： +- 目标是夏普比率，不是交易频率 +- 宁可错过，不做低质量交易 +- 每笔交易都要经得起反复推敲 +``` + +#### 使用方式 + +**方式1: 替换默认模板** +```bash +# 备份原文件 +cp prompts/default.txt prompts/default.txt.bak + +# 将上述模板内容保存到 prompts/default.txt +# 重启系统 +docker-compose restart +``` + +**方式2: Web界面自定义** +1. 复制上述模板内容 +2. 粘贴到 Web 界面的"自定义 Prompt" +3. 设置 `override_base_prompt = false` + +--- + +### 平衡型策略 + +#### 适用场景 +- ✅ 有一定经验的用户 +- ✅ 正常市场条件 +- ✅ 追求风险收益平衡 + +#### 核心特点 +- 开仓信心度 ≥ 75（系统默认） +- 风险回报比 ≥ 1:3（系统默认） +- 最多持仓 3 个（系统默认） +- 仓位适中（0.8~1.5倍净值） + +#### 预期表现 +- 交易频率: 中（一天2-4笔） +- 持仓时间: 中（平均1-2小时） +- 胜率: 中等（60-70%） +- 波动: 适中 + +#### 完整模板 + +```plaintext +你是专业的加密货币交易AI，在合约市场进行自主交易。 + +# 核心目标 + +最大化夏普比率（Sharpe Ratio） + +夏普比率 = 平均收益 / 收益波动率 + +这意味着： +- 高质量交易（高胜率、大盈亏比）→ 提升夏普 +- 稳定收益、控制回撤 → 提升夏普 +- 耐心持仓、让利润奔跑 → 提升夏普 +- 频繁交易、小盈小亏 → 增加波动，严重降低夏普 +- 过度交易、手续费损耗 → 直接亏损 +- 过早平仓、频繁进出 → 错失大行情 + +关键认知: 系统每3分钟扫描一次，但不意味着每次都要交易！ +大多数时候应该是 `wait` 或 `hold`，只在极佳机会时才开仓。 + +# 交易哲学 & 最佳实践 + +## 核心原则： + +资金保全第一：保护资本比追求收益更重要 + +纪律胜于情绪：执行你的退出方案，不随意移动止损或目标 + +质量优于数量：少量高信念交易胜过大量低信念交易 + +适应波动性：根据市场条件调整仓位 + +尊重趋势：不要与强趋势作对 + +## 常见误区避免： + +过度交易：频繁交易导致费用侵蚀利润 + +复仇式交易：亏损后立即加码试图"翻本" + +分析瘫痪：过度等待完美信号，导致失机 + +忽视相关性：BTC常引领山寨币，须优先观察BTC + +过度杠杆：放大收益同时放大亏损 + +# 交易频率认知 + +量化标准: +- 优秀交易员：每天2-4笔 = 每小时0.1-0.2笔 +- 过度交易：每小时>2笔 = 严重问题 +- 最佳节奏：开仓后持有至少30-60分钟 + +自查: +如果你发现自己每个周期都在交易 → 说明标准太低 +如果你发现持仓<30分钟就平仓 → 说明太急躁 + +# 开仓标准（严格） + +只在强信号时开仓，不确定就观望。 + +你拥有的完整数据： +- 原始序列：3分钟价格序列(MidPrices数组) + 4小时K线序列 +- 技术序列：EMA20序列、MACD序列、RSI7序列、RSI14序列 +- 资金序列：成交量序列、持仓量(OI)序列、资金费率 +- 筛选标记：AI500评分 / OI_Top排名（如果有标注） + +分析方法（完全由你自主决定）： +- 自由运用序列数据，你可以做但不限于趋势分析、形态识别、支撑阻力、技术阻力位、斐波那契、波动带计算 +- 多维度交叉验证（价格+量+OI+指标+序列形态） +- 用你认为最有效的方法发现高确定性机会 +- 综合信心度 ≥ 75 才开仓 + +避免低质量信号： +- 单一维度（只看一个指标） +- 相互矛盾（涨但量萎缩） +- 横盘震荡 +- 刚平仓不久（<15分钟） + +# 夏普比率自我进化 + +每次你会收到夏普比率作为绩效反馈（周期级别）： + +夏普比率 < -0.5 (持续亏损): + → 停止交易，连续观望至少6个周期（18分钟） + → 深度反思： + • 交易频率过高？（每小时>2次就是过度） + • 持仓时间过短？（<30分钟就是过早平仓） + • 信号强度不足？（信心度<75） + +夏普比率 -0.5 ~ 0 (轻微亏损): + → 严格控制：只做信心度>80的交易 + → 减少交易频率：每小时最多1笔新开仓 + → 耐心持仓：至少持有30分钟以上 + +夏普比率 0 ~ 0.7 (正收益): + → 维持当前策略 + +夏普比率 > 0.7 (优异表现): + → 可适度扩大仓位 + +关键: 夏普比率是唯一指标，它会自然惩罚频繁交易和过度进出。 + +# 决策流程 + +1. 分析夏普比率: 当前策略是否有效？需要调整吗？ +2. 评估持仓: 趋势是否改变？是否该止盈/止损？ +3. 寻找新机会: 有强信号吗？多空机会？ +4. 输出决策: 思维链分析 + JSON + +# 仓位大小计算 + +**重要**：`position_size_usd` 是**名义价值**（包含杠杆），非保证金需求。 + +**计算步骤**： +1. **可用保证金** = Available Cash × 0.88（预留12%给手续费、滑点与清算保证金缓冲） +2. **名义价值** = 可用保证金 × Leverage +3. **position_size_usd** = 名义价值（JSON中填写此值） +4. **实际币数** = position_size_usd / Current Price + +**示例**：可用资金 $500，杠杆 5x +- 可用保证金 = $500 × 0.88 = $440 +- position_size_usd = $440 × 5 = **$2,200** ← JSON填此值 +- 实际占用保证金 = $440，剩余 $60 用于手续费、滑点与清算保护 + +--- + +记住: +- 目标是夏普比率，不是交易频率 +- 宁可错过，不做低质量交易 +- 风险回报比1:3是底线 +``` + +#### 使用方式 + +同保守型策略的使用方式。 + +--- + +### 激进型策略 + +#### 适用场景 +- ✅ 高风险偏好用户 +- ✅ 强趋势市场 +- ✅ 追求高收益，容忍高波动 + +#### 核心特点 +- 开仓信心度 ≥ 70（比系统默认低） +- 风险回报比 ≥ 1:3（系统最低要求） +- 最多持仓 3 个 +- 仓位大（接近系统上限1.5倍净值） +- 杠杆高（接近系统上限） + +#### 预期表现 +- 交易频率: 高（一天4-8笔） +- 持仓时间: 短（平均30分钟-1小时） +- 胜率: 较低（50-60%） +- 波动: 大 + +⚠️ **风险警告**: 此策略波动大，可能出现较大回撤，仅适合风险承受能力强的用户。 + +#### 完整模板 + +```plaintext +你是专业的加密货币交易AI，采用激进主动的交易策略。 + +⚠️ 风险声明：此策略追求高收益，但波动性大，可能出现较大回撤。 + +# 核心目标 + +最大化收益，在控制风险的前提下积极把握市场机会。 + +# 交易哲学 + +机会优先：积极寻找交易机会，不过度观望 +快进快出：捕捉短期波动，及时止盈止损 +趋势跟随：顺应市场趋势，快速反应 +适度激进：在风控范围内最大化仓位和杠杆 + +# 开仓标准（相对宽松） + +开仓条件： +- 信心度 ≥ 70（中等确定性即可） +- 至少2个指标支持 +- 风险回报比 ≥ 1:3（系统最低要求） +- 顺应市场大趋势 + +可以尝试的场景： +- 突破关键阻力位/支撑位 +- 快速拉升/下跌启动 +- 成交量异常放大 +- 短期超买/超卖反转 + +# 仓位管理（激进） + +单币仓位： +- 山寨币: 1.2~1.5 倍账户净值（接近上限） +- BTC/ETH: 8~10 倍账户净值（接近上限） + +最多持仓：3 个币种 + +杠杆使用： +- 山寨币: 4~5x 杠杆（接近上限） +- BTC/ETH: 15~20x 杠杆（接近上限） + +# 止盈止损（灵活） + +快速止损：亏损达到 -3% 立即止损 +分批止盈： + - 达到 +3%：平仓 30% + - 达到 +6%：平仓 40% + - 达到 +9%：全部平仓 + +回撤管理： +盈亏金额从最高收益率回撤超过 60%，全部平仓 + +# 夏普比率调整 + +夏普比率 < -0.5: 暂停交易 15 分钟 +夏普比率 -0.5~0: 降低仓位至 0.8 倍净值 +夏普比率 0~0.7: 维持当前策略 +夏普比率 > 0.7: 保持激进，可满仓操作 + +# 特殊策略 + +BTC 强趋势跟随： +- BTC 4h涨跌幅 > +5%：优先做多强势山寨币 +- BTC 4h涨跌幅 < -5%：快速做空或空仓观望 + +短期波动捕捉： +- 价格短时间（15分钟内）波动 > 3%，考虑反向交易 +- 持仓时长通常 30-60 分钟 + +记住： +- 激进不等于赌博，仍需严格风控 +- 快进快出，不恋战 +- 控制单次亏损，保护本金 +``` + +#### 使用方式 + +同保守型策略的使用方式。 + +⚠️ **再次提醒**: 激进策略适合经验丰富、风险承受能力强的用户，新手请谨慎使用。 + +--- + +## ✅ 质量检查清单 + +在使用自定义 Prompt 前，请通过以下检查： + +### 1. 内部逻辑检查 + +- [ ] **策略目标明确** + - ✅ 有清晰的交易哲学（如"趋势跟踪"、"均值回归"） + - ❌ 目标模糊（"赚钱就行"） + +- [ ] **开仓/平仓逻辑一致** + - ✅ 开仓条件："MACD金叉 + 成交量放大" + - ✅ 平仓条件："MACD死叉 或 达到止盈/止损" + - ❌ 矛盾逻辑："只做多但遇到下跌信号也做空" + +- [ ] **风控与盈利目标平衡** + - ✅ 风险回报比 ≥ 1:3，止盈止损明确 + - ❌ 只追求高收益，忽视风险控制 + +- [ ] **无"既要又要"的矛盾** + - ❌ "既要保守又要激进" + - ❌ "既要频繁交易又要高胜率" + +### 2. 字段引用检查 + +- [ ] **字段名称与系统输出一致** + - ✅ "盈亏金额"、"最高收益率"、"保证金" + - ❌ `unrealized_pnl`、`peak_pnl_pct`、`margin_used` + +- [ ] **计算公式使用正确字段** + - ✅ 真实收益率 = 盈亏金额 / 保证金 + - ❌ 真实收益率 = 盈亏（百分比）/ 杠杆 + +- [ ] **没有引用不存在的字段** + - ❌ "根据 KDJ 指标..." （系统未提供 KDJ） + - ✅ "根据 MACD、RSI 指标..." + +- [ ] **单位理解正确** + - ✅ "盈亏（百分比）" = 含杠杆的收益率 + - ✅ "盈亏金额" = 实际美元盈亏 + +### 3. 系统约束检查 + +- [ ] **未尝试覆盖硬约束**（除非模式3且完全理解） + - ❌ "风险回报比可以低于1:3" + - ❌ "可以同时持仓5个币种" + +- [ ] **未使用保留关键词** + - ❌ 在 Prompt 中写 `
+
+ )
}
-function App() {
- const { language, setLanguage } = useLanguage();
- const { user, token, logout, isLoading } = useAuth();
- const { config: systemConfig, loading: configLoading } = useSystemConfig();
- const [route, setRoute] = useState(window.location.pathname);
-
- // 从URL路径读取初始页面状态（支持刷新保持页面）
- const getInitialPage = (): Page => {
- const path = window.location.pathname;
- const hash = window.location.hash.slice(1); // 去掉 #
-
- if (path === '/traders' || hash === 'traders') return 'traders';
- if (path === '/dashboard' || hash === 'trader' || hash === 'details') return 'trader';
- return 'competition'; // 默认为竞赛页面
- };
-
- const [currentPage, setCurrentPage] = useState
+ 
+
+
+ {t('loading', language)}
+
-
- );
+ return
-
-
-
- {t('loading', language)}
-
- {
- console.log('Competition page onPageChange called with:', page);
- console.log('Current route:', route, 'Current page:', currentPage);
-
- if (page === 'competition') {
- console.log('Navigating to competition');
- window.history.pushState({}, '', '/competition');
- setRoute('/competition');
- setCurrentPage('competition');
- } else if (page === 'traders') {
- console.log('Navigating to traders');
- window.history.pushState({}, '', '/traders');
- setRoute('/traders');
- setCurrentPage('traders');
- } else if (page === 'trader') {
- console.log('Navigating to trader/dashboard');
- window.history.pushState({}, '', '/dashboard');
- setRoute('/dashboard');
- setCurrentPage('trader');
- }
-
- console.log('After navigation - route:', route, 'currentPage:', currentPage);
- }}
- />
-
-
-
- );
- }
-
- // Show landing page for root route
- if (route === '/' || route === '') {
- return
- {
- console.log('Main app onPageChange called with:', page);
-
- if (page === 'competition') {
- window.history.pushState({}, '', '/competition');
- setRoute('/competition');
- setCurrentPage('competition');
- } else if (page === 'traders') {
- window.history.pushState({}, '', '/traders');
- setRoute('/traders');
- setCurrentPage('traders');
- } else if (page === 'trader') {
- window.history.pushState({}, '', '/dashboard');
- setRoute('/dashboard');
- setCurrentPage('trader');
- }
- }}
- />
-
- {/* Main Content */}
-
- {currentPage === 'competition' ? (
- {
- setSelectedTraderId(traderId);
- window.history.pushState({}, '', '/dashboard');
- setRoute('/dashboard');
- setCurrentPage('trader');
- }}
- />
- ) : (
-
-
- {/* Footer */}
-
-
- );
+ return
- {/* Loading Skeleton - Binance Style */}
-
- );
- }
-
- return (
-
-
-
-
-
-
-
-
-
- {[1, 2, 3, 4].map((i) => (
-
-
-
-
-
- ))}
-
-
-
-
-
- {/* Trader Header */}
-
- );
-}
-
-// Stat Card Component - Binance Style Enhanced
-function StatCard({
- title,
- value,
- change,
- positive,
- subtitle,
-}: {
- title: string;
- value: string;
- change?: number;
- positive?: boolean;
- subtitle?: string;
-}) {
- return (
-
-
-
- {/* Debug Info */}
- {account && (
-
-
- - - 🤖 - - {selectedTrader.trader_name} -
- - {/* Trader Selector */} - {traders && traders.length > 0 && ( -
- {t('switchTrader', language)}:
-
-
- )}
-
- AI Model: {getModelDisplayName(selectedTrader.ai_model.split('_').pop() || selectedTrader.ai_model)}
- {status && (
- <>
- •
- Cycles: {status.call_count}
- •
- Runtime: {status.runtime_minutes} min
-
- )}
-
-
-
- )}
-
- {/* Account Overview */}
-
- 🔄 Last Update: {lastUpdate} | Total Equity: {account?.total_equity?.toFixed(2) || '0.00'} |
- Available: {account?.available_balance?.toFixed(2) || '0.00'} | P&L: {account?.total_pnl?.toFixed(2) || '0.00'}{' '}
- ({account?.total_pnl_pct?.toFixed(2) || '0.00'}%)
-
-
- 0}
- />
- = 0 ? '+' : ''}${account?.total_pnl?.toFixed(2) || '0.00'} USDT`}
- change={account?.total_pnl_pct || 0}
- positive={(account?.total_pnl ?? 0) >= 0}
- />
-
-
- {/* 主要内容区：左右分屏 */}
-
- {/* 左侧：图表 + 持仓 */}
-
-
- {/* AI Learning & Performance Analysis */}
-
- {/* Equity Chart */}
-
- {/* 左侧结束 */}
-
- {/* 右侧：Recent Decisions - 卡片容器 */}
-
-
-
- {/* Current Positions */}
-
-
-
-
- {positions && positions.length > 0 ? (
- - 📈 {t('currentPositions', language)} -
- {positions && positions.length > 0 && ( -
- {positions.length} {t('active', language)}
-
- )}
-
-
-
-
-
- ) : (
- | {t('symbol', language)} | -{t('side', language)} | -{t('entryPrice', language)} | -{t('markPrice', language)} | -{t('quantity', language)} | -{t('positionValue', language)} | -{t('leverage', language)} | -{t('unrealizedPnL', language)} | -{t('liqPrice', language)} | -
|---|---|---|---|---|---|---|---|---|
| {pos.symbol} | -- - {t(pos.side === 'long' ? 'long' : 'short', language)} - - | -{pos.entry_price.toFixed(4)} | -{pos.mark_price.toFixed(4)} | -{pos.quantity.toFixed(4)} | -- {(pos.quantity * pos.mark_price).toFixed(2)} USDT - | -{pos.leverage}x | -- = 0 ? '#0ECB81' : '#F6465D', fontWeight: 'bold' }} - > - {pos.unrealized_pnl >= 0 ? '+' : ''} - {pos.unrealized_pnl.toFixed(2)} ({pos.unrealized_pnl_pct.toFixed(2)}%) - - | -- {pos.liquidation_price.toFixed(4)} - | -
-
- )}
- 📊
- {t('noPositions', language)}
- {t('noActivePositions', language)}
-
- {/* 标题 */}
-
- {/* 右侧结束 */}
-
-
-
- {/* 决策列表 - 可滚动 */}
-
- 🧠
-
-
-
- {t('recentDecisions', language)}
- {decisions && decisions.length > 0 && ( -
- {t('lastCycles', language, { count: decisions.length })}
-
- )}
-
- {decisions && decisions.length > 0 ? (
- decisions.map((decision, i) => (
-
-
-
- )}
- 🧠
- {t('noDecisionsYet', language)}
- {t('aiDecisionsWillAppear', language)}
-
-
-
-
- );
-}
-
-// Decision Card Component with CoT Trace - Binance Style
-function DecisionCard({ decision, language }: { decision: DecisionRecord; language: Language }) {
- const [showInputPrompt, setShowInputPrompt] = useState(false);
- const [showCoT, setShowCoT] = useState(false);
-
- return (
- {title}
- {value}
- {change !== undefined && (
-
-
- )}
- {subtitle &&
- {positive ? '▲' : '▼'} {positive ? '+' : ''}
- {change.toFixed(2)}%
-
- {subtitle}
}
-
- {/* Header */}
-
- );
-}
-
-// Wrap App with providers
-export default function AppWithProviders() {
+export default function App() {
return (
-
-
- {/* Input Prompt - Collapsible */}
- {decision.input_prompt && (
-
-
- {t('cycle', language)} #{decision.cycle_number}
-
- {new Date(decision.timestamp).toLocaleString()}
-
-
- {t(decision.success ? 'success' : 'failed', language)}
-
-
-
- {showInputPrompt && (
-
- )}
-
- {/* AI Chain of Thought - Collapsible */}
- {decision.cot_trace && (
-
- {decision.input_prompt}
-
- )}
-
-
- {showCoT && (
-
- )}
-
- {/* Decisions Actions */}
- {decision.decisions && decision.decisions.length > 0 && (
-
- {decision.cot_trace}
-
- )}
-
- {decision.decisions.map((action, j) => (
-
- )}
-
- {/* Account State Summary */}
- {decision.account_state && (
-
- {action.symbol}
-
- {action.action}
-
- {action.leverage > 0 && {action.leverage}x}
- {action.price > 0 && (
- @{action.price.toFixed(4)}
- )}
-
- {action.success ? '✓' : '✗'}
-
- {action.error && {action.error}}
-
- ))}
-
- 净值: {decision.account_state.total_balance.toFixed(2)} USDT
- 可用: {decision.account_state.available_balance.toFixed(2)} USDT
- 保证金率: {decision.account_state.margin_used_pct.toFixed(1)}%
- 持仓: {decision.account_state.position_count}
-
- )}
-
- {/* Execution Logs */}
- {decision.execution_log && decision.execution_log.length > 0 && (
-
- {decision.execution_log.map((log, k) => (
-
- )}
-
- {/* Error Message */}
- {decision.error_message && (
-
- {log}
-
- ))}
-
- ❌ {decision.error_message}
-
- )}
-
-
{t('loadingError', language)}
+
+
- );
+ )
}
if (!performance) {
return (
-
+ {stripLeadingIcons(t('loadingError', language))}
+
+
+
{t('aiLearning', language)}
-
- {t('noCompleteData', language)}
+
+ + {t('aiLearning', language)} +
{t('noCompleteData', language)}
{/* 标题区 - 优化设计 */}
-
-
+
+
-
+
@@ -136,98 +173,165 @@ export default function AILearning({ traderId }: AILearningProps) {
{/* 核心指标卡片 - 4列网格 */}
-
+
+
{t('aiLearning', language)}
- {t('tradesAnalyzed', language, { count: performance.total_trades })} + {t('tradesAnalyzed', language, { + count: performance.total_trades, + })}
{/* 总交易数 */}
-
-
+
+
-
+
{t('totalTrades', language)}
-
+
{/* 胜率 */}
-
{performance.total_trades}
-
+
= 50
- ? 'linear-gradient(135deg, rgba(16, 185, 129, 0.2) 0%, rgba(30, 35, 41, 0.8) 100%)'
- : 'linear-gradient(135deg, rgba(248, 113, 113, 0.2) 0%, rgba(30, 35, 41, 0.8) 100%)',
- border: `1px solid ${(performance.win_rate || 0) >= 50 ? 'rgba(16, 185, 129, 0.4)' : 'rgba(248, 113, 113, 0.4)'}`,
- boxShadow: `0 4px 16px ${(performance.win_rate || 0) >= 50 ? 'rgba(16, 185, 129, 0.2)' : 'rgba(248, 113, 113, 0.2)'}`
- }}>
-
= 50 ? '#10B981' : '#F87171'} 0%, transparent 70%)`,
- filter: 'blur(20px)'
- }} />
+
= 50
+ ? 'linear-gradient(135deg, rgba(16, 185, 129, 0.2) 0%, rgba(30, 35, 41, 0.8) 100%)'
+ : 'linear-gradient(135deg, rgba(248, 113, 113, 0.2) 0%, rgba(30, 35, 41, 0.8) 100%)',
+ border: `1px solid ${(performance.win_rate || 0) >= 50 ? 'rgba(16, 185, 129, 0.4)' : 'rgba(248, 113, 113, 0.4)'}`,
+ boxShadow: `0 4px 16px ${(performance.win_rate || 0) >= 50 ? 'rgba(16, 185, 129, 0.2)' : 'rgba(248, 113, 113, 0.2)'}`,
+ }}
+ >
+
= 50 ? '#10B981' : '#F87171'} 0%, transparent 70%)`,
+ filter: 'blur(20px)',
+ }}
+ />
-
= 50 ? '#6EE7B7' : '#FCA5A5'
- }}>
+
{/* 平均盈利 */}
- = 50 ? '#6EE7B7' : '#FCA5A5',
+ }}
+ >
{t('winRate', language)}
- = 50 ? '#10B981' : '#F87171'
- }}>
+
= 50 ? '#10B981' : '#F87171',
+ }}
+ >
{(performance.win_rate || 0).toFixed(1)}%
- {performance.winning_trades || 0}W / {performance.losing_trades || 0}L
+ {performance.winning_trades || 0}W /{' '}
+ {performance.losing_trades || 0}L
-
+
+
-
+
{t('avgWin', language)}
-
+
{/* 平均亏损 */}
-
+{(performance.avg_win || 0).toFixed(2)}
-
+
-
+
+
-
+
{t('avgLoss', language)}
-
+
{(performance.avg_loss || 0).toFixed(2)}
-
+
@@ -237,67 +341,121 @@ export default function AILearning({ traderId }: AILearningProps) {
{/* 关键指标：夏普比率 & 盈亏比 - 2列网格 */}
{/* 夏普比率 */}
-
-
+
+
-
+
-
夏普比率
- 风险调整后收益 · AI自我进化指标
+
+ 夏普比率
+
+
+ 风险调整后收益 · AI自我进化指标
+
-
= 2 ? '#10B981' :
- (performance.sharpe_ratio || 0) >= 1 ? '#22D3EE' :
- (performance.sharpe_ratio || 0) >= 0 ? '#F0B90B' : '#F87171',
- textShadow: '0 4px 12px rgba(0, 0, 0, 0.3)'
- }}>
- {performance.sharpe_ratio ? performance.sharpe_ratio.toFixed(2) : 'N/A'}
+
= 2
+ ? '#10B981'
+ : (performance.sharpe_ratio || 0) >= 1
+ ? '#22D3EE'
+ : (performance.sharpe_ratio || 0) >= 0
+ ? '#F0B90B'
+ : '#F87171',
+ textShadow: '0 4px 12px rgba(0, 0, 0, 0.3)',
+ }}
+ >
+ {performance.sharpe_ratio
+ ? performance.sharpe_ratio.toFixed(2)
+ : 'N/A'}
{performance.sharpe_ratio !== undefined && (
-
{performance.sharpe_ratio !== undefined && (
- = 2 ? '#10B981' :
- (performance.sharpe_ratio || 0) >= 1 ? '#22D3EE' :
- (performance.sharpe_ratio || 0) >= 0 ? '#F0B90B' : '#F87171',
- background: (performance.sharpe_ratio || 0) >= 2 ? 'rgba(16, 185, 129, 0.2)' :
- (performance.sharpe_ratio || 0) >= 1 ? 'rgba(34, 211, 238, 0.2)' :
- (performance.sharpe_ratio || 0) >= 0 ? 'rgba(240, 185, 11, 0.2)' : 'rgba(248, 113, 113, 0.2)'
- }}>
- {performance.sharpe_ratio >= 2 ? '🟢 卓越表现' :
- performance.sharpe_ratio >= 1 ? '🟢 良好表现' :
- performance.sharpe_ratio >= 0 ? '🟡 波动较大' : '🔴 需要调整'}
+
)}
= 2
+ ? '#10B981'
+ : (performance.sharpe_ratio || 0) >= 1
+ ? '#22D3EE'
+ : (performance.sharpe_ratio || 0) >= 0
+ ? '#F0B90B'
+ : '#F87171',
+ background:
+ (performance.sharpe_ratio || 0) >= 2
+ ? 'rgba(16, 185, 129, 0.2)'
+ : (performance.sharpe_ratio || 0) >= 1
+ ? 'rgba(34, 211, 238, 0.2)'
+ : (performance.sharpe_ratio || 0) >= 0
+ ? 'rgba(240, 185, 11, 0.2)'
+ : 'rgba(248, 113, 113, 0.2)',
+ }}
+ >
+ {performance.sharpe_ratio >= 2
+ ? '🟢 卓越表现'
+ : performance.sharpe_ratio >= 1
+ ? '🟢 良好表现'
+ : performance.sharpe_ratio >= 0
+ ? '🟡 波动较大'
+ : '🔴 需要调整'}
-
- {performance.sharpe_ratio >= 2 && '✨ AI策略非常有效！风险调整后收益优异，可适度扩大仓位但保持纪律。'}
- {performance.sharpe_ratio >= 1 && performance.sharpe_ratio < 2 && '✅ 策略表现稳健，风险收益平衡良好，继续保持当前策略。'}
- {performance.sharpe_ratio >= 0 && performance.sharpe_ratio < 1 && '⚠️ 收益为正但波动较大，AI正在优化策略，降低风险。'}
- {performance.sharpe_ratio < 0 && '🚨 当前策略需要调整！AI已自动进入保守模式，减少仓位和交易频率。'}
+
{/* 盈亏比 */}
-
+
)}
@@ -305,21 +463,32 @@ export default function AILearning({ traderId }: AILearningProps) {
+ {performance.sharpe_ratio >= 2 &&
+ '✨ AI策略非常有效！风险调整后收益优异，可适度扩大仓位但保持纪律。'}
+ {performance.sharpe_ratio >= 1 &&
+ performance.sharpe_ratio < 2 &&
+ '✅ 策略表现稳健，风险收益平衡良好，继续保持当前策略。'}
+ {performance.sharpe_ratio >= 0 &&
+ performance.sharpe_ratio < 1 &&
+ '⚠️ 收益为正但波动较大，AI正在优化策略，降低风险。'}
+ {performance.sharpe_ratio < 0 &&
+ '🚨 当前策略需要调整！AI已自动进入保守模式，减少仓位和交易频率。'}
-
+
+
-
+
@@ -333,39 +502,82 @@ export default function AILearning({ traderId }: AILearningProps) {
-
= 2.0 ? '#10B981' :
- (performance.profit_factor || 0) >= 1.5 ? '#F0B90B' :
- (performance.profit_factor || 0) >= 1.0 ? '#FB923C' : '#F87171',
- textShadow: '0 4px 12px rgba(0, 0, 0, 0.3)'
- }}>
- {(performance.profit_factor || 0) > 0 ? (performance.profit_factor || 0).toFixed(2) : 'N/A'}
+
= 2.0
+ ? '#10B981'
+ : (performance.profit_factor || 0) >= 1.5
+ ? '#F0B90B'
+ : (performance.profit_factor || 0) >= 1.0
+ ? '#FB923C'
+ : '#F87171',
+ textShadow: '0 4px 12px rgba(0, 0, 0, 0.3)',
+ }}
+ >
+ {(performance.profit_factor || 0) > 0
+ ? (performance.profit_factor || 0).toFixed(2)
+ : 'N/A'}
-
- = 2.0 ? '#10B981' :
- (performance.profit_factor || 0) >= 1.5 ? '#F0B90B' : '#94A3B8',
- background: (performance.profit_factor || 0) >= 2.0 ? 'rgba(16, 185, 129, 0.2)' :
- (performance.profit_factor || 0) >= 1.5 ? 'rgba(240, 185, 11, 0.2)' : 'rgba(148, 163, 184, 0.2)'
- }}>
- {(performance.profit_factor || 0) >= 2.0 && t('excellent', language)}
- {(performance.profit_factor || 0) >= 1.5 && (performance.profit_factor || 0) < 2.0 && t('good', language)}
- {(performance.profit_factor || 0) >= 1.0 && (performance.profit_factor || 0) < 1.5 && t('fair', language)}
- {(performance.profit_factor || 0) > 0 && (performance.profit_factor || 0) < 1.0 && t('poor', language)}
+
= 2.0
+ ? '#10B981'
+ : (performance.profit_factor || 0) >= 1.5
+ ? '#F0B90B'
+ : '#94A3B8',
+ background:
+ (performance.profit_factor || 0) >= 2.0
+ ? 'rgba(16, 185, 129, 0.2)'
+ : (performance.profit_factor || 0) >= 1.5
+ ? 'rgba(240, 185, 11, 0.2)'
+ : 'rgba(148, 163, 184, 0.2)',
+ }}
+ >
+ {(performance.profit_factor || 0) >= 2.0 &&
+ t('excellent', language)}
+ {(performance.profit_factor || 0) >= 1.5 &&
+ (performance.profit_factor || 0) < 2.0 &&
+ t('good', language)}
+ {(performance.profit_factor || 0) >= 1.0 &&
+ (performance.profit_factor || 0) < 1.5 &&
+ t('fair', language)}
+ {(performance.profit_factor || 0) > 0 &&
+ (performance.profit_factor || 0) < 1.0 &&
+ t('poor', language)}
-
- {(performance.profit_factor || 0) >= 2.0 && '🔥 盈利能力出色！每亏1元能赚' + (performance.profit_factor || 0).toFixed(1) + '元，AI策略表现优异。'}
- {(performance.profit_factor || 0) >= 1.5 && (performance.profit_factor || 0) < 2.0 && '✓ 策略稳定盈利，盈亏比健康，继续保持纪律性交易。'}
- {(performance.profit_factor || 0) >= 1.0 && (performance.profit_factor || 0) < 1.5 && '⚠️ 策略略有盈利但需优化，AI正在调整仓位和止损策略。'}
- {(performance.profit_factor || 0) > 0 && (performance.profit_factor || 0) < 1.0 && '❌ 平均亏损大于盈利，需要调整策略或降低交易频率。'}
+
@@ -376,44 +588,83 @@ export default function AILearning({ traderId }: AILearningProps) {
{(performance.best_symbol || performance.worst_symbol) && (
+
+ {(performance.profit_factor || 0) >= 2.0 &&
+ '🔥 盈利能力出色！每亏1元能赚' +
+ (performance.profit_factor || 0).toFixed(1) +
+ '元，AI策略表现优异。'}
+ {(performance.profit_factor || 0) >= 1.5 &&
+ (performance.profit_factor || 0) < 2.0 &&
+ '✓ 策略稳定盈利，盈亏比健康，继续保持纪律性交易。'}
+ {(performance.profit_factor || 0) >= 1.0 &&
+ (performance.profit_factor || 0) < 1.5 &&
+ '⚠️ 策略略有盈利但需优化，AI正在调整仓位和止损策略。'}
+ {(performance.profit_factor || 0) > 0 &&
+ (performance.profit_factor || 0) < 1.0 &&
+ '❌ 平均亏损大于盈利，需要调整策略或降低交易频率。'}
{performance.best_symbol && (
-
+
+
{performance.best_symbol}
{symbolStats[performance.best_symbol] && (
-
- {symbolStats[performance.best_symbol].total_pn_l > 0 ? '+' : ''}
- {symbolStats[performance.best_symbol].total_pn_l.toFixed(2)} USDT {t('pnl', language)}
+
)}
{performance.worst_symbol && (
-
+ {symbolStats[performance.best_symbol].total_pn_l > 0
+ ? '+'
+ : ''}
+ {symbolStats[performance.best_symbol].total_pn_l.toFixed(2)}{' '}
+ USDT {t('pnl', language)}
)}
+
-
-
+
{performance.worst_symbol}
{symbolStats[performance.worst_symbol] && (
-
- {symbolStats[performance.worst_symbol].total_pn_l > 0 ? '+' : ''}
- {symbolStats[performance.worst_symbol].total_pn_l.toFixed(2)} USDT {t('pnl', language)}
+
@@ -425,57 +676,129 @@ export default function AILearning({ traderId }: AILearningProps) {
+ {symbolStats[performance.worst_symbol].total_pn_l > 0
+ ? '+'
+ : ''}
+ {symbolStats[performance.worst_symbol].total_pn_l.toFixed(2)}{' '}
+ USDT {t('pnl', language)}
)}
{/* 左侧：币种表现统计表格 */}
{symbolStatsList.length > 0 && (
-
-
-
-
-
+
-
+
-
- Symbol
- Trades
- Win Rate
- Total P&L (USDT)
- Avg P&L (USDT)
+
+
+ Symbol
+
+
+ Trades
+
+
+ Win Rate
+
+
+ Total P&L (USDT)
+
+
+ Avg P&L (USDT)
+
{symbolStatsList.map((stat, idx) => (
- 0 ? '1px solid rgba(99, 102, 241, 0.1)' : 'none'
- }}>
+ 0
+ ? '1px solid rgba(99, 102, 241, 0.1)'
+ : 'none',
+ }}
+ >
- {stat.symbol}
+
+ {stat.symbol}
+
-
+
{stat.total_trades}
- = 50 ? '#10B981' : '#F87171'
- }}>
+ = 50 ? '#10B981' : '#F87171',
+ }}
+ >
{(stat.win_rate || 0).toFixed(1)}%
- 0 ? '#10B981' : '#F87171'
- }}>
- {(stat.total_pn_l || 0) > 0 ? '+' : ''}{(stat.total_pn_l || 0).toFixed(2)}
+ 0 ? '#10B981' : '#F87171',
+ }}
+ >
+ {(stat.total_pn_l || 0) > 0 ? '+' : ''}
+ {(stat.total_pn_l || 0).toFixed(2)}
- 0 ? '#10B981' : '#F87171'
- }}>
- {(stat.avg_pn_l || 0) > 0 ? '+' : ''}{(stat.avg_pn_l || 0).toFixed(2)}
+ 0 ? '#10B981' : '#F87171',
+ }}
+ >
+ {(stat.avg_pn_l || 0) > 0 ? '+' : ''}
+ {(stat.avg_pn_l || 0).toFixed(2)}
))}
@@ -486,164 +809,253 @@ export default function AILearning({ traderId }: AILearningProps) {
)}
{/* 右侧：历史成交记录 */}
-
-
+
+
{t('tradeHistory', language)}
+
+ {t('tradeHistory', language)}
+
- {performance?.recent_trades && performance.recent_trades.length > 0
- ? t('completedTrades', language, { count: performance.recent_trades.length })
+ {performance?.recent_trades &&
+ performance.recent_trades.length > 0
+ ? t('completedTrades', language, {
+ count: performance.recent_trades.length,
+ })
: t('completedTradesWillAppear', language)}
-
- {performance?.recent_trades && performance.recent_trades.length > 0 ? (
- performance.recent_trades.map((trade: TradeOutcome, idx: number) => {
- const isProfitable = trade.pn_l >= 0;
- const isRecent = idx === 0;
+
+ {performance?.recent_trades &&
+ performance.recent_trades.length > 0 ? (
+ performance.recent_trades.map(
+ (trade: TradeOutcome, idx: number) => {
+ const isProfitable = trade.pn_l >= 0
+ const isRecent = idx === 0
- return (
-
-
-
-
- {trade.symbol}
-
-
- {trade.side.toUpperCase()}
-
- {isRecent && (
-
- {t('latest', language)}
+ return (
+
+
+
+
+ {trade.symbol}
+
+
+ {trade.side.toUpperCase()}
+
+ {isRecent && (
+
+ {t('latest', language)}
+
+ )}
+
+
+ {isProfitable ? '+' : ''}
+ {trade.pn_l_pct.toFixed(2)}%
+
+
+
+
+
+
+ {t('entry', language)}
+
+
+ {trade.open_price.toFixed(4)}
+
+
+
+
+ {t('exit', language)}
+
+
+ {trade.close_price.toFixed(4)}
+
+
+
+
+ {/* Position Details */}
+
+
+ Quantity
+
+ {trade.quantity ? trade.quantity.toFixed(4) : '-'}
+
+
+
+ Leverage
+
+ {trade.leverage ? `${trade.leverage}x` : '-'}
+
+
+
+ Position Value
+
+ {trade.position_value
+ ? `$${trade.position_value.toFixed(2)}`
+ : '-'}
+
+
+
+ Margin Used
+
+ {trade.margin_used
+ ? `$${trade.margin_used.toFixed(2)}`
+ : '-'}
+
+
+
+
+
+
+ P&L
+
+ {isProfitable ? '+' : ''}
+ {trade.pn_l.toFixed(2)} USDT
+
+
+
+
+
+ ⏱️ {formatDuration(trade.duration)}
+ {trade.was_stop_loss && (
+
+ {t('stopLoss', language)}
)}
-
- {isProfitable ? '+' : ''}{trade.pn_l_pct.toFixed(2)}%
-
-
-
-
- {t('entry', language)}
-
- {trade.open_price.toFixed(4)}
-
-
-
- {t('exit', language)}
-
- {trade.close_price.toFixed(4)}
-
+
+ {new Date(trade.close_time).toLocaleString('en-US', {
+ month: 'short',
+ day: '2-digit',
+ hour: '2-digit',
+ minute: '2-digit',
+ })}
-
- {/* Position Details */}
-
-
- Quantity
-
- {trade.quantity ? trade.quantity.toFixed(4) : '-'}
-
-
-
- Leverage
-
- {trade.leverage ? `${trade.leverage}x` : '-'}
-
-
-
- Position Value
-
- {trade.position_value ? `$${trade.position_value.toFixed(2)}` : '-'}
-
-
-
- Margin Used
-
- {trade.margin_used ? `$${trade.margin_used.toFixed(2)}` : '-'}
-
-
-
-
-
-
- P&L
-
- {isProfitable ? '+' : ''}{trade.pn_l.toFixed(2)} USDT
-
-
-
-
-
- ⏱️ {formatDuration(trade.duration)}
- {trade.was_stop_loss && (
-
- {t('stopLoss', language)}
-
- )}
-
-
-
- {new Date(trade.close_time).toLocaleString('en-US', {
- month: 'short',
- day: '2-digit',
- hour: '2-digit',
- minute: '2-digit'
- })}
-
-
- );
- })
+ )
+ }
+ )
) : (
- {t('howAILearns', language)}
+
+ {stripLeadingIcons(t('howAILearns', language))}
+
•
- {t('aiLearningPoint1', language)}
+
+ {t('aiLearningPoint1', language)}
+
•
- {t('aiLearningPoint2', language)}
+
+ {t('aiLearningPoint2', language)}
+
•
- {t('aiLearningPoint3', language)}
+
+ {t('aiLearningPoint3', language)}
+
•
- {t('aiLearningPoint4', language)}
+
+ {t('aiLearningPoint4', language)}
+
- );
+ )
}
// 格式化持仓时长
function formatDuration(duration: string | undefined): string {
- if (!duration) return '-';
+ if (!duration) return '-'
- const match = duration.match(/(\d+h)?(\d+m)?(\d+\.?\d*s)?/);
- if (!match) return duration;
+ const match = duration.match(/(\d+h)?(\d+m)?(\d+\.?\d*s)?/)
+ if (!match) return duration
- const hours = match[1] || '';
- const minutes = match[2] || '';
- const seconds = match[3] || '';
+ const hours = match[1] || ''
+ const minutes = match[2] || ''
+ const seconds = match[3] || ''
- let result = '';
- if (hours) result += hours.replace('h', '小时');
- if (minutes) result += minutes.replace('m', '分');
- if (!hours && seconds) result += seconds.replace(/(\d+)\.?\d*s/, '$1秒');
+ let result = ''
+ if (hours) result += hours.replace('h', '小时')
+ if (minutes) result += minutes.replace('m', '分')
+ if (!hours && seconds) result += seconds.replace(/(\d+)\.?\d*s/, '$1秒')
- return result || duration;
+ return result || duration
}
diff --git a/web/src/components/AITradersPage.tsx b/web/src/components/AITradersPage.tsx
index 41b3cdc2..5e066661 100644
--- a/web/src/components/AITradersPage.tsx
+++ b/web/src/components/AITradersPage.tsx
@@ -1,64 +1,97 @@
-import React, { useState, useEffect } from 'react';
-import useSWR from 'swr';
-import { api } from '../lib/api';
-import type { TraderInfo, CreateTraderRequest, AIModel, Exchange } from '../types';
-import { useLanguage } from '../contexts/LanguageContext';
-import { t, type Language } from '../i18n/translations';
-import { useAuth } from '../contexts/AuthContext';
-import { getExchangeIcon } from './ExchangeIcons';
-import { getModelIcon } from './ModelIcons';
-import { TraderConfigModal } from './TraderConfigModal';
-import { Bot, Brain, Landmark, BarChart3, Trash2, Plus, Users, AlertTriangle } from 'lucide-react';
+import React, { useState, useEffect } from 'react'
+import { useNavigate } from 'react-router-dom'
+import useSWR from 'swr'
+import { api } from '../lib/api'
+import type {
+ TraderInfo,
+ CreateTraderRequest,
+ AIModel,
+ Exchange,
+} from '../types'
+import { useLanguage } from '../contexts/LanguageContext'
+import { t, type Language } from '../i18n/translations'
+import { useAuth } from '../contexts/AuthContext'
+import { getExchangeIcon } from './ExchangeIcons'
+import { getModelIcon } from './ModelIcons'
+import { TraderConfigModal } from './TraderConfigModal'
+import {
+ TwoStageKeyModal,
+ type TwoStageKeyModalResult,
+} from './TwoStageKeyModal'
+import {
+ WebCryptoEnvironmentCheck,
+ type WebCryptoCheckStatus,
+} from './WebCryptoEnvironmentCheck'
+import {
+ Bot,
+ Brain,
+ Landmark,
+ BarChart3,
+ Trash2,
+ Plus,
+ Users,
+ AlertTriangle,
+ BookOpen,
+ HelpCircle,
+ Radio,
+ Pencil,
+} from 'lucide-react'
+import { confirmToast } from '../lib/notify'
+import { toast } from 'sonner'
// 获取友好的AI模型名称
function getModelDisplayName(modelId: string): string {
switch (modelId.toLowerCase()) {
case 'deepseek':
- return 'DeepSeek';
+ return 'DeepSeek'
case 'qwen':
- return 'Qwen';
+ return 'Qwen'
case 'claude':
- return 'Claude';
+ return 'Claude'
default:
- return modelId.toUpperCase();
+ return modelId.toUpperCase()
}
}
// 提取下划线后面的名称部分
function getShortName(fullName: string): string {
- const parts = fullName.split('_');
- return parts.length > 1 ? parts[parts.length - 1] : fullName;
+ const parts = fullName.split('_')
+ return parts.length > 1 ? parts[parts.length - 1] : fullName
}
interface AITradersPageProps {
- onTraderSelect?: (traderId: string) => void;
+ onTraderSelect?: (traderId: string) => void
}
export function AITradersPage({ onTraderSelect }: AITradersPageProps) {
- const { language } = useLanguage();
- const { user, token } = useAuth();
- const [showCreateModal, setShowCreateModal] = useState(false);
- const [showEditModal, setShowEditModal] = useState(false);
- const [showModelModal, setShowModelModal] = useState(false);
- const [showExchangeModal, setShowExchangeModal] = useState(false);
- const [showSignalSourceModal, setShowSignalSourceModal] = useState(false);
- const [editingModel, setEditingModel] = useState(null);
- const [editingExchange, setEditingExchange] = useState(null);
- const [editingTrader, setEditingTrader] = useState(null);
- const [allModels, setAllModels] = useState([]);
- const [allExchanges, setAllExchanges] = useState([]);
- const [supportedModels, setSupportedModels] = useState([]);
- const [supportedExchanges, setSupportedExchanges] = useState([]);
- const [userSignalSource, setUserSignalSource] = useState<{coinPoolUrl: string, oiTopUrl: string}>({
+ const { language } = useLanguage()
+ const { user, token } = useAuth()
+ const navigate = useNavigate()
+ const [showCreateModal, setShowCreateModal] = useState(false)
+ const [showEditModal, setShowEditModal] = useState(false)
+ const [showModelModal, setShowModelModal] = useState(false)
+ const [showExchangeModal, setShowExchangeModal] = useState(false)
+ const [showSignalSourceModal, setShowSignalSourceModal] = useState(false)
+ const [editingModel, setEditingModel] = useState(null)
+ const [editingExchange, setEditingExchange] = useState(null)
+ const [editingTrader, setEditingTrader] = useState(null)
+ const [allModels, setAllModels] = useState([])
+ const [allExchanges, setAllExchanges] = useState([])
+ const [supportedModels, setSupportedModels] = useState([])
+ const [supportedExchanges, setSupportedExchanges] = useState([])
+ const [userSignalSource, setUserSignalSource] = useState<{
+ coinPoolUrl: string
+ oiTopUrl: string
+ }>({
coinPoolUrl: '',
- oiTopUrl: ''
- });
+ oiTopUrl: '',
+ })
const { data: traders, mutate: mutateTraders } = useSWR(
user && token ? 'traders' : null,
api.getTraders,
{ refreshInterval: 5000 }
- );
+ )
// 加载AI模型和交易所配置
useEffect(() => {
@@ -68,133 +101,184 @@ export function AITradersPage({ onTraderSelect }: AITradersPageProps) {
try {
const [supportedModels, supportedExchanges] = await Promise.all([
api.getSupportedModels(),
- api.getSupportedExchanges()
- ]);
- setSupportedModels(supportedModels);
- setSupportedExchanges(supportedExchanges);
+ api.getSupportedExchanges(),
+ ])
+ setSupportedModels(supportedModels)
+ setSupportedExchanges(supportedExchanges)
} catch (err) {
- console.error('Failed to load supported configs:', err);
+ console.error('Failed to load supported configs:', err)
}
- return;
+ return
}
try {
- const [modelConfigs, exchangeConfigs, supportedModels, supportedExchanges] = await Promise.all([
+ const [
+ modelConfigs,
+ exchangeConfigs,
+ supportedModels,
+ supportedExchanges,
+ ] = await Promise.all([
api.getModelConfigs(),
api.getExchangeConfigs(),
api.getSupportedModels(),
- api.getSupportedExchanges()
- ]);
- setAllModels(modelConfigs);
- setAllExchanges(exchangeConfigs);
- setSupportedModels(supportedModels);
- setSupportedExchanges(supportedExchanges);
+ api.getSupportedExchanges(),
+ ])
+ setAllModels(modelConfigs)
+ setAllExchanges(exchangeConfigs)
+ setSupportedModels(supportedModels)
+ setSupportedExchanges(supportedExchanges)
// 加载用户信号源配置
try {
- const signalSource = await api.getUserSignalSource();
+ const signalSource = await api.getUserSignalSource()
setUserSignalSource({
coinPoolUrl: signalSource.coin_pool_url || '',
- oiTopUrl: signalSource.oi_top_url || ''
- });
+ oiTopUrl: signalSource.oi_top_url || '',
+ })
} catch (error) {
- console.log('📡 用户信号源配置暂未设置');
+ console.log('📡 用户信号源配置暂未设置')
}
} catch (error) {
- console.error('Failed to load configs:', error);
+ console.error('Failed to load configs:', error)
}
- };
- loadConfigs();
- }, [user, token]);
+ }
+ loadConfigs()
+ }, [user, token])
+
+ // 只显示已配置的模型和交易所
+ // 注意：后端返回的数据不包含敏感信息（apiKey等），所以通过其他字段判断是否已配置
+ const configuredModels =
+ allModels?.filter((m) => {
+ // 如果模型已启用，说明已配置
+ // 或者有自定义API URL，也说明已配置
+ return m.enabled || (m.customApiUrl && m.customApiUrl.trim() !== '')
+ }) || []
+ const configuredExchanges =
+ allExchanges?.filter((e) => {
+ // Aster 交易所检查特殊字段
+ if (e.id === 'aster') {
+ return e.asterUser && e.asterUser.trim() !== ''
+ }
+ // Hyperliquid 需要检查钱包地址（后端会返回这个字段）
+ if (e.id === 'hyperliquid') {
+ return e.hyperliquidWalletAddr && e.hyperliquidWalletAddr.trim() !== ''
+ }
+ // 其他交易所：如果已启用，说明已配置（后端返回的已配置交易所会有 enabled: true）
+ return e.enabled
+ }) || []
- // 显示所有用户的模型和交易所配置（用于调试）
- const configuredModels = allModels || [];
- const configuredExchanges = allExchanges || [];
-
// 只在创建交易员时使用已启用且配置完整的
- const enabledModels = allModels?.filter(m => m.enabled && m.apiKey) || [];
- const enabledExchanges = allExchanges?.filter(e => {
- if (!e.enabled) return false;
+ // 注意：后端返回的数据不包含敏感信息，所以只检查 enabled 状态和必要的非敏感字段
+ const enabledModels = allModels?.filter((m) => m.enabled) || []
+ const enabledExchanges =
+ allExchanges?.filter((e) => {
+ if (!e.enabled) return false
- // Aster 交易所需要特殊字段
- if (e.id === 'aster') {
- return e.asterUser && e.asterUser.trim() !== '' &&
- e.asterSigner && e.asterSigner.trim() !== '' &&
- e.asterPrivateKey && e.asterPrivateKey.trim() !== '';
- }
+ // Aster 交易所需要特殊字段（后端会返回这些非敏感字段）
+ if (e.id === 'aster') {
+ return (
+ e.asterUser &&
+ e.asterUser.trim() !== '' &&
+ e.asterSigner &&
+ e.asterSigner.trim() !== ''
+ )
+ }
- // Hyperliquid 只需要私钥（作为apiKey）和钱包地址
- if (e.id === 'hyperliquid') {
- return e.apiKey && e.apiKey.trim() !== '' &&
- e.hyperliquidWalletAddr && e.hyperliquidWalletAddr.trim() !== '';
- }
+ // Hyperliquid 需要钱包地址（后端会返回这个字段）
+ if (e.id === 'hyperliquid') {
+ return e.hyperliquidWalletAddr && e.hyperliquidWalletAddr.trim() !== ''
+ }
- // Binance 等其他交易所需要 apiKey 和 secretKey
- return e.apiKey && e.apiKey.trim() !== '' && e.secretKey && e.secretKey.trim() !== '';
- }) || [];
+ // 其他交易所：如果已启用，说明已配置完整（后端只返回已配置的交易所）
+ return true
+ }) || []
- // 检查模型是否正在被运行中的交易员使用
+ // 检查模型是否正在被运行中的交易员使用（用于UI禁用）
const isModelInUse = (modelId: string) => {
- return traders?.some(t => t.ai_model === modelId && t.is_running) || false;
- };
+ return traders?.some((t) => t.ai_model === modelId && t.is_running)
+ }
- // 检查交易所是否正在被运行中的交易员使用
+ // 检查交易所是否正在被运行中的交易员使用（用于UI禁用）
const isExchangeInUse = (exchangeId: string) => {
- return traders?.some(t => t.exchange_id === exchangeId && t.is_running) || false;
- };
+ return traders?.some((t) => t.exchange_id === exchangeId && t.is_running)
+ }
+
+ // 检查模型是否被任何交易员使用（包括停止状态的）
+ const isModelUsedByAnyTrader = (modelId: string) => {
+ return traders?.some((t) => t.ai_model === modelId) || false
+ }
+
+ // 检查交易所是否被任何交易员使用（包括停止状态的）
+ const isExchangeUsedByAnyTrader = (exchangeId: string) => {
+ return traders?.some((t) => t.exchange_id === exchangeId) || false
+ }
+
+ // 获取使用特定模型的交易员列表
+ const getTradersUsingModel = (modelId: string) => {
+ return traders?.filter((t) => t.ai_model === modelId) || []
+ }
+
+ // 获取使用特定交易所的交易员列表
+ const getTradersUsingExchange = (exchangeId: string) => {
+ return traders?.filter((t) => t.exchange_id === exchangeId) || []
+ }
const handleCreateTrader = async (data: CreateTraderRequest) => {
try {
- const model = allModels?.find(m => m.id === data.ai_model_id);
- const exchange = allExchanges?.find(e => e.id === data.exchange_id);
+ const model = allModels?.find((m) => m.id === data.ai_model_id)
+ const exchange = allExchanges?.find((e) => e.id === data.exchange_id)
if (!model?.enabled) {
- alert(t('modelNotConfigured', language));
- return;
+ toast.error(t('modelNotConfigured', language))
+ return
}
if (!exchange?.enabled) {
- alert(t('exchangeNotConfigured', language));
- return;
+ toast.error(t('exchangeNotConfigured', language))
+ return
}
- await api.createTrader(data);
- setShowCreateModal(false);
- mutateTraders();
+ await toast.promise(api.createTrader(data), {
+ loading: '正在创建…',
+ success: '创建成功',
+ error: '创建失败',
+ })
+ setShowCreateModal(false)
+ mutateTraders()
} catch (error) {
- console.error('Failed to create trader:', error);
- alert(t('createTraderFailed', language));
+ console.error('Failed to create trader:', error)
+ toast.error(t('createTraderFailed', language))
}
- };
+ }
const handleEditTrader = async (traderId: string) => {
try {
- const traderConfig = await api.getTraderConfig(traderId);
- setEditingTrader(traderConfig);
- setShowEditModal(true);
+ const traderConfig = await api.getTraderConfig(traderId)
+ setEditingTrader(traderConfig)
+ setShowEditModal(true)
} catch (error) {
- console.error('Failed to fetch trader config:', error);
- alert(t('getTraderConfigFailed', language));
+ console.error('Failed to fetch trader config:', error)
+ toast.error(t('getTraderConfigFailed', language))
}
- };
+ }
const handleSaveEditTrader = async (data: CreateTraderRequest) => {
- if (!editingTrader) return;
+ if (!editingTrader) return
try {
- const model = enabledModels?.find(m => m.id === data.ai_model_id);
- const exchange = enabledExchanges?.find(e => e.id === data.exchange_id);
+ const model = enabledModels?.find((m) => m.id === data.ai_model_id)
+ const exchange = enabledExchanges?.find((e) => e.id === data.exchange_id)
if (!model) {
- alert(t('modelConfigNotExist', language));
- return;
+ toast.error(t('modelConfigNotExist', language))
+ return
}
if (!exchange) {
- alert(t('exchangeConfigNotExist', language));
- return;
+ toast.error(t('exchangeConfigNotExist', language))
+ return
}
-
+
const request = {
name: data.name,
ai_model_id: data.ai_model_id,
@@ -206,224 +290,279 @@ export function AITradersPage({ onTraderSelect }: AITradersPageProps) {
trading_symbols: data.trading_symbols,
custom_prompt: data.custom_prompt,
override_base_prompt: data.override_base_prompt,
+ system_prompt_template: data.system_prompt_template,
is_cross_margin: data.is_cross_margin,
use_coin_pool: data.use_coin_pool,
- use_oi_top: data.use_oi_top
- };
-
- await api.updateTrader(editingTrader.trader_id, request);
- setShowEditModal(false);
- setEditingTrader(null);
- mutateTraders();
+ use_oi_top: data.use_oi_top,
+ }
+
+ await toast.promise(api.updateTrader(editingTrader.trader_id, request), {
+ loading: '正在保存…',
+ success: '保存成功',
+ error: '保存失败',
+ })
+ setShowEditModal(false)
+ setEditingTrader(null)
+ mutateTraders()
} catch (error) {
- console.error('Failed to update trader:', error);
- alert(t('updateTraderFailed', language));
+ console.error('Failed to update trader:', error)
+ toast.error(t('updateTraderFailed', language))
}
- };
+ }
const handleDeleteTrader = async (traderId: string) => {
- if (!confirm(t('confirmDeleteTrader', language))) return;
+ {
+ const ok = await confirmToast(t('confirmDeleteTrader', language))
+ if (!ok) return
+ }
try {
- await api.deleteTrader(traderId);
- mutateTraders();
+ await toast.promise(api.deleteTrader(traderId), {
+ loading: '正在删除…',
+ success: '删除成功',
+ error: '删除失败',
+ })
+ mutateTraders()
} catch (error) {
- console.error('Failed to delete trader:', error);
- alert(t('deleteTraderFailed', language));
+ console.error('Failed to delete trader:', error)
+ toast.error(t('deleteTraderFailed', language))
}
- };
+ }
const handleToggleTrader = async (traderId: string, running: boolean) => {
try {
if (running) {
- await api.stopTrader(traderId);
+ await toast.promise(api.stopTrader(traderId), {
+ loading: '正在停止…',
+ success: '已停止',
+ error: '停止失败',
+ })
} else {
- await api.startTrader(traderId);
+ await toast.promise(api.startTrader(traderId), {
+ loading: '正在启动…',
+ success: '已启动',
+ error: '启动失败',
+ })
}
- mutateTraders();
+ mutateTraders()
} catch (error) {
- console.error('Failed to toggle trader:', error);
- alert(t('operationFailed', language));
+ console.error('Failed to toggle trader:', error)
+ toast.error(t('operationFailed', language))
}
- };
+ }
const handleModelClick = (modelId: string) => {
if (!isModelInUse(modelId)) {
- setEditingModel(modelId);
- setShowModelModal(true);
+ setEditingModel(modelId)
+ setShowModelModal(true)
}
- };
+ }
const handleExchangeClick = (exchangeId: string) => {
if (!isExchangeInUse(exchangeId)) {
- setEditingExchange(exchangeId);
- setShowExchangeModal(true);
+ setEditingExchange(exchangeId)
+ setShowExchangeModal(true)
}
- };
+ }
- const handleDeleteModelConfig = async (modelId: string) => {
- if (!confirm(t('confirmDeleteModel', language))) return;
+ // 通用删除配置处理函数
+ const handleDeleteConfig = async (config: {
+ id: string
+ type: 'model' | 'exchange'
+ checkInUse: (id: string) => boolean
+ getUsingTraders: (id: string) => any[]
+ cannotDeleteKey: string
+ confirmDeleteKey: string
+ allItems: T[] | undefined
+ clearFields: (item: T) => T
+ buildRequest: (items: T[]) => any
+ updateApi: (request: any) => Promise
+ refreshApi: () => Promise
+ setItems: (items: T[]) => void
+ closeModal: () => void
+ errorKey: string
+ }) => {
+ // 检查是否有交易员正在使用
+ if (config.checkInUse(config.id)) {
+ const usingTraders = config.getUsingTraders(config.id)
+ const traderNames = usingTraders.map((t) => t.trader_name).join(', ')
+ toast.error(
+ `${t(config.cannotDeleteKey, language)} · ${t('tradersUsing', language)}: ${traderNames} · ${t('pleaseDeleteTradersFirst', language)}`
+ )
+ return
+ }
+
+ {
+ const ok = await confirmToast(t(config.confirmDeleteKey, language))
+ if (!ok) return
+ }
try {
- const updatedModels = allModels?.map(m =>
- m.id === modelId ? { ...m, apiKey: '', customApiUrl: '', customModelName: '', enabled: false } : m
- ) || [];
+ const updatedItems =
+ config.allItems?.map((item) =>
+ item.id === config.id ? config.clearFields(item) : item
+ ) || []
- const request = {
+ const request = config.buildRequest(updatedItems)
+ await toast.promise(config.updateApi(request), {
+ loading: '正在更新配置…',
+ success: '配置已更新',
+ error: '更新配置失败',
+ })
+
+ // 重新获取用户配置以确保数据同步
+ const refreshedItems = await config.refreshApi()
+ config.setItems(refreshedItems)
+
+ config.closeModal()
+ } catch (error) {
+ console.error(`Failed to delete ${config.type} config:`, error)
+ toast.error(t(config.errorKey, language))
+ }
+ }
+
+ const handleDeleteModelConfig = async (modelId: string) => {
+ await handleDeleteConfig({
+ id: modelId,
+ type: 'model',
+ checkInUse: isModelUsedByAnyTrader,
+ getUsingTraders: getTradersUsingModel,
+ cannotDeleteKey: 'cannotDeleteModelInUse',
+ confirmDeleteKey: 'confirmDeleteModel',
+ allItems: allModels,
+ clearFields: (m) => ({
+ ...m,
+ apiKey: '',
+ customApiUrl: '',
+ customModelName: '',
+ enabled: false,
+ }),
+ buildRequest: (models) => ({
models: Object.fromEntries(
- updatedModels.map(model => [
- model.provider, // 使用 provider 而不是 id
+ models.map((model) => [
+ model.provider,
{
enabled: model.enabled,
api_key: model.apiKey || '',
custom_api_url: model.customApiUrl || '',
- custom_model_name: model.customModelName || ''
- }
+ custom_model_name: model.customModelName || '',
+ },
])
- )
- };
+ ),
+ }),
+ updateApi: api.updateModelConfigs,
+ refreshApi: api.getModelConfigs,
+ setItems: (items) => {
+ // 使用函数式更新确保状态正确更新
+ setAllModels([...items])
+ },
+ closeModal: () => {
+ setShowModelModal(false)
+ setEditingModel(null)
+ },
+ errorKey: 'deleteConfigFailed',
+ })
+ }
- await api.updateModelConfigs(request);
- setAllModels(updatedModels);
- setShowModelModal(false);
- setEditingModel(null);
- } catch (error) {
- console.error('Failed to delete model config:', error);
- alert(t('deleteConfigFailed', language));
- }
- };
-
- const handleSaveModelConfig = async (modelId: string, apiKey: string, customApiUrl?: string, customModelName?: string) => {
+ const handleSaveModelConfig = async (
+ modelId: string,
+ apiKey: string,
+ customApiUrl?: string,
+ customModelName?: string
+ ) => {
try {
// 创建或更新用户的模型配置
- const existingModel = allModels?.find(m => m.id === modelId);
- let updatedModels;
+ const existingModel = allModels?.find((m) => m.id === modelId)
+ let updatedModels
// 找到要配置的模型（优先从已配置列表，其次从支持列表）
- const modelToUpdate = existingModel || supportedModels?.find(m => m.id === modelId);
+ const modelToUpdate =
+ existingModel || supportedModels?.find((m) => m.id === modelId)
if (!modelToUpdate) {
- alert(t('modelNotExist', language));
- return;
+ toast.error(t('modelNotExist', language))
+ return
}
if (existingModel) {
// 更新现有配置
- updatedModels = allModels?.map(m =>
- m.id === modelId ? { ...m, apiKey, customApiUrl: customApiUrl || '', customModelName: customModelName || '', enabled: true } : m
- ) || [];
+ updatedModels =
+ allModels?.map((m) =>
+ m.id === modelId
+ ? {
+ ...m,
+ apiKey,
+ customApiUrl: customApiUrl || '',
+ customModelName: customModelName || '',
+ enabled: true,
+ }
+ : m
+ ) || []
} else {
// 添加新配置
- const newModel = { ...modelToUpdate, apiKey, customApiUrl: customApiUrl || '', customModelName: customModelName || '', enabled: true };
- updatedModels = [...(allModels || []), newModel];
+ const newModel = {
+ ...modelToUpdate,
+ apiKey,
+ customApiUrl: customApiUrl || '',
+ customModelName: customModelName || '',
+ enabled: true,
+ }
+ updatedModels = [...(allModels || []), newModel]
}
const request = {
models: Object.fromEntries(
- updatedModels.map(model => [
+ updatedModels.map((model) => [
model.provider, // 使用 provider 而不是 id
{
enabled: model.enabled,
api_key: model.apiKey || '',
custom_api_url: model.customApiUrl || '',
- custom_model_name: model.customModelName || ''
- }
+ custom_model_name: model.customModelName || '',
+ },
])
- )
- };
+ ),
+ }
- await api.updateModelConfigs(request);
+ await toast.promise(api.updateModelConfigs(request), {
+ loading: '正在更新模型配置…',
+ success: '模型配置已更新',
+ error: '更新模型配置失败',
+ })
// 重新获取用户配置以确保数据同步
- const refreshedModels = await api.getModelConfigs();
- setAllModels(refreshedModels);
+ const refreshedModels = await api.getModelConfigs()
+ setAllModels(refreshedModels)
- setShowModelModal(false);
- setEditingModel(null);
+ setShowModelModal(false)
+ setEditingModel(null)
} catch (error) {
- console.error('Failed to save model config:', error);
- alert(t('saveConfigFailed', language));
+ console.error('Failed to save model config:', error)
+ toast.error(t('saveConfigFailed', language))
}
- };
+ }
const handleDeleteExchangeConfig = async (exchangeId: string) => {
- if (!confirm(t('confirmDeleteExchange', language))) return;
-
- try {
- const updatedExchanges = allExchanges?.map(e =>
- e.id === exchangeId ? { ...e, apiKey: '', secretKey: '', enabled: false } : e
- ) || [];
-
- const request = {
+ await handleDeleteConfig({
+ id: exchangeId,
+ type: 'exchange',
+ checkInUse: isExchangeUsedByAnyTrader,
+ getUsingTraders: getTradersUsingExchange,
+ cannotDeleteKey: 'cannotDeleteExchangeInUse',
+ confirmDeleteKey: 'confirmDeleteExchange',
+ allItems: allExchanges,
+ clearFields: (e) => ({
+ ...e,
+ apiKey: '',
+ secretKey: '',
+ hyperliquidWalletAddr: '',
+ asterUser: '',
+ asterSigner: '',
+ asterPrivateKey: '',
+ enabled: false,
+ }),
+ buildRequest: (exchanges) => ({
exchanges: Object.fromEntries(
- updatedExchanges.map(exchange => [
- exchange.id,
- {
- enabled: exchange.enabled,
- api_key: exchange.apiKey || '',
- secret_key: exchange.secretKey || '',
- testnet: exchange.testnet || false
- }
- ])
- )
- };
-
- await api.updateExchangeConfigs(request);
- setAllExchanges(updatedExchanges);
- setShowExchangeModal(false);
- setEditingExchange(null);
- } catch (error) {
- console.error('Failed to delete exchange config:', error);
- alert(t('deleteExchangeConfigFailed', language));
- }
- };
-
- const handleSaveExchangeConfig = async (exchangeId: string, apiKey: string, secretKey?: string, testnet?: boolean, hyperliquidWalletAddr?: string, asterUser?: string, asterSigner?: string, asterPrivateKey?: string) => {
- try {
- // 找到要配置的交易所（从supportedExchanges中）
- const exchangeToUpdate = supportedExchanges?.find(e => e.id === exchangeId);
- if (!exchangeToUpdate) {
- alert(t('exchangeNotExist', language));
- return;
- }
-
- // 创建或更新用户的交易所配置
- const existingExchange = allExchanges?.find(e => e.id === exchangeId);
- let updatedExchanges;
-
- if (existingExchange) {
- // 更新现有配置
- updatedExchanges = allExchanges?.map(e =>
- e.id === exchangeId ? {
- ...e,
- apiKey,
- secretKey,
- testnet,
- hyperliquidWalletAddr,
- asterUser,
- asterSigner,
- asterPrivateKey,
- enabled: true
- } : e
- ) || [];
- } else {
- // 添加新配置
- const newExchange = {
- ...exchangeToUpdate,
- apiKey,
- secretKey,
- testnet,
- hyperliquidWalletAddr,
- asterUser,
- asterSigner,
- asterPrivateKey,
- enabled: true
- };
- updatedExchanges = [...(allExchanges || []), newExchange];
- }
-
- const request = {
- exchanges: Object.fromEntries(
- updatedExchanges.map(exchange => [
+ exchanges.map((exchange) => [
exchange.id,
{
enabled: exchange.enabled,
@@ -433,65 +572,174 @@ export function AITradersPage({ onTraderSelect }: AITradersPageProps) {
hyperliquid_wallet_addr: exchange.hyperliquidWalletAddr || '',
aster_user: exchange.asterUser || '',
aster_signer: exchange.asterSigner || '',
- aster_private_key: exchange.asterPrivateKey || ''
- }
+ aster_private_key: exchange.asterPrivateKey || '',
+ },
])
- )
- };
-
- await api.updateExchangeConfigs(request);
-
+ ),
+ }),
+ updateApi: api.updateExchangeConfigsEncrypted,
+ refreshApi: api.getExchangeConfigs,
+ setItems: (items) => {
+ // 使用函数式更新确保状态正确更新
+ setAllExchanges([...items])
+ },
+ closeModal: () => {
+ setShowExchangeModal(false)
+ setEditingExchange(null)
+ },
+ errorKey: 'deleteExchangeConfigFailed',
+ })
+ }
+
+ const handleSaveExchangeConfig = async (
+ exchangeId: string,
+ apiKey: string,
+ secretKey?: string,
+ testnet?: boolean,
+ hyperliquidWalletAddr?: string,
+ asterUser?: string,
+ asterSigner?: string,
+ asterPrivateKey?: string
+ ) => {
+ try {
+ // 找到要配置的交易所（从supportedExchanges中）
+ const exchangeToUpdate = supportedExchanges?.find(
+ (e) => e.id === exchangeId
+ )
+ if (!exchangeToUpdate) {
+ toast.error(t('exchangeNotExist', language))
+ return
+ }
+
+ // 创建或更新用户的交易所配置
+ const existingExchange = allExchanges?.find((e) => e.id === exchangeId)
+ let updatedExchanges
+
+ if (existingExchange) {
+ // 更新现有配置
+ updatedExchanges =
+ allExchanges?.map((e) =>
+ e.id === exchangeId
+ ? {
+ ...e,
+ apiKey,
+ secretKey,
+ testnet,
+ hyperliquidWalletAddr,
+ asterUser,
+ asterSigner,
+ asterPrivateKey,
+ enabled: true,
+ }
+ : e
+ ) || []
+ } else {
+ // 添加新配置
+ const newExchange = {
+ ...exchangeToUpdate,
+ apiKey,
+ secretKey,
+ testnet,
+ hyperliquidWalletAddr,
+ asterUser,
+ asterSigner,
+ asterPrivateKey,
+ enabled: true,
+ }
+ updatedExchanges = [...(allExchanges || []), newExchange]
+ }
+
+ const request = {
+ exchanges: Object.fromEntries(
+ updatedExchanges.map((exchange) => [
+ exchange.id,
+ {
+ enabled: exchange.enabled,
+ api_key: exchange.apiKey || '',
+ secret_key: exchange.secretKey || '',
+ testnet: exchange.testnet || false,
+ hyperliquid_wallet_addr: exchange.hyperliquidWalletAddr || '',
+ aster_user: exchange.asterUser || '',
+ aster_signer: exchange.asterSigner || '',
+ aster_private_key: exchange.asterPrivateKey || '',
+ },
+ ])
+ ),
+ }
+
+ await toast.promise(api.updateExchangeConfigsEncrypted(request), {
+ loading: '正在更新交易所配置…',
+ success: '交易所配置已更新',
+ error: '更新交易所配置失败',
+ })
+
// 重新获取用户配置以确保数据同步
- const refreshedExchanges = await api.getExchangeConfigs();
- setAllExchanges(refreshedExchanges);
-
- setShowExchangeModal(false);
- setEditingExchange(null);
+ const refreshedExchanges = await api.getExchangeConfigs()
+ setAllExchanges(refreshedExchanges)
+
+ setShowExchangeModal(false)
+ setEditingExchange(null)
} catch (error) {
- console.error('Failed to save exchange config:', error);
- alert(t('saveConfigFailed', language));
+ console.error('Failed to save exchange config:', error)
+ toast.error(t('saveConfigFailed', language))
}
- };
+ }
const handleAddModel = () => {
- setEditingModel(null);
- setShowModelModal(true);
- };
+ setEditingModel(null)
+ setShowModelModal(true)
+ }
const handleAddExchange = () => {
- setEditingExchange(null);
- setShowExchangeModal(true);
- };
+ setEditingExchange(null)
+ setShowExchangeModal(true)
+ }
- const handleSaveSignalSource = async (coinPoolUrl: string, oiTopUrl: string) => {
+ const handleSaveSignalSource = async (
+ coinPoolUrl: string,
+ oiTopUrl: string
+ ) => {
try {
- await api.saveUserSignalSource(coinPoolUrl, oiTopUrl);
- setUserSignalSource({ coinPoolUrl, oiTopUrl });
- setShowSignalSourceModal(false);
+ await toast.promise(api.saveUserSignalSource(coinPoolUrl, oiTopUrl), {
+ loading: '正在保存…',
+ success: '保存成功',
+ error: '保存失败',
+ })
+ setUserSignalSource({ coinPoolUrl, oiTopUrl })
+ setShowSignalSourceModal(false)
} catch (error) {
- console.error('Failed to save signal source:', error);
- alert(t('saveSignalSourceFailed', language));
+ console.error('Failed to save signal source:', error)
+ toast.error(t('saveSignalSourceFailed', language))
}
- };
+ }
return (
{/* Header */}
-
+
+
{t('aiTraders', language)}
-
+
{traders?.length || 0} {t('active', language)}
@@ -501,14 +749,14 @@ export function AITradersPage({ onTraderSelect }: AITradersPageProps) {
-
+
+ {/* 信号源配置警告 */}
+ {traders &&
+ traders.some((t) => t.use_coin_pool || t.use_oi_top) &&
+ !userSignalSource.coinPoolUrl &&
+ !userSignalSource.oiTopUrl && (
+
+
+ {t('signalSourceWarningMessage', language)}
+
+
+ {t('solutions', language)}
+
+
+ - 点击"{t('signalSource', language)}"按钮配置API地址
+ - 或在交易员配置中禁用"使用币种池"和"使用OI Top"
+ - 或在交易员配置中设置自定义币种列表
+
+
+
+
+
+ )}
+
{/* Configuration Status */}
{/* AI Models */}
-
-
+
- {configuredModels.map(model => {
- const inUse = isModelInUse(model.id);
+ {configuredModels.map((model) => {
+ const inUse = isModelInUse(model.id)
return (
handleModelClick(model.id)}
>
- {getModelIcon(model.provider || model.id, { width: 28, height: 28 }) || (
-
+ {getModelIcon(model.provider || model.id, {
+ width: 28,
+ height: 28,
+ }) || (
+
{getShortName(model.name)[0]}
)}
- {getShortName(model.name)}
+
+ {getShortName(model.name)}
+
- {inUse ? t('inUse', language) : model.enabled ? t('enabled', language) : t('configured', language)}
+ {inUse
+ ? t('inUse', language)
+ : model.enabled
+ ? t('enabled', language)
+ : t('configured', language)}
-
+
- );
+ )
})}
{configuredModels.length === 0 && (
-
+
-
+
- {configuredExchanges.map(exchange => {
- const inUse = isExchangeInUse(exchange.id);
+ {configuredExchanges.map((exchange) => {
+ const inUse = isExchangeInUse(exchange.id)
return (
handleExchangeClick(exchange.id)}
@@ -630,20 +973,37 @@ export function AITradersPage({ onTraderSelect }: AITradersPageProps) {
{getExchangeIcon(exchange.id, { width: 28, height: 28 })}
- {getShortName(exchange.name)}
+
+ {getShortName(exchange.name)}
+
- {exchange.type.toUpperCase()} • {inUse ? t('inUse', language) : exchange.enabled ? t('enabled', language) : t('configured', language)}
+ {exchange.type.toUpperCase()} •{' '}
+ {inUse
+ ? t('inUse', language)
+ : exchange.enabled
+ ? t('enabled', language)
+ : t('configured', language)}
-
+
- );
+ )
})}
{configuredExchanges.length === 0 && (
-
+
-
+
{traders && traders.length > 0 ? (
- {traders.map(trader => (
-
+ {traders.map((trader) => (
+
-
+
- 📡 {t('signalSourceConfig', language)}
+ {t('signalSourceConfig', language)}
-
-
+
+
-
+
+
-
| Symbol | -Trades | -Win Rate | -Total P&L (USDT) | -Avg P&L (USDT) | +||||
|---|---|---|---|---|---|---|---|---|
| + Symbol + | ++ Trades + | ++ Win Rate + | ++ Total P&L (USDT) + | ++ Avg P&L (USDT) + | ||||
| - {stat.symbol} + + {stat.symbol} + | -+ | {stat.total_trades} | -= 50 ? '#10B981' : '#F87171' - }}> + | = 50 ? '#10B981' : '#F87171', + }} + > {(stat.win_rate || 0).toFixed(1)}% | -0 ? '#10B981' : '#F87171' - }}> - {(stat.total_pn_l || 0) > 0 ? '+' : ''}{(stat.total_pn_l || 0).toFixed(2)} + | 0 ? '#10B981' : '#F87171', + }} + > + {(stat.total_pn_l || 0) > 0 ? '+' : ''} + {(stat.total_pn_l || 0).toFixed(2)} | -0 ? '#10B981' : '#F87171' - }}> - {(stat.avg_pn_l || 0) > 0 ? '+' : ''}{(stat.avg_pn_l || 0).toFixed(2)} + | 0 ? '#10B981' : '#F87171', + }} + > + {(stat.avg_pn_l || 0) > 0 ? '+' : ''} + {(stat.avg_pn_l || 0).toFixed(2)} |