hchain-mcp 1.0.0

package/dist/tools/payments.js

@@ -0,0 +1,100 @@
+/**
+ * Payments 模块 — CAT:[链上-支付]
+ * Agent Payments Protocol: Agent端 A2A (单次支付) + HTTP端 x402
+ *
+ * 路径来源: https://web3.okx.com API 参考
+ *   Agent端: /api/v6/pay/a2a/payment/create | /p/{id} | /p/{id}/credential | /p/{id}/status
+ *   HTTP端:  /api/v6/pay/x402/supported | verify | settle | settle/status
+ */
+import { z } from "zod";
+import { paymentsApi } from "../adapters/onchainos.js";
+import { toResult, toError, AUTH_REQUIRED } from "../adapters/shared.js";
+export function registerPaymentsTools(server, auth) {
+    // ── Agent 端 A2A 单次支付 ─────────────────────────────
+    server.tool("onchainos_payment_create", "CAT:[链上-支付] | ## 功能: Seller Agent 创建单次付款(charge), 返回 paymentId+challenge+付款链接\n## 场景: Agent 卖家在对话中需要收费时调此工具, 拿到付款链接发给买家\n## 关键词: payment, create, charge, seller, 收款, a2a\n## 参数:\n##   - amount: 收款金额, 人类可读(必填, 如'0.1'=0.1 USDT0)\n##   - symbol: 代币符号(必填, USD_T0/USDC/USDG)\n##   - recipient: 收款钱包地址(必填)\n##   - description: 付款描述(可选)\n##   - externalId: 业务订单号(可选, 幂等用)\n##   - expiresIn: 有效期秒数(可选, 默认1800=30分钟)\n## 鉴权: 需要 API Key(交易)\n## 风险: WRITE - 创建付款订单\n## 返回量: 微小 ~2KB\n## 关联: 本工具创建 -> 把 paymentId/付款链接发给买家 -> 买家调 onchainos_payment_detail -> onchainos_payment_submit -> onchainos_payment_status", {
+        amount: z.string().describe("收款金额, 人类可读(如'0.1'=0.1 USDT0)"),
+        symbol: z.enum(["USD₮0", "USDC", "USDG"]).describe("代币符号: USD_T0/USDC/USDG"),
+        recipient: z.string().describe("Seller 收款钱包地址"),
+        description: z.string().optional().describe("付款描述, 如'翻译服务-3000字'"),
+        externalId: z.string().optional().describe("Seller 业务订单号, 用于幂等"),
+        expiresIn: z.number().int().optional().describe("有效期(秒), 默认1800=30分钟"),
+    }, { destructiveHint: true }, async ({ amount, symbol, recipient, description, externalId, expiresIn }) => {
+        if (!auth)
+            return AUTH_REQUIRED("TRADE");
+        try {
+            const data = await paymentsApi.create(auth, {
+                type: "charge", amount, symbol, recipient,
+                ...(description ? { description } : {}),
+                ...(externalId ? { externalId } : {}),
+                ...(expiresIn ? { expiresIn } : {}),
+                deliveries: { includeUrl: true },
+            });
+            return toResult(data, {
+                nextSteps: [
+                    { action: "把付款链接发给买家", tool: "onchainos_payment_detail", condition: "通过消息通道或对话发送 https://pay.okx.com/p/{paymentId}" },
+                    { action: "买家拉取详情", tool: "onchainos_payment_detail", params: { paymentId: "{{data.paymentId}}" }, condition: "买家侧操作" },
+                    { action: "买家签名后提交", tool: "onchainos_payment_submit", params: { paymentId: "{{data.paymentId}}" }, condition: "买家侧操作" },
+                    { action: "轮询结算结果", tool: "onchainos_payment_status", params: { paymentId: "{{data.paymentId}}" }, condition: "提交后轮询" },
+                ],
+            });
+        }
+        catch (e) {
+            return toError(e);
+        }
+    });
+    server.tool("onchainos_payment_detail", "CAT:[链上-支付] | ## 功能: Buyer 拉取付款详情(challenge), 含金额/收款方/代币/过期时间\n## 场景: 买家拿到 paymentId 或付款链接后查看付款信息\n## 关键词: payment, detail, challenge, buyer, a2a\n## 参数:\n##   - paymentId: 付款ID(必填, 从付款链接或卖家消息获取)\n## 鉴权: PUBLIC - 公开接口, 无需 API Key\n## 风险: READ - 只读查询\n## 返回量: 微小 ~2KB\n## 关联: 卖家发 paymentId -> 本工具 -> onchainos_payment_submit", {
+        paymentId: z.string().describe("付款ID。格式 a2a_XXXX。从付款链接 https://pay.okx.com/p/{paymentId} 或卖家消息获取"),
+    }, { readOnlyHint: true }, async ({ paymentId }) => {
+        try {
+            return toResult(await paymentsApi.detail(paymentId));
+        }
+        catch (e) {
+            return toError(e);
+        }
+    });
+    server.tool("onchainos_payment_submit", "CAT:[链上-支付] | ## 功能: Buyer 提交 EIP-3009 签名凭证, Broker 验签后上链结算\n## 场景: 买家签名后提交支付, 资金直接从买家转给卖家\n## 关键词: payment, submit, credential, EIP-3009, 签名, a2a\n## 参数:\n##   - paymentId: 付款ID(必填)\n##   - authorization: EIP-3009 授权 JSON 字符串(必填)\n##     {type:\"eip-3009\",from,to,value,validAfter,validBefore,nonce}\n##   - signature: EIP-712 签名 hex(必填, 65字节)\n## 鉴权: PUBLIC - 公开接口, 无需 API Key\n## 风险: WRITE - 触发链上结算\n## 返回量: 微小 ~1KB\n## 关联: onchainos_payment_detail -> 买家签名 -> 本工具 -> onchainos_payment_status", {
+        paymentId: z.string().describe("付款ID"),
+        authorization: z.string().describe("EIP-3009 授权 JSON。格式: {\"type\":\"eip-3009\",\"from\":\"0x买家地址\",\"to\":\"0x卖家地址\",\"value\":\"100000\",\"validAfter\":\"0\",\"validBefore\":\"1714521600\",\"nonce\":\"0x...\"}。value 必须与 challenge 中 amount 一致"),
+        signature: z.string().describe("EIP-712 签名(0x前缀, 65字节 hex)。用买家钱包对 authorization 签名得到"),
+    }, { destructiveHint: true }, async ({ paymentId, authorization, signature }) => {
+        try {
+            let auth;
+            try {
+                auth = JSON.parse(authorization);
+            }
+            catch {
+                return toError(new Error("authorization 格式错误"));
+            }
+            return toResult(await paymentsApi.submit(paymentId, {
+                payload: { type: "transaction", signature, authorization: auth },
+            }), {
+                nextSteps: [
+                    { action: "查询结算状态", tool: "onchainos_payment_status", params: { paymentId } },
+                    { action: "交易确认后 Seller 交付资源", tool: "onchainos_payment_status", condition: "status=completed 时" },
+                ],
+            });
+        }
+        catch (e) {
+            return toError(e);
+        }
+    });
+    server.tool("onchainos_payment_status", "CAT:[链上-支付] | ## 功能: 查询支付状态(pending/settling/completed/failed/expired)\n## 场景: 提交凭证后轮询确认结算结果, 拿到 txHash\n## 关键词: payment, status, 状态, txHash, a2a\n## 参数:\n##   - paymentId: 付款ID(必填)\n## 鉴权: PUBLIC - 公开接口, 无需 API Key\n## 风险: READ - 只读查询\n## 返回量: 微小 ~1KB\n## 关联: onchainos_payment_submit -> 本工具", {
+        paymentId: z.string().describe("付款ID"),
+    }, { readOnlyHint: true }, async ({ paymentId }) => {
+        try {
+            return toResult(await paymentsApi.status(paymentId));
+        }
+        catch (e) {
+            return toError(e);
+        }
+    });
+    // ── HTTP 端基础设施 ───────────────────────────────────
+    server.tool("onchainos_payment_supported", "CAT:[链上-支付] | ## 功能: 获取支付支持的网络/代币/scheme 列表\n## 场景: 发起支付前确认目标链和代币是否支持\n## 关键词: x402, payment, 支持列表, network, token\n## 参数: 无\n## 鉴权: 需要 API Key(只读)\n## 风险: READ - 只读查询\n## 返回量: 微小 ~2KB\n## 关联: 本工具 -> onchainos_payment_create / onchainos_payment_verify", {}, { readOnlyHint: true }, async () => { if (!auth)
+        return AUTH_REQUIRED("READ"); try {
+        return toResult(await paymentsApi.supported(auth));
+    }
+    catch (e) {
+        return toError(e);
+    } });
+}
+//# sourceMappingURL=payments.js.map

package/dist/tools/skills.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Auth } from "../adapters/shared.js";
+export declare function registerSkillTools(server: McpServer, auth: Auth | null): void;
+//# sourceMappingURL=skills.d.ts.map

package/dist/tools/skills.js

@@ -0,0 +1,464 @@
+/**
+ * Skills 模块 — CAT:[链上-Skill]
+ * API 组合技能: 将多个 API 调用编排为单步工具
+ * Phase 2: 交易全链路 / 风险检测链 / 智能滑点 / 信号聚合
+ */
+import { z } from "zod";
+import { tradeApi, gatewayApi, marketApi, } from "../adapters/onchainos.js";
+import { toResult, AUTH_REQUIRED } from "../adapters/shared.js";
+// ── 常量 ────────────────────────────────────────────────────
+/** 主链币地址集合 — 这些地址代表原生代币，无需 approve */
+const NATIVE_ADDR = new Set([
+    "",
+    "0x0000000000000000000000000000000000000000",
+    "0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee",
+    "0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE",
+    "11111111111111111111111111111111",
+    "0x2::sui::SUI",
+    "EQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAM9c",
+]);
+function isNative(address) {
+    return NATIVE_ADDR.has(address) || NATIVE_ADDR.has(address.toLowerCase());
+}
+/** 从 swap API 返回体中提取 calldata/to/value，兼容多种返回结构 */
+function extractTxFields(raw) {
+    const tx = raw?.tx ?? raw;
+    return {
+        to: tx?.to ?? "",
+        data: tx?.data ?? "",
+        value: tx?.value ?? "0",
+        gasPrice: tx?.gasPrice ?? tx?.maxPriorityFeePerGas,
+        gas: tx?.gas,
+    };
+}
+// ═══════════════════════════════════════════════════════════════
+//  Skill 1: 交易全链路
+// ═══════════════════════════════════════════════════════════════
+export function registerSkillTools(server, auth) {
+    // ── 1. 交易全链路 ──────────────────────────────────────
+    server.tool("onchainos_skill_trade_pipeline", "CAT:[链上-Swap] | ## 功能: 全自动交易管线: 报价→(授权)→构建交易→模拟, 返回完整 calldata 和逐步骤结果\n## 场景: \"用1 SOL换USDC\" → 自动判断主链币省去授权, ERC20自动加approve\n## 关键词: pipeline, trade, 全链路, swap, 自动, simulate, approve\n## 参数:\n##   - chainIndex/fromTokenAddress/toTokenAddress/amount/userWalletAddress(必填)\n##   - slippagePercent: 滑点(可选,默认1.0)\n##   - gasLevel: Gas等级(可选,默认average)\n## 鉴权: 需要 API Key(交易)\n## 风险: WRITE - 构建 calldata, 不上链\n## 返回量: 中等 ~15KB\n## 关联: 本工具产出 calldata → 用户签名 → onchainos_gateway_broadcast", {
+        chainIndex: z.string().describe("链索引。如 '1'=ETH '501'=Solana '8453'=Base。从 onchainos_dex_supported_chain 获取"),
+        fromTokenAddress: z.string().describe("卖出代币合约地址。主链币传空字符串''或'0xEeeeEeeeEeeeEeeeEeeeEeeeEeeeEeeeEeeeEEeE'"),
+        toTokenAddress: z.string().describe("买入代币合约地址"),
+        amount: z.string().describe("卖出数量(最小单位,含精度)。如 1 USDT=1000000, 1 SOL=1000000000"),
+        userWalletAddress: z.string().describe("用户钱包地址"),
+        slippagePercent: z.string().optional().default("1.0").describe("滑点百分比, 默认1.0。建议从 onchainos_skill_smart_slippage 获取"),
+        gasLevel: z.enum(["slow", "average", "fast"]).optional().describe("Gas等级, 默认average"),
+    }, { destructiveHint: true }, async (params) => {
+        if (!auth)
+            return AUTH_REQUIRED("TRADE");
+        const steps = [];
+        const warnings = [];
+        const { chainIndex, fromTokenAddress, toTokenAddress, amount, userWalletAddress, slippagePercent } = params;
+        // Step 1: Quote
+        try {
+            const qParams = {
+                chainIndex, fromTokenAddress, toTokenAddress, amount,
+                swapMode: "exactIn",
+            };
+            const quoteR = await tradeApi.quote(auth, qParams);
+            steps.push({ step: "quote", status: "ok", data: { priceImpactPercent: quoteR.priceImpactPercent, estimateGasFee: quoteR.estimateGasFee } });
+        }
+        catch (e) {
+            steps.push({ step: "quote", status: "error", error: e instanceof Error ? e.message : String(e) });
+            return toResult({ steps, summary: { status: "failed", failedAt: "quote", reason: "报价失败, 无法继续" } }, { warnings });
+        }
+        // Step 2: Approve (仅 ERC20 需要)
+        const needApprove = !isNative(fromTokenAddress);
+        let approveOk = false;
+        if (needApprove) {
+            try {
+                const approveR = await tradeApi.approveTransaction(auth, chainIndex, fromTokenAddress, amount);
+                steps.push({ step: "approve", status: "ok", data: { tokenContractAddress: fromTokenAddress, approveAmount: amount } });
+                approveOk = true;
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                steps.push({ step: "approve", status: "error", error: msg });
+                warnings.push(`授权失败, 跳过授权继续: ${msg}`);
+            }
+        }
+        else {
+            steps.push({ step: "approve", status: "skipped", warning: "主链币无需授权" });
+        }
+        // Step 3: Build Swap
+        let swapRaw;
+        try {
+            const sParams = {
+                chainIndex, fromTokenAddress, toTokenAddress, amount,
+                userWalletAddress, slippagePercent: slippagePercent ?? "1.0",
+            };
+            if (params.gasLevel)
+                sParams.gasLevel = params.gasLevel;
+            if (approveOk) {
+                sParams.approveTransaction = "true";
+                sParams.approveAmount = amount;
+            }
+            swapRaw = await tradeApi.swap(auth, sParams);
+            const tx = extractTxFields(swapRaw);
+            steps.push({ step: "swap", status: "ok", data: { to: tx.to, dataLen: tx.data?.length ?? 0, value: tx.value, gasPrice: tx.gasPrice, gas: tx.gas } });
+        }
+        catch (e) {
+            steps.push({ step: "swap", status: "error", error: e instanceof Error ? e.message : String(e) });
+            return toResult({ steps, summary: { status: "failed", failedAt: "swap", reason: "构建交易失败, 无法继续" } }, { warnings });
+        }
+        // Step 4: Simulate
+        const swapTx = extractTxFields(swapRaw);
+        try {
+            const simR = await gatewayApi.simulate(auth, {
+                fromAddress: userWalletAddress,
+                toAddress: swapTx.to,
+                chainIndex,
+                txAmount: swapTx.value,
+                extJson: { inputData: swapTx.data },
+            });
+            steps.push({ step: "simulate", status: "ok", data: simR });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            steps.push({ step: "simulate", status: "error", error: msg });
+            warnings.push(`模拟执行失败: ${msg}。广播前请手动调用 onchainos_gateway_simulate 确认`);
+        }
+        const okCount = steps.filter(s => s.status === "ok" || s.status === "skipped").length;
+        const isReady = steps.every(s => s.status !== "error" || s.step === "approve");
+        const nextSteps = [
+            { action: "用户签名 calldata", tool: "—", condition: "用私钥/钱包对 swap 步骤返回的 data(calldata) 签名" },
+        ];
+        if (isReady) {
+            nextSteps.push({ action: "广播签名交易", tool: "onchainos_gateway_broadcast", params: { chainIndex, address: userWalletAddress } });
+            nextSteps.push({ action: "查交易状态", tool: "onchainos_gateway_orders", params: { address: userWalletAddress, chainIndex } });
+        }
+        return toResult({
+            steps,
+            calldata: { to: swapTx.to, data: swapTx.data, value: swapTx.value, gasPrice: swapTx.gasPrice, gas: swapTx.gas },
+            rawResponses: { swap: swapRaw },
+            summary: { status: isReady ? "ready" : "partial", totalSteps: steps.length, okSteps: okCount, failedSteps: steps.filter(s => s.status === "error").map(s => s.step) },
+        }, { warnings: warnings.length ? warnings : undefined, nextSteps });
+    });
+    // ── 2. 风险检测链 ──────────────────────────────────────
+    server.tool("onchainos_skill_risk_detect", "CAT:[链上-行情] | ## 功能: 综合风险检测: 安全分析+持仓集中度+打包检测+开发者信息, 输出0-100风险评分\n## 场景: 交易土狗/新代币前必调, 检测貔貅/Rug Pull/狙击手/打包\n## 关键词: risk, 风险, 安全, honeypot, 貔貅, rug, bundle, cluster, dev\n## 参数:\n##   - chainIndex/tokenContractAddress(必填)\n## 鉴权: 需要 API Key(只读)\n## 风险: READ - 只读查询\n## 返回量: 中等 ~10KB\n## 关联: onchainos_token_search → 本工具 → onchainos_skill_trade_pipeline(低风险通过后)", {
+        chainIndex: z.string().describe("链索引。如 '501'=Solana '1'=ETH '8453'=Base"),
+        tokenContractAddress: z.string().describe("代币合约地址。从 onchainos_token_search 获取"),
+    }, { readOnlyHint: true }, async ({ chainIndex, tokenContractAddress }) => {
+        if (!auth)
+            return AUTH_REQUIRED("READ");
+        // 4 个 API 并行调用，互不依赖
+        const results = await Promise.allSettled([
+            marketApi.tokenAdvancedInfo(auth, chainIndex, tokenContractAddress)
+                .then(d => ({ step: "advanced_info", status: "ok", data: d }))
+                .catch(e => ({ step: "advanced_info", status: "error", error: e instanceof Error ? e.message : String(e) })),
+            marketApi.tokenClusterOverview(auth, chainIndex, tokenContractAddress)
+                .then(d => ({ step: "cluster_overview", status: "ok", data: d }))
+                .catch(e => ({ step: "cluster_overview", status: "error", error: e instanceof Error ? e.message : String(e) })),
+            marketApi.memepumpBundleInfo(auth, chainIndex, tokenContractAddress)
+                .then(d => ({ step: "bundle_info", status: "ok", data: d }))
+                .catch(e => ({ step: "bundle_info", status: "error", error: e instanceof Error ? e.message : String(e) })),
+            marketApi.memepumpTokenDevInfo(auth, chainIndex, tokenContractAddress)
+                .then(d => ({ step: "dev_info", status: "ok", data: d }))
+                .catch(e => ({ step: "dev_info", status: "error", error: e instanceof Error ? e.message : String(e) })),
+        ]);
+        const steps = [];
+        for (const r of results) {
+            if (r.status === "fulfilled")
+                steps.push(r.value);
+            else
+                steps.push({ step: "unknown", status: "error", error: r.reason?.message ?? String(r.reason) });
+        }
+        // ── 风险评分 ──────────────────────────────────────
+        let score = 0;
+        const factors = [];
+        const advInfo = steps.find(s => s.step === "advanced_info" && s.status === "ok")?.data;
+        const clustInfo = steps.find(s => s.step === "cluster_overview" && s.status === "ok")?.data;
+        const bundleInfo = steps.find(s => s.step === "bundle_info" && s.status === "ok")?.data;
+        const devInfo = steps.find(s => s.step === "dev_info" && s.status === "ok")?.data;
+        // Factor 1: HoneyPot (30 pts)
+        if (advInfo?.isHoneypot) {
+            score += 30;
+            factors.push("检测到貔貅(HoneyPot)");
+        }
+        if (advInfo?.isHoneyPot) {
+            score += 30;
+            factors.push("检测到貔貅(HoneyPot)");
+        }
+        // Factor 2: Risk Level (20 pts)
+        const riskLevel = (advInfo?.riskLevel ?? "").toUpperCase();
+        if (riskLevel === "HIGH" || riskLevel === "CRITICAL") {
+            score += 20;
+            factors.push(`风险等级=${riskLevel}`);
+        }
+        else if (riskLevel === "MEDIUM") {
+            score += 10;
+            factors.push(`风险等级=${riskLevel}`);
+        }
+        // Factor 3: Tax rate (10 pts — high buy/sell tax)
+        const buyTax = parseFloat(advInfo?.buyTax ?? "0");
+        const sellTax = parseFloat(advInfo?.sellTax ?? "0");
+        if (buyTax > 10 || sellTax > 10) {
+            score += 10;
+            factors.push(`高税率 buy=${buyTax}% sell=${sellTax}%`);
+        }
+        else if (buyTax > 5 || sellTax > 5) {
+            score += 5;
+            factors.push(`中等税率 buy=${buyTax}% sell=${sellTax}%`);
+        }
+        // Factor 4: Rug Pull % (15 pts)
+        const rugPercent = parseFloat(clustInfo?.rugPullPercent ?? "0");
+        if (rugPercent > 50) {
+            score += 15;
+            factors.push(`Rug概率>50%: ${rugPercent}%`);
+        }
+        else if (rugPercent > 25) {
+            score += 8;
+            factors.push(`Rug概率>25%: ${rugPercent}%`);
+        }
+        // Factor 5: Concentration (15 pts)
+        const concentration = (clustInfo?.clusterConcentration ?? "").toUpperCase();
+        if (concentration === "HIGH") {
+            score += 15;
+            factors.push("持仓高度集中");
+        }
+        else if (concentration === "MEDIUM") {
+            score += 7;
+            factors.push("持仓中度集中");
+        }
+        // Factor 6: Bundle detected (10 pts)
+        const hasBundle = bundleInfo && (bundleInfo.isBundled || (Array.isArray(bundleInfo.bundles) && bundleInfo.bundles.length > 0));
+        if (hasBundle) {
+            score += 10;
+            factors.push("检测到打包(Bundle)交易");
+        }
+        // Factor 7: Creator/dev history (10 pts)
+        const hasDevRisk = devInfo &&
+            (devInfo.isRugHistory || devInfo.hasRugHistory ||
+                parseFloat(devInfo.rugCount ?? "0") > 0 ||
+                devInfo.isRugDev === true);
+        if (hasDevRisk) {
+            score += 10;
+            factors.push("开发者有Rug历史");
+        }
+        score = Math.min(score, 100);
+        const level = score <= 20 ? "LOW" : score <= 50 ? "MEDIUM" : score <= 70 ? "HIGH" : "CRITICAL";
+        const nextSteps = [];
+        if (level === "LOW" || level === "MEDIUM") {
+            nextSteps.push({ action: "低/中风险, 可考虑交易", tool: "onchainos_skill_trade_pipeline", condition: "确认风险可接受后" });
+        }
+        else {
+            nextSteps.push({ action: "高风险, 强烈不建议交易", tool: "—", condition: "风险评分过高, 建议放弃" });
+            nextSteps.push({ action: "如仍需交易, 手动调小金额并设高滑点", tool: "onchainos_dex_swap", condition: "了解风险后自行决定" });
+        }
+        return toResult({
+            steps,
+            riskScore: { total: score, level, factors },
+            summary: {
+                status: level === "LOW" ? "safe" : level === "MEDIUM" ? "caution" : "danger",
+                recommendation: level === "LOW" ? "风险可控" : level === "MEDIUM" ? "谨慎操作" : level === "HIGH" ? "强烈不建议" : "禁止交易",
+            },
+        }, { nextSteps });
+    });
+    // ── 3. 智能滑点推荐 ────────────────────────────────────
+    server.tool("onchainos_skill_smart_slippage", "CAT:[链上-Swap] | ## 功能: 基于波动率和价格影响智能推荐最优滑点百分比\n## 场景: Agent 构建交易前获取推荐滑点, 避免因滑点太低被拒或太高被夹\n## 关键词: slippage, 滑点, 推荐, volatility, 波动率, price impact\n## 参数:\n##   - chainIndex/fromTokenAddress/toTokenAddress(必填)\n##   - amount: 交易数量(可选,用于评估价格影响)\n## 鉴权: 需要 API Key(只读)\n## 风险: READ - 只读查询\n## 返回量: 微小 ~3KB\n## 关联: 本工具 → onchainos_dex_swap / onchainos_skill_trade_pipeline(传 recommendedSlippagePercent)", {
+        chainIndex: z.string().describe("链索引。如 '501'=Solana '1'=ETH"),
+        fromTokenAddress: z.string().describe("卖出代币合约地址"),
+        toTokenAddress: z.string().describe("买入代币合约地址"),
+        amount: z.string().optional().describe("交易数量(最小单位)。填了会调 quote 评估价格影响, 不填仅用波动率估算"),
+    }, { readOnlyHint: true }, async ({ chainIndex, fromTokenAddress, toTokenAddress, amount }) => {
+        if (!auth)
+            return AUTH_REQUIRED("READ");
+        const steps = [];
+        const warnings = [];
+        // Step 1: 查报价获取价格影响
+        let priceImpact = 0;
+        if (amount) {
+            try {
+                const qParams = { chainIndex, fromTokenAddress, toTokenAddress, amount, swapMode: "exactIn" };
+                const quoteR = await tradeApi.quote(auth, qParams);
+                priceImpact = Math.abs(parseFloat(quoteR.priceImpactPercent ?? "0"));
+                steps.push({ step: "quote_impact", status: "ok", data: { priceImpactPercent: priceImpact } });
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                steps.push({ step: "quote_impact", status: "error", error: msg });
+                warnings.push(`报价查询失败, 跳过价格影响评估: ${msg}`);
+            }
+        }
+        else {
+            steps.push({ step: "quote_impact", status: "skipped", warning: "未提供 amount, 跳过价格影响评估" });
+        }
+        // Step 2: 查 K 线计算波动率
+        let volatility = 0.5; // 默认中等波动
+        try {
+            const candleR = await marketApi.candles(auth, {
+                chainIndex, tokenContractAddress: fromTokenAddress,
+                bar: "1H", limit: "100",
+            });
+            const candles = Array.isArray(candleR) ? candleR : [];
+            if (candles.length >= 2) {
+                const closes = candles.map((c) => parseFloat(Array.isArray(c) ? c[4] : (c.close ?? c.c ?? "0"))).filter((v) => !isNaN(v) && v > 0);
+                if (closes.length >= 2) {
+                    const mean = closes.reduce((a, b) => a + b, 0) / closes.length;
+                    const variance = closes.reduce((s, c) => s + Math.pow(c - mean, 2), 0) / closes.length;
+                    volatility = Math.sqrt(variance) / mean; // CV (coefficient of variation)
+                }
+            }
+            steps.push({ step: "volatility", status: "ok", data: { coefficientOfVariation: +volatility.toFixed(4), candleCount: candles.length } });
+        }
+        catch (e) {
+            const msg = e instanceof Error ? e.message : String(e);
+            steps.push({ step: "volatility", status: "error", error: msg });
+            warnings.push(`K线查询失败, 使用默认波动率 0.5: ${msg}`);
+        }
+        // Step 3: 计算推荐滑点
+        let baseSlippage = 3.0;
+        const vtiers = [[0.01, 0.3], [0.03, 0.5], [0.08, 1.0], [0.15, 2.0]];
+        for (const [maxV, slip] of vtiers) {
+            if (volatility <= maxV) {
+                baseSlippage = slip;
+                break;
+            }
+        }
+        let impactAdjust = 0;
+        if (priceImpact > 10)
+            impactAdjust = 2.0;
+        else if (priceImpact > 5)
+            impactAdjust = 1.0;
+        else if (priceImpact > 1)
+            impactAdjust = 0.5;
+        const recommended = Math.min(Math.max(baseSlippage + impactAdjust, 0.1), 15.0);
+        const conservative = Math.max(recommended * 0.5, 0.1);
+        const aggressive = Math.min(recommended * 2, 15.0);
+        return toResult({
+            steps,
+            recommendation: {
+                recommendedSlippagePercent: recommended.toFixed(1),
+                reason: [
+                    `波动率 CV=${(volatility * 100).toFixed(1)}% → 基础滑点 ${baseSlippage}%`,
+                    impactAdjust > 0 ? `价格影响 ${priceImpact.toFixed(1)}% → 额外 +${impactAdjust}%` : "",
+                ].filter(Boolean).join("; "),
+                factorsConsidered: {
+                    volatilityPercent: +(volatility * 100).toFixed(2),
+                    priceImpactPercent: priceImpact,
+                    baseSlippagePercent: baseSlippage,
+                    impactAdjustmentPercent: impactAdjust,
+                },
+                range: {
+                    conservativePercent: conservative.toFixed(1),
+                    recommendedPercent: recommended.toFixed(1),
+                    aggressivePercent: aggressive.toFixed(1),
+                },
+            },
+        }, {
+            warnings: warnings.length ? warnings : undefined,
+            nextSteps: [
+                { action: "用推荐滑点构建交易", tool: "onchainos_skill_trade_pipeline", params: { chainIndex, fromTokenAddress, toTokenAddress, slippagePercent: recommended.toFixed(1) } },
+                { action: "或手动构建", tool: "onchainos_dex_swap", params: { chainIndex, fromTokenAddress, toTokenAddress, slippagePercent: recommended.toFixed(1) } },
+            ],
+        });
+    });
+    // ── 4. 信号聚合 ────────────────────────────────────────
+    server.tool("onchainos_skill_signal_aggregate", "CAT:[链上-信号] | ## 功能: 获取买入信号+风险过滤, 自动剔除貔貅/高风险代币, 返回带安全评级的精选信号\n## 场景: 跟踪聪明钱/KOL/鲸鱼动态, 一站式发现+过滤\n## 关键词: signal, 信号, 聪明钱, 聚合, 过滤, 风险, KOL, 鲸鱼\n## 参数:\n##   - chainIndex(必填)\n##   - walletType: 钱包类型过滤(可选)\n##   - minAmountUsd/maxAmountUsd: 金额筛选(可选)\n##   - limit: 返回条数(可选,默认10,最大20)\n## 鉴权: 需要 API Key(只读)\n## 风险: READ - 只读查询\n## 返回量: 中等 ~30KB\n## 关联: 本工具 → onchainos_skill_risk_detect(深入分析) → onchainos_skill_trade_pipeline(交易)", {
+        chainIndex: z.string().describe("链索引。如 '1'=ETH '501'=Solana。从 onchainos_signal_supported_chain 获取"),
+        walletType: z.string().optional().describe("钱包类型: '1'=聪明钱 '2'=KOL '3'=鲸鱼, 逗号分隔。不传不过滤"),
+        minAmountUsd: z.string().optional().describe("最小交易金额(USD)。如 '1000'=只返回>$1000的信号"),
+        maxAmountUsd: z.string().optional().describe("最大交易金额(USD)"),
+        limit: z.string().optional().default("10").describe("返回信号条数, 默认10, 最大20"),
+    }, { readOnlyHint: true }, async ({ chainIndex, walletType, minAmountUsd, maxAmountUsd, limit }) => {
+        if (!auth)
+            return AUTH_REQUIRED("READ");
+        const steps = [];
+        const limitNum = Math.min(parseInt(limit ?? "10", 10) || 10, 20);
+        // Step 1: 获取原始信号
+        let signals = [];
+        try {
+            const body = { chainIndex };
+            if (walletType)
+                body.walletType = walletType;
+            if (minAmountUsd)
+                body.minAmountUsd = minAmountUsd;
+            if (maxAmountUsd)
+                body.maxAmountUsd = maxAmountUsd;
+            body.limit = Math.min(limitNum * 3, 60); // 过度获取以便过滤后有足够数据
+            const raw = await marketApi.signalList(auth, body);
+            signals = (Array.isArray(raw) ? raw : raw?.dataList ?? raw?.signals ?? []);
+            steps.push({ step: "signal_list", status: "ok", data: { totalSignals: signals.length } });
+        }
+        catch (e) {
+            steps.push({ step: "signal_list", status: "error", error: e instanceof Error ? e.message : String(e) });
+            return toResult({ steps, signals: [], summary: { status: "failed", reason: "信号获取失败" } });
+        }
+        if (signals.length === 0) {
+            return toResult({ steps, signals: [], summary: { status: "empty", message: "当前无匹配信号" } });
+        }
+        // Step 2: 去重 token 地址
+        const tokenMap = new Map();
+        for (const sig of signals) {
+            const ci = sig.chainIndex ?? chainIndex;
+            const addr = sig.tokenContractAddress ?? sig.tokenAddress;
+            if (!addr)
+                continue;
+            const key = `${ci}:${addr}`;
+            if (!tokenMap.has(key))
+                tokenMap.set(key, { chainIndex: String(ci), tokenContractAddress: String(addr) });
+        }
+        const tokensToCheck = Array.from(tokenMap.values()).slice(0, limitNum);
+        const riskCache = {};
+        const chunkSize = 5;
+        for (let i = 0; i < tokensToCheck.length; i += chunkSize) {
+            const chunk = tokensToCheck.slice(i, i + chunkSize);
+            const chunkResults = await Promise.allSettled(chunk.map(async (t) => {
+                const info = await marketApi.tokenAdvancedInfo(auth, t.chainIndex, t.tokenContractAddress);
+                const key = `${t.chainIndex}:${t.tokenContractAddress}`;
+                return { key, info };
+            }));
+            for (const r of chunkResults) {
+                if (r.status === "fulfilled") {
+                    riskCache[r.value.key] = r.value.info;
+                }
+            }
+        }
+        steps.push({ step: "risk_filter", status: "ok", data: { tokensChecked: tokensToCheck.length, riskDataAvailable: Object.keys(riskCache).length } });
+        // Step 4: 过滤 + 排序
+        const enriched = signals
+            .map(sig => {
+            const ci = sig.chainIndex ?? chainIndex;
+            const addr = sig.tokenContractAddress ?? sig.tokenAddress ?? "";
+            const key = `${ci}:${addr}`;
+            const risk = riskCache[key];
+            // 过滤明显风险
+            if (risk) {
+                const isHoney = risk.isHoneypot || risk.isHoneyPot;
+                const rl = (risk.riskLevel ?? "").toUpperCase();
+                if (isHoney || rl === "HIGH" || rl === "CRITICAL")
+                    return null;
+            }
+            return {
+                chainIndex: String(ci),
+                tokenContractAddress: String(addr),
+                tokenSymbol: sig.tokenSymbol ?? sig.symbol,
+                walletAddress: sig.walletAddress ?? sig.address,
+                walletType: sig.walletType ?? walletType,
+                amountUsd: sig.amountUsd ?? sig.amountUSD,
+                timestamp: sig.timestamp ?? sig.ts,
+                riskContext: risk
+                    ? { riskLevel: risk.riskLevel, isHoneypot: risk.isHoneypot || risk.isHoneyPot, buyTax: risk.buyTax, sellTax: risk.sellTax }
+                    : { warning: "风险数据未获取" },
+            };
+        })
+            .filter(Boolean)
+            .slice(0, limitNum);
+        return toResult({
+            steps,
+            signals: enriched,
+            summary: {
+                status: enriched.length > 0 ? "ready" : "filtered_empty",
+                totalRaw: signals.length,
+                afterFilter: enriched.length,
+                riskFiltered: signals.length - enriched.length,
+            },
+        }, {
+            nextSteps: enriched.length > 0
+                ? [{ action: "深入分析特定代币", tool: "onchainos_skill_risk_detect", params: { chainIndex: enriched[0]?.chainIndex, tokenContractAddress: "{{选中代币地址}}" } }]
+                : [{ action: "无安全信号, 放宽条件或检查其他链", tool: "onchainos_signal_list" }],
+        });
+    });
+}
+//# sourceMappingURL=skills.js.map

package/dist/tools/trade.d.ts

@@ -0,0 +1,4 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { Auth } from "../adapters/shared.js";
+export declare function registerTradeTools(server: McpServer, auth: Auth | null): void;
+//# sourceMappingURL=trade.d.ts.map