[{"_1":2,"_3":-5,"_4":-5},"loaderData",{"_5":6,"_7":8},"actionData","errors","root",{"_11":12,"_13":14,"_15":16,"_17":18,"_19":20,"_21":22,"_23":-7,"_24":25,"_26":27},"routes/app/user-guide.$",{"_9":10},"userGuide","[{\"_src_hash\": \"153be5e8a66f628c4e7a5d9bf4e85e1d9941a1ee227b692f46a1d6821a018d9f\", \"children\": [{\"_src_hash\": \"04b53efddeb02316817ec82198c8f3e4d088c8503db1891b37ed0fec619a8c59\", \"children\": [], \"desc\": \"发明者量化交易平台（FMZ量化）是一个量化交易平台：在网页上编写策略、在线回测，然后在自己部署或租用的托管者上运行实盘；也可以在策略广场学习、分享、出租策略，或公开展示自己的实盘。\\n\\n### 支持的市场\\n- 加密货币：主流中心化交易所的现货、期货与永续合约，以及部分链上交易所。\\n- 证券与期货：富途证券、盈透证券（Interactive Brokers）等。\\n- 平台尚未对接的交易所，可以通过{@平台基础/交易所/通用协议通用协议}自行接入。\\n\\n### 支持的策略语言\\nJavaScript、Python、Rust、PINE、My语言（麦语言）和Workflow工作流，见{@编写策略/编程语言编程语言}。\\n\\n### AI 辅助\\n- 策略编辑器内置{@开发工具/策略编辑器/AI助手 AI助手}，可以生成、解释、修改策略代码并分析回测结果。\\n- 也可以把自己使用的外部 AI 助手接入平台，通过对话管理策略、回测和实盘，见{@扩展API接口/AI接入 AI接入}。\\n\\n### 控制台\\n注册并登录后进入[控制台](https://www.fmz.com/m)：\\n\\n![控制中心概览](/upload/asset/2e4e636a6fe51c8f620e8.png)\\n\\n- [控制中心](https://www.fmz.com/m/dashboard)：账户概况和常用功能入口。运行一个实盘需要三样东西：一个在线的托管者、一个策略、一个配置好的交易所账户。\\n- [实盘](https://www.fmz.com/m/robots)：创建、管理、控制实盘。实盘即运行中的策略程序实例。\\n- [策略库](https://www.fmz.com/m/strategies)：编写、保存、分组管理各种语言的策略。\\n- [托管者](https://www.fmz.com/m/nodes)：部署和管理运行策略的托管者程序。\\n- [交易所](https://www.fmz.com/m/platforms)：添加和管理交易所账户。\\n\\n### 平台公共资源\\n- [策略广场](https://www.fmz.com/square)：公开分享或上架出租的策略，适合学习和参考。\\n- [实盘围观](https://www.fmz.com/live)：用户公开展示的实盘。\\n- [文库](https://www.fmz.com/digest)：平台原创文章。\\n- [社区](https://www.fmz.com/bbs)：交流、讨论量化交易的论坛。\\n- [众包](https://www.fmz.com/markets)：发布和承接策略开发需求。\\n- [公开课](https://www.fmz.com/class)：视频教程。\\n- [API文档](https://www.fmz.com/api)：策略编写的API语法手册。\\n\\n### 获取帮助\\n遇到问题可以在社区发帖、在控制台提交工单，或在[Telegram](https://t.me/fmzquant_cn)社群联系管理员。\", \"title\": \"欢迎使用发明者量化交易平台\"}, {\"_src_hash\": \"0de696d347b4c79dd1664212e7aab77d9c1a09092e43365e5e8337659283dfc6\", \"desc\": [\"从注册到运行第一个实盘，按下面六步完成，每一步后面链接了详细说明。\\n\\n### 1. 注册账号\\n\\n在[注册页面](https://www.fmz.com/sign-up)注册并登录。添加交易所时要输入账号密码（交易所密钥在浏览器端用它加密），用第三方账号登录、还没有设置密码的用户会被要求先设置密码，见{@入门/密钥安全性密钥安全性}。\\n\\n### 2. 添加交易所账户\\n\\n在交易所官网创建API KEY（只开启读取和交易权限，不要开启提现），然后在[交易所页面](https://www.fmz.com/m/platforms)点击「添加交易所」，选择交易所并填写密钥。第一次使用建议先用交易所的模拟盘或小额子账号。步骤与各配置项见{@平台基础/交易所交易所}。\\n\\n### 3. 部署托管者\\n\\n托管者是运行策略的程序，实盘都运行在托管者上。可以{@平台基础/托管者/部署托管者/一键租用托管者一键租用托管者}，也可以{@平台基础/托管者/部署托管者/手动部署托管者手动部署托管者}到自己的服务器上。\\n\\n### 4. 编写策略\\n\\n在[新建策略页面](https://www.fmz.com/m/add-strategy)选择编程语言，把下面的最小策略粘贴进去保存。它每5秒读取一次行情和账户，显示在状态栏，不会下单。策略由入口函数```main()```和其中的主循环构成，见{@编写策略/策略结构策略结构}；全部函数见{@编写策略/API函数速查 API函数速查}；编辑器的用法见{@开发工具/策略编辑器策略编辑器}。也可以从策略广场复制一个公开策略开始。\\n\\n### 5. 回测\\n\\n在策略编辑页面的回测面板中选择交易所、交易对、时间范围和K线周期后开始回测，检查收益曲线、交易记录和日志。回测通过后再上实盘，见{@回测系统/概述与发起回测概述与发起回测}。\\n\\n### 6. 创建实盘\\n\\n在[实盘创建页面](https://www.fmz.com/m/add-robot)选择策略、托管者和交易所账户，设置策略参数后启动。实盘按小时计费，启动前账户里需要有余额，见{@平台基础/账号与计费/实盘计费与充值实盘计费与充值}。运行状态、日志和收益在实盘页面查看，见{@平台基础/实盘实盘}。\\n\\n之后可以按需阅读：「开发工具」介绍编辑与调试，「进阶专题」介绍限流、实盘间通信、多线程和链上交易，「扩展API接口」介绍用程序或AI助手操作平台。\"], \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n Log(\\\"交易所:\\\", exchange.GetName(), \\\"交易对:\\\", exchange.GetCurrency())\\n while (true) {\\n var ticker = exchange.GetTicker()\\n var account = exchange.GetAccount()\\n if (ticker && account) {\\n LogStatus(_D(), \\\"最新价:\\\", ticker.Last,\\n \\\"可用计价币:\\\", account.Balance, \\\"可用币数:\\\", account.Stocks)\\n }\\n Sleep(5000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n Log(\\\"交易所:\\\", exchange.GetName(), \\\"交易对:\\\", exchange.GetCurrency())\\n while True:\\n ticker = exchange.GetTicker()\\n account = exchange.GetAccount()\\n if ticker and account:\\n LogStatus(_D(), \\\"最新价:\\\", ticker[\\\"Last\\\"],\\n \\\"可用计价币:\\\", account[\\\"Balance\\\"], \\\"可用币数:\\\", account[\\\"Stocks\\\"])\\n Sleep(5000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n Log!(\\\"交易所:\\\", exchange.GetName(), \\\"交易对:\\\", exchange.GetCurrency());\\n loop {\\n if let (Ok(ticker), Ok(account)) = (exchange.GetTicker(None), exchange.GetAccount()) {\\n LogStatus!(_D(None), \\\"最新价:\\\", ticker.Last,\\n \\\"可用计价币:\\\", account.Balance, \\\"可用币数:\\\", account.Stocks);\\n }\\n Sleep(5000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"最小可运行策略：每5秒在状态栏显示行情和账户，不下单，回测和实盘都可以直接运行。\"}], \"title\": \"快速开始\"}, {\"_src_hash\": \"5e3a72aa3b5ee40f6060250a958f6d54eee2388f7e88ddde0a82669ea15e5e2f\", \"children\": [], \"desc\": \"配置交易所账户前，按下面的清单检查密钥的安全设置；交易所密钥一旦泄露，损失的是交易所账户里的资产。\\n\\n- **只开交易权限**：API KEY只开启读取和交易权限，**不要开启提现**。\\n- **绑定 IP 白名单**：在交易所把API KEY绑定到托管者所在服务器的出口IP。服务器有多个IP时，用托管者的```-I```参数固定出口IP，见{@平台基础/托管者/命令行参数命令行参数}。\\n- **私钥留在本地**：交易所支持RSA等非对称密钥时优先使用；私钥以凭据文件的形式放在托管者所在的机器上，平台只保存文件路径，见{@平台基础/交易所/本地凭据文件本地凭据文件}。\\n- **先小额试运行**：第一次运行新策略时使用交易所的模拟盘或小额子账号。\\n- **不公开敏感信息**：策略代码、参数、描述里如果写了密钥、账号等信息，不要公开或出售该策略。\\n\\n平台如何保存密钥：在交易所配置页面填写的密钥等加密字段，在浏览器端用平台账号密码加密后才上传，平台不保存明文；只有用账号密码启动的托管者能在本地解密。因此修改平台账号密码后，原有的交易所配置会失效，处理方法见{@平台基础/实盘/实盘报错、异常退出的常见原因实盘报错、异常退出的常见原因}。\", \"title\": \"密钥安全性\"}], \"desc\": \"第一次使用先读这里：认识平台，按六个步骤从注册走到运行第一个实盘，并做好交易所密钥的安全设置。\", \"title\": \"入门\"}, {\"_src_hash\": \"22528ed19396439a6153dbdc174062ed040052037070a9972cf1188817042f8c\", \"children\": [{\"_src_hash\": \"2acf4d88c1f9536834131fc40d9534e45fe96ed000c1747176697342ba6f4b3a\", \"children\": [{\"_src_hash\": \"bd9f8c437a44e8477cc91e9ea4a4018e65eed5d153702960ba0d8af2c850486f\", \"children\": [], \"desc\": \"各交易所的配置、合约代码、专属指令与注意事项已移到语法手册「交易所」章节。所有交易所的函数与交易模式指令支持情况见{@exchanges/capabilities 能力矩阵}；各交易所页按分组列在{@exchanges/cex 中心化交易所}、{@exchanges/dex 去中心化交易所}、{@exchanges/prediction 预测市场}、{@exchanges/broker 证券与期货}、{@exchanges/custom 链上与自定义接入}。\", \"title\": \"交易所特殊说明\"}, {\"_src_hash\": \"750bacf5c6f03fa0f5f42601466b4346d1b18fab384c46247bea79455ac8ddab\", \"desc\": \"配置交易所时，所有带掩码的加密输入框（Secret Key、私钥、密码等）都可以不填写内容本身，而填写一个凭据文件路径```file:///文件名.txt```。实盘运行时，托管者从本机读取该文件的内容作为这一项的值。这样私钥只存在于托管者所在的机器上，平台上保存的只是一个路径。\\n\\n### 路径规则\\n- 路径相对于**本实盘的目录**```logs/storage/<实盘ID>/```解析（```logs```位于托管者的工作目录下）。例如实盘ID为```123456```时，```file:///rsaKey.txt```对应```logs/storage/123456/rsaKey.txt```。\\n- 可以有子目录，例如```file:///keys/rsaKey.txt```。\\n- 只认```.txt```后缀；其它后缀不会当作文件读取，而是把这串文字原样作为配置值。\\n- 路径不能是绝对路径，不能包含```..```，解析后也不能跳出实盘目录（指向目录外的符号链接同样不行）。\\n- 凭据文件按实盘目录读取，多个实盘使用同一个交易所配置时，每个实盘的目录里都要放一份。\\n- 文件读不到时实盘启动失败：文件不存在时报错中包含```resolve key file```，文件存在但无法读取时包含```read key file```；路径不合法时报错为```key file path must be relative and cannot contain '..'```或```key file path escapes the robot directory```。\\n\\n### 示例：使用 RSA 密钥\\n以支持```RSA KEY```验证的交易所为例：\\n1. 生成RSA公钥和私钥，例如用```openssl```生成PKCS#8格式的密钥对。\\n2. 在交易所创建```RSA KEY```，上传第1步生成的公钥。\\n3. 在平台配置交易所：```Access Key```填写交易所创建的```RSA KEY```，```Secret Key```填写```file:///rsaKey.txt```。\\n4. 创建实盘，得到实盘ID（例如```123456```）。\\n5. 把第1步生成的私钥保存为```logs/storage/123456/rsaKey.txt```，然后启动（或重启）实盘。\\n\\n详细过程可以参考[视频讲解](https://www.bilibili.com/video/BV1UM41147Jj/)。\", \"title\": \"本地凭据文件\"}, {\"_src_hash\": \"1bec8ca6b3648bdb350bda7fca766f7ec7c11f295cca366da17d2b9ddf4b2139\", \"children\": [], \"desc\": \"平台尚未对接的交易所，可以通过编写通用协议插件程序接入：插件程序一端调用交易所的API，另一端按统一的格式与托管者交互。\\n\\n![通用协议配置截图](/upload/asset/2e43b059b3ec9f42ded6e.png)\\n\\n任何提供API交易接口的交易所都可以这样接入，插件支持两种协议：\\n- ```REST```协议：[参考文档](https://www.fmz.com/digest-topic/10518)。\\n- ```FIX```协议：[参考项目](https://github.com/fmzquant/fixc)。\\n\\n两种插件的区别只在于与交易所接口的交互方式；与托管者的交互方式、数据格式等完全相同，具体实现见以上链接中的示例。\", \"title\": \"通用协议\"}], \"desc\": \"[交易所](https://www.fmz.com/m/platforms)页面管理已配置的交易所账户。在发明者量化交易平台中，「交易所」指一个可供策略程序操作的账户：它包含资金账户的密钥配置，以及与该交易所通信的协议和接口封装。\\n\\n### 添加交易所账户\\n\\n1. **在交易所创建 API 密钥**：只开启读取和交易权限，不要开启提现；交易所支持 IP 白名单时，绑定运行实盘的托管者的出口 IP（检查清单见{@入门/密钥安全性密钥安全性}）。\\n2. **打开添加页面**：在交易所页面点击「添加交易所」，进入[交易所添加页面](https://www.fmz.com/m/add-platform)。\\n3. **选择协议**：按分类选择交易所，或在搜索框输入交易所名称、ID 搜索。现货和期货（合约）是两个不同的交易所对象，需要分别添加，期货交易所带「合约」标记；例如币安现货是```Binance```，币安期货是```Futures_Binance```。\\n4. **填写配置**：「标签」是这个账户在平台上的名称，默认是交易所名，同一交易所有多个账户时用它区分；其余配置项因交易所而异，常见的见下表，每个交易所的完整配置项见语法手册的交易所页（所有交易所见{@exchanges/capabilities 能力矩阵}）。没有标「选填」的都要填写。\\n5. **确认添加**：点击「确认添加」并输入平台账号密码。密钥等加密字段在浏览器端用账号密码加密后才上传，平台不保存明文。\\n6. **使用**：创建实盘或回测时选择这个交易所账户。使用平台公用托管者时，添加页面下方会列出这些托管者的 IP，需要加入交易所的 IP 白名单。\\n\\n### 常见配置项\\n\\n| 配置项 | 说明 |\\n| - | - |\\n| Access Key、Secret Key | 交易所的 API Key 和密钥。Secret Key 是加密字段 |\\n| Passphrase | 创建 API Key 时设置的口令，部分交易所需要（见下方说明） |\\n| 模拟盘 | 勾选后连接交易所的模拟盘（测试网），通常要在交易所单独创建 API Key |\\n| Version、V5协议、V3协议 | 交易所 API 版本，多数交易所保持默认即可 |\\n| 钱包地址、私钥类 | 链上交易所签名用的钱包地址、钱包私钥或交易所生成的 API 私钥 |\\n| Rpc Address、Chain、ChainType | 链上兑换和 Web3 交易所对象的节点地址和链，见{@进阶专题/Web3 Web3} |\\n| 服务器地址、交易密码 | 富途、盈透等证券期货账户，见语法手册{@exchanges/broker 证券与期货}中的交易所页 |\\n\\n- Passphrase：```OKEX```（OKX）、```Futures_OKCoin```（OKX 期货）、Bitget、DeepCoin、```Futures_KuCoin```、```WEEX```、```Futures_WEEX```等需要；```KuCoin```现货的这一项显示为 Password。\\n- 模拟盘：币安、OKX、Bybit、Gate、DigiFinex 的部分交易所对象支持。\\n- API 版本：个别交易所的版本对应不同的账户类型，例如 Bitget 的 v3 为统一账户、v2 为经典账户，见交易所页。\\n- 钱包地址、私钥类：用于 Hyperliquid、Lighter、EdgeX、Aster、Polymarket 等链上交易所，具体字段见语法手册{@exchanges/dex 去中心化交易所}、{@exchanges/prediction 预测市场}中的交易所页。\\n\\n所有带掩码的加密输入框都可以改填一个凭据文件路径，让私钥只保存在托管者所在的机器上，见{@平台基础/交易所/本地凭据文件本地凭据文件}。\\n\\n### 交易所对象\\n配置好的交易所在策略代码中就是交易所对象{@var/EXCHANGE/exchange exchange}。配置回测或实盘时可以添加多个交易所，在代码中对应交易所对象数组{@var/EXCHANGE/exchanges exchanges}。```exchange.GetName()```返回交易所对象的名称（如```Futures_Binance```），文档中提到具体交易所时都用这个名称，必要时括注常用名。\\n\\n在策略代码中通过交易所对象读取账户和行情、下单、撤单，以```JavaScript```为例：\\n\\n```javascript\\nfunction main() {\\n let account = exchange.GetAccount() // 查询账户信息\\n let ticker = exchange.GetTicker() // 获取ticker行情\\n let id = exchange.Buy(1000, 1) // 价格为1000，下单量为1\\n if (id) {\\n exchange.CancelOrder(id) // 下单成功才有订单Id，订单未成交时可以撤单\\n }\\n}\\n```\", \"title\": \"交易所\"}, {\"_src_hash\": \"38f9d729a5a12e93ae06905b5701d16ed404f9758e4894d4278b0baeafb837fa\", \"children\": [{\"_src_hash\": \"e9dc69ab98373332a1f5a611fb82db2e80aa5628cd9466d1ea8029ef8d1872f5\", \"children\": [{\"_src_hash\": \"b6a0091af4ebe5f11238f152d67e7511d51865f8543f96cedc66794c57c69164\", \"desc\": \"由平台代为租用一台服务器并自动部署托管者，不需要自己准备服务器，几分钟后托管者即可上线。\\n\\n### 步骤\\n1. 在[托管者部署页面](https://www.fmz.com/m/add-node)点击**一键租用托管者**标签，按配置、服务器机房地区等需求选择服务器。\\n2. 点击「立即购买」，输入发明者量化交易平台的账号密码验证。\\n3. 验证通过后自动部署托管者程序并安装常用的Python库，整个过程需要几分钟。\\n\\n### 注意事项\\n- 服务器由平台代为租用，只有有限的系统权限，不支持远程登录。需要使用没有预装的第三方Python库时，建议用自己的服务器{@平台基础/托管者/部署托管者/手动部署托管者手动部署托管者}。\\n- 租用的服务器单独计费，与实盘计费无关。\\n- 点击「重新部署」不会删除托管者目录下```logs```目录中的实盘日志和数据文件。\", \"title\": \"一键租用托管者\"}, {\"_src_hash\": \"856b5a72a040bf213f22840eab1a6706fb6e57ec4bf13a45cb6f1ecceb1d3d54\", \"desc\": \"可以把托管者部署在个人电脑、服务器、树莓派（64位系统）等设备上。托管者只发布64位版本：\\n- Linux命令行版：x86_64（amd64）、ARM64（aarch64）\\n- macOS命令行版：Intel、Apple Silicon\\n- Windows：x64、ARM64，各有命令行版和界面版\\n\\n在[托管者部署页面](https://www.fmz.com/m/add-node)点击**手动部署托管者**，按系统下载对应的托管者程序并解压，可执行文件```robot```即托管者程序。同一页面还显示部署需要的两项信息：\\n\\n![手动部署托管者页面](/upload/asset/2e460507bc21582ba1448.png)\\n\\n1. 通信地址：包含账号UID，形如```node.fmz.com/123456```。\\n2. 密码：UID对应的发明者量化交易平台账号的密码。\\n\\n### Windows界面版\\n运行```robot.exe```，在界面上填写通信地址和密码，点击启动。\\n\\n### 命令行版\\n```bash\\nchmod +x robot # Linux/macOS 首次运行前加上执行权限\\n./robot -s node.fmz.com/123456 # 启动后提示输入密码，输入时不回显\\n```\\n\\n```123456```只是示例，实际的通信地址在托管者部署页面查看。不要用```-p```在命令行里写明文密码，它会留在shell历史和进程列表里；需要无人值守启动时，把地址和密码写进只有自己可读的配置文件```robot.conf```：\\n\\n```bash\\ncat > robot.conf <<'EOF'\\ns=node.fmz.com/123456\\np=你的密码\\nEOF\\nchmod 600 robot.conf\\n./robot -c robot.conf # 启动目录下有robot.conf时，直接 ./robot 也会自动加载\\n```\\n\\n全部参数和配置文件格式见{@平台基础/托管者/命令行参数命令行参数}。\\n\\n### 在后台运行\\n托管者忽略终端挂断信号：在SSH里前台启动后直接断开连接，托管者会继续运行，运行日志同时写在```logs/docker.log```。需要开机自启或崩溃后自动拉起时，可以用systemd等服务管理器运行，例如```/etc/systemd/system/robot.service```：\\n\\n```ini\\n[Unit]\\nDescription=FMZ robot\\nAfter=network-online.target\\nWants=network-online.target\\n\\n[Service]\\nWorkingDirectory=/opt/robot\\nExecStart=/opt/robot/robot -c /opt/robot/robot.conf\\nRestart=on-failure\\nTimeoutStopSec=90\\n\\n[Install]\\nWantedBy=multi-user.target\\n```\\n\\n```bash\\nsudo systemctl daemon-reload\\nsudo systemctl enable --now robot\\n```\\n\\n```systemctl stop robot```发送的```SIGTERM```会让托管者优雅退出：先停止其上的所有实盘、上报状态，再从平台下线。```TimeoutStopSec```留出足够的时间，避免收尾未完成就被强制结束。\\n\\n### 升级托管者\\n策略运行时和交易所连接器由平台按需下发，不需要手动更新。升级托管者程序本身：先停止托管者（见{@平台基础/托管者/部署托管者/托管者操作注意事项托管者操作注意事项}），用新版本替换```robot```可执行文件，再在**同一工作目录**启动。工作目录下的```logs```目录保留了托管者身份和实盘数据，启动后沿用原来的托管者ID。\\n\\n### 用Docker容器隔离策略进程\\nLinux和macOS的命令行版可以用```-i```参数让每个策略进程运行在独立的Docker容器里（需要本机已安装并运行Docker）。这是策略进程的隔离方式，不是托管者本身的Docker镜像，参数见{@平台基础/托管者/命令行参数命令行参数}。\", \"title\": \"手动部署托管者\"}, {\"_src_hash\": \"dbb019d91024425d886853cbb6e62480dcc03944009f109b13b7ccc105f5ece8\", \"desc\": \"停止或删除托管者时要注意的事项：先停实盘，用正常的方式停止，避免强制结束进程。\\n\\n### 先停实盘，再停托管者\\n删除托管者或停止托管者进程前，先确认它上面没有运行中的实盘。\\n\\n### 正常停止托管者\\n- 命令行版：在终端按一次```Ctrl+C```，或向进程发送```SIGTERM```（```kill ```、```systemctl stop```）。\\n- Windows界面版：点击界面上的停止按钮。\\n\\n托管者收到停止指令后会优雅退出：先停止其上的所有实盘、上报最终状态，再从平台下线。收尾期间再按一次```Ctrl+C```会跳过状态上报和下线，直接退出，一般不要这样做。\\n\\n### 避免强制结束\\n不要用```kill -9```结束托管者进程，也不要直接断电或强制关机。这样托管者来不及下线，平台上的实盘可能仍显示为运行中并继续计费；出现这种情况，需要先删除已离线的托管者，才能停止这些实盘。重启服务器前先停止托管者；用systemd等服务管理器运行时，系统关机会自动发送```SIGTERM```。\", \"title\": \"托管者操作注意事项\"}], \"desc\": \"可以在平台一键租用服务器，或在自己的设备上手动部署。在[托管者管理页面](https://www.fmz.com/m/nodes)点击**部署托管者**进入[托管者部署页面](https://www.fmz.com/m/add-node)选择方式。\\n\\n托管者管理页面列出当前账号下的托管者，可以切换列表或详细信息展示，查看托管者的IP地址、版本、编译时间等信息。\\n\\n![托管者部署页面](/upload/asset/2e527e497b3fa27ba497b.png)\", \"title\": \"部署托管者\"}, {\"_src_hash\": \"bd8c6384b3c65009ae3509d40767c2a933c4e36326c84040f0e34fbf65b3fdec\", \"desc\": \"命令行版托管者程序```robot```的启动参数和配置文件```robot.conf```的写法。常用的启动方式：\\n\\n```bash\\n./robot -s node.fmz.com/123456 # 启动后交互输入密码（不回显）\\n./robot node.fmz.com/123456 # 简写：robot 地址 [密码]\\n./robot -c robot.conf # 从配置文件读取参数\\n./robot -v # 查看版本\\n```\\n\\n通信地址和账号UID在[托管者部署页面](https://www.fmz.com/m/add-node)查看。\\n\\n### 参数\\n\\n| 参数 | 说明 |\\n| --- | --- |\\n| ```-s 地址``` | 与平台通信的地址，形如```node.fmz.com/123456```（```123456```为账号UID），可带```ws://```或```wss://```前缀。 |\\n| ```-p 密码``` | 账号密码。不建议使用：明文密码会留在shell历史和进程列表中。不给时启动后交互输入，或写在配置文件里。 |\\n| ```-n 名称``` | 托管者名称，显示在平台的托管者页面上。 |\\n| ```-w 目录``` | 工作目录。```logs```（实盘数据、托管者日志、身份文件）都在这个目录下。 |\\n| ```-c 文件``` | 配置文件，格式见下文。 |\\n| ```-u 用户``` | 仅Linux/macOS：以该系统用户运行策略进程，托管者本身需要以root运行。使用```-i```时忽略。 |\\n| ```-I IP``` | 指定本机出口IP，托管者与平台的连接以及策略访问交易所的连接都绑定这个地址，见下文。 |\\n| ```-i 镜像``` | 仅Linux/macOS：用该Docker镜像为每个策略进程创建独立容器运行，需要本机已安装并运行Docker。 |\\n| ```-e 路径``` | 配合```-i```：容器内的可执行文件路径。 |\\n| ```-f JSON``` | 配合```-i```：Docker容器设置，可以直接写JSON，也可以写```@文件路径```从文件读取。 |\\n| ```-H 地址``` | 配合```-i```：容器回连宿主机的地址。 |\\n| ```-vv``` | 输出详细日志（托管者与平台的交互消息等），默认不输出，以免日志膨胀。 |\\n| ```-d DNS``` | 旧版的自定义DNS参数，仍可接受但会被忽略，托管者一律使用系统的DNS解析。 |\\n| ```-v```、```-V```、```--version``` | 打印版本和编译信息后退出。 |\\n| ```-h```、```--help``` | 打印用法。 |\\n| ```--ctl-stdin``` | 从标准输入读取控制指令（没有```-p```时第一行为密码），收到```stop```或输入结束时优雅退出。供把托管者封装成服务的程序使用。 |\\n\\n取值型参数也可以写成```-参数=值```，例如```-n=server01```。参数写错时打印用法并退出。\\n\\n### 配置文件 robot.conf\\n每行一个```键=值```，键是参数名去掉```-```（```s p n w u I d i e f H vv```），```#```开头的行是注释：\\n\\n```ini\\n# robot.conf\\ns=node.fmz.com/123456\\np=你的密码\\nn=server01\\nvv=true\\n```\\n\\n- 用```-c```指定配置文件；没有```-c```也没有给出通信地址时，如果启动目录下有```robot.conf```，会自动加载。\\n- 同一项命令行和配置文件都给了时，以命令行为准。\\n- 键先按原样匹配、匹配不到再按小写匹配，所以只有```I```（出口IP）与```i```（Docker镜像）区分大小写，其余键（如```S=```）大小写均可。\\n- 配置文件路径相对启动目录解析（在```-w```切换目录之前）；```-f @文件```在```-w```切换目录之后读取，相对路径按工作目录解析。\\n- 配置文件里有密码，记得设置只有自己可读（```chmod 600 robot.conf```）。\\n\\n### 指定出口IP（-I）\\n服务器有多个IP地址，而交易所API KEY绑定了其中某个IP的白名单时，用```-I```指定出口IP，例如```./robot -s node.fmz.com/123456 -I 192.168.1.100```。指定后托管者与平台的连接、策略访问交易所的连接都从该地址发出。使用```-i```容器隔离时，容器的网络里可能没有这个地址，此时需要让容器使用宿主机网络。\\n\\nWindows界面版没有IP设置，需要指定出口IP时请使用命令行版。界面版只接受```-s```、```-p```、```-n```三个启动参数，用于预填界面，同时给出```-s```和```-p```时自动启动。\", \"title\": \"命令行参数\"}, {\"_src_hash\": \"8519d18805fd3ef58c099a470fb2a2f9fd1ac3e91c0ac8ddbad10f9eee385571\", \"desc\": \"每个实盘的数据都在托管者工作目录下的```logs/storage/<实盘ID>/```目录里（数据库```<实盘ID>.db3```、```stdout.log```、```stderr.log```等）。平台显示的实盘日志、收益、图表都是从运行该实盘的托管者上读取的。\\n\\n### 把单个实盘迁移到另一台机器的托管者\\n1. 停止该实盘。\\n2. 把整个```logs/storage/<实盘ID>/```目录复制到新托管者工作目录下的相同位置，目录名保持为实盘ID。\\n3. 在实盘配置中把托管者改为新托管者，再启动实盘。\\n\\n这样实盘原有的日志、收益等数据不会因为换了机器而丢失。\\n\\n### 整体迁移托管者\\n1. 停止旧托管者上的实盘，再停止旧托管者。\\n2. 把旧托管者工作目录下的整个```logs```目录复制到新机器的工作目录。\\n3. 在新机器上启动托管者。\\n\\n```logs/docker.pid```保存了托管者的身份，旧托管者已离线时，新机器上的托管者会沿用原来的托管者ID，实盘配置无需修改。不要让两台机器同时使用同一份```logs```目录运行托管者。\", \"title\": \"实盘数据迁移\"}, {\"_src_hash\": \"f8d7dd6da76aee5f41e952a0a970de38fc95bc90b9b34f925e3efffea65534b6\", \"desc\": \"在[托管者管理页面](https://www.fmz.com/m/nodes)，托管者列表或托管者详情的操作项中可以开启**托管者监控**。开启后，托管者异常离线以及恢复在线时，平台会按[推送设置](https://www.fmz.com/m/account#push)发送通知（App、邮箱、Telegram，不发送到WebHook）。\", \"title\": \"托管者监控\"}], \"desc\": \"[托管者](https://www.fmz.com/m/nodes)是运行策略的程序：实盘策略运行在托管者上，而不是运行在发明者量化交易平台网站上。托管者负责与平台通信、启动和停止策略进程、回传日志；策略访问交易所的网络请求也都从托管者所在的机器发出。托管者运行在你自己的服务器（或一键租用的服务器）上，平台网站出现网络故障也不影响托管者上正在运行的实盘。\\n\\n### 支持的系统\\n托管者只发布64位版本：Linux（x86_64、ARM64）、macOS（Intel、Apple Silicon）、Windows（x64、ARM64，另有界面版）。不支持32位系统。\\n\\n### 数据目录\\n托管者的数据都在工作目录（默认为启动目录，可用```-w```指定）下的```logs```目录中：\\n- ```logs/storage/<实盘ID>/<实盘ID>.db3```：实盘数据库（```SQLite```），保存日志、收益、图表、状态栏和```_G()```数据，可以用```SQLite```管理软件打开。\\n- ```logs/storage/<实盘ID>/stdout.log```、```stderr.log```：策略进程的标准输出和标准错误。\\n- ```logs/docker.log```：托管者自身的运行日志。\\n- ```logs/docker.pid```：托管者的身份信息，保留它，重启后平台会沿用原来的托管者ID。\\n\\n如需把实盘目录放到其他磁盘，可在启动托管者前设置环境变量```QUANT_ROBOT_LOG_DIR```，它会替代```logs/storage```作为各实盘目录的上级目录。\\n\\n### 网络代理\\n托管者不读取操作系统的代理设置。托管者进程环境中的```HTTP_PROXY```、```HTTPS_PROXY```、```ALL_PROXY```（及```NO_PROXY```）等环境变量会作用于策略发出的HTTP请求（```HttpQuery```和交易所REST接口），但不作用于WebSocket连接。需要通过代理访问交易所时，推荐：\\n- 在策略中用{@fun/Exchange/exchange.SetProxy exchange.SetProxy}给交易所对象设置代理；\\n- 或使用在网络层接管流量的透明代理（例如 Clash 的 TUN 模式），托管者无需任何配置。\", \"title\": \"托管者\"}, {\"_src_hash\": \"7501db47f0aadcfa10afbb5b38058e5423eafcdf2b44ed326e08cbee23e2e28e\", \"children\": [{\"_src_hash\": \"75549cfd63949cfd3cd6a0c07393e3a2815e3467e06e005437575ecee7e2f83b\", \"children\": [], \"desc\": \"迁移策略不能只复制源码：参数设计、交互设计、模板引用等都不在源码里。在策略编辑页面使用「导出策略」和「导入策略」可以完整地迁移一个策略。\\n\\n![策略导入导出截图](/upload/asset/2e52ccf44526f396fb795.png)\\n\\n- 导出策略\\n 导出为一个```xml```文件，所有编程语言的策略都一样。导出时可以勾选要包含的内容：策略名称、源码、笔记、描述、手册、模板引用、策略参数、交互控件、回测设置。\\n\\n- 导入策略\\n 在策略编辑页面点击「导入策略」，选择用「导出策略」得到的```xml```文件，再勾选要导入的内容。导入后点击「保存」保存策略。\", \"title\": \"完整策略的导入与导出\"}, {\"_src_hash\": \"b5cff52ac6fe2129f40bf35c8597955347fb353ddd4885596618636095e11d2a\", \"children\": [{\"_src_hash\": \"ddd33b64b304b0aecfa39d29b0665864f7653ce736fc4f215f694cbfbedca457\", \"desc\": \"分享策略后，对方得到策略的完整副本（包括源码）。点击策略的「分享」按钮，在弹出的对话框中选择分享方式：\\n\\n- **公开分享**：策略完整地分享到平台的策略广场，任何用户都可以复制。\\n- **内部分享**：选择分享有效期和分享次数后，生成该策略的**复制页面地址**和**复制码**，分发给指定的平台用户。对方打开复制页面地址并登录，输入复制码即可获取该策略，策略随即出现在对方的策略库中。\\n\\n![策略分享](/upload/asset/2e593d57dc36afc004ef6.png)\", \"title\": \"策略分享\"}, {\"_src_hash\": \"901206a25531b3a79395de13c5439daedd5980a75a5a1cdd4c327337880132e7\", \"desc\": \"出租策略后，对方只获得回测和实盘的使用权，看不到策略源码等信息。点击策略的「出租」按钮，在弹出的对话框中选择出租方式：\\n\\n- **公开出售**：申请把策略上架到策略广场出售，需要通过审核。\\n- **内部出售**：选择使用天数、最多并发实盘数和注册码个数后，生成该策略的**注册页面地址**和**注册码**，分发给指定的平台用户。对方打开注册页面地址并登录，输入注册码即可获得使用权，策略随即出现在对方的策略库中。最多并发实盘数设置为0时不限制并发数，可以无限制地创建实盘。\\n\\n![策略出租](/upload/asset/2e4e78f6c46c9dde1ce90.png)\\n\\n租用的策略到期后，使用它的实盘会被停止且不能再启动；达到最多并发实盘数后不能再启动新的实盘。\", \"title\": \"策略出租\"}], \"desc\": \"把自己的策略交给他人使用有两种方式：分享（对方得到策略的完整副本，包括源码）和出租（对方只得到回测、实盘使用权，看不到源码）。在[策略库](https://www.fmz.com/m/strategies)页面点击策略右侧的「操作项」按钮，在弹出的菜单中选择分享或出租。\\n\\n创建、分发**注册码**（出租）时务必确认生成的是「注册码」而不是「复制码」（分享），以免误把策略源码分享出去。\", \"title\": \"策略分享与出租\"}], \"desc\": \"[策略库](https://www.fmz.com/m/strategies)页面保存当前账号下的所有策略，策略可以用多种编程语言或可视化方式编写。\\n\\n- 分组：策略和实盘一样可以分组管理，见{@平台基础/实盘/分组分组}。\\n- 导入与导出：一个完整的策略除了源码，还包括参数、交互、描述、笔记、手册、模板引用等，迁移策略要导出、导入完整策略，见{@平台基础/策略库/完整策略的导入与导出完整策略的导入与导出}。\\n- 分享与出租：生成「复制码」分享策略，生成「注册码」出租策略，见{@平台基础/策略库/策略分享与出租策略分享与出租}。\", \"title\": \"策略库\"}, {\"_src_hash\": \"0c8f175686cff3ef9239baa0812d1504292edf60577b951d30e8a978a5be2e8b\", \"children\": [{\"_src_hash\": \"64b2568f9cfcc2eaa8fe8011af8271a3a47de2c5fbf6854ad10e66aa614de198\", \"children\": [], \"desc\": \"在「实盘」页面和「策略库」页面点击右侧的**分组管理**按钮，可以给实盘、策略分组，分组名称可以自定义。例如给策略分组时，可以把模板类库、JavaScript策略、测试用策略各分一组。\\n\\n策略分组：\\n\\n![策略分组](/upload/asset/2e482ba9b9aa272085d00.png)\\n\\n实盘分组：\\n\\n![实盘分组](/upload/asset/2e577d050e817837bbfdf.png)\", \"title\": \"分组\"}, {\"_src_hash\": \"f453c47edee2899ffd063704478596bee1bbe87268e2feb9b704be6c44ccd468\", \"desc\": \"在[实盘页面](https://www.fmz.com/m/robots)的实盘列表中点击某个实盘的「公开」按钮，可以让他人围观这个实盘。围观有两种方式：\\n\\n1. **公开分享**：实盘展示在平台公开的[实盘围观](https://www.fmz.com/live)页面上。\\n2. **内部分享**：设置有效期后生成一个私有链接，持有链接的人可以打开该实盘的私有围观页面。\", \"title\": \"实盘围观\"}, {\"_src_hash\": \"87f27932c04957b99986730b2139ad5e306d477c28f8810a3460d3c1e82a9c97\", \"children\": [], \"desc\": \"实盘可以把日志作为消息推送到手机App、邮箱、Telegram或WebHook；推送渠道在[推送设置页面](https://www.fmz.com/m/account#push)中开启。\\n\\n![推送设置](/upload/asset/2e4ad17706aa842c914ce.png)\\n\\n### 推送渠道\\n- 移动端（App）：开启后，推送消息发送到发明者量化移动端App。\\n- 邮箱：先验证邮箱，验证通过后即可接收推送消息。\\n- Telegram：在推送设置中绑定Telegram并开启推送。\\n- WebHook：开启并设置推送地址，例如```http://abc.com/push.php?data={body}```，写法见下文。\\n\\n托管者监控、实盘监控、额度预警等告警通知同样按推送设置发送，但不会发送到WebHook。\\n\\n### WebHook地址\\n实盘发出推送消息时，平台向推送地址发送```GET```请求：地址中的```{body}```替换为推送内容，```{subject}```替换为消息标题，两者都经过URL编码；写成```{{body}}```、```{{subject}}```则原样替换，不做编码。\\n\\n需要发送```POST```请求时，把推送地址写成```请求地址||请求体```，例如```http://abc.com/push.php||text={body}```：```||```之前是请求地址，之后是请求体，两部分都可以使用上述占位符。推送地址必须是可从公网访问的```http```或```https```地址。\\n\\n### 在策略中推送\\n- JavaScript、Python、Rust：调用{@fun/Log/Log Log}以及其它会在日志区域输出日志的函数（如```exchange.CreateOrder()```、```exchange.CancelOrder()```）时，在必要参数之后再传一个参数```@```，这条日志就会按推送设置推送，例如```Log(\\\"This is a push message\\\", \\\"@\\\")```；Rust中用```Log!```宏，写法相同：```Log!(\\\"This is a push message\\\", \\\"@\\\");```。\\n- PINE语言、My语言：在策略集成的「交易类库」的参数中开启交易日志推送，触发交易动作后自动推送。\\n\\n### 推送限制\\n推送消息由托管者随心跳（约20秒一次）上报，同一周期内的多条推送合并为一条；每个账号每小时最多推送50条（合并后的一条计为一条），每条正文最长200个字符。回测系统和调试工具不推送消息。完整规则见{@fun/Log/Log Log}。\", \"title\": \"实盘消息推送\"}, {\"_src_hash\": \"0faaf64516366668314213d4c35bac37b32746d7043330e96c854360b790fa5f\", \"children\": [], \"desc\": \"实盘无法启动、运行中报错或异常退出时，按下面的分类排查原因。\\n\\n### 实盘无法启动\\n- 没有在线的托管者\\n 实盘所选的托管者离线时实盘无法启动。在[托管者页面](https://www.fmz.com/m/nodes)确认托管者在线，或换一个在线的托管者。\\n- 账户余额不足\\n 启动实盘需要预付第一个小时的费用，余额不足时无法启动；运行中余额耗尽，实盘会被平台停止。充值后重新启动，见{@平台基础/账号与计费/实盘计费与充值实盘计费与充值}。\\n- 租用的策略到期或并发数已满\\n 租用的策略到期后，使用它的实盘会被停止且无法再启动；达到租用的最多并发实盘数后，无法再启动新的实盘。\\n- 密钥解密失败\\n 报错形如```decrypt connector config (<交易所标签>): field '<字段>': AES decrypt failed (wrong password?)```（少数情况下为```secret key decrypt failed (wrong password)```）。原因是修改了发明者量化交易平台的账号密码，原先配置的交易所密钥无法再解密。处理方法：\\n 1. 在[「交易所」管理页面](https://www.fmz.com/m/platforms)重新填写交易所的密钥、密码等信息。\\n 2. 停止所有托管者，用新密码重新启动托管者。\\n- 凭据文件读不到\\n 交易所配置中使用了```file:///xxx.txt```凭据文件，而实盘目录里没有该文件，报错中包含```resolve key file```（文件存在但无法读取时为```read key file```）；路径不合法时报```key file path must be relative and cannot contain '..'```或```key file path escapes the robot directory```。见{@平台基础/交易所/本地凭据文件本地凭据文件}。\\n\\n### 策略代码导致的错误\\n- 静态语法错误\\n\\n ![编辑器中语法错误](/upload/asset/2e4daebbb80548adf3927.png)\\n\\n 此类错误比较明显，通常在策略编辑页面就能看到错误标记，回测时也能发现。\\n- 运行时错误\\n 最常见的是对函数返回值不做合法性判断就直接使用。\\n- 过度占用内存\\n 在全局变量里保存过多无法被垃圾回收的内容，导致内存占用过大。\\n- 未合理使用```exchange.Go```并发请求\\n 调用异步的```exchange.Go```后没有及时```wait```等待结果，导致并发任务数量过多。\\n- 递归调用过深\\n 递归层数过多，超出调用栈大小。\\n\\n### 其它报错\\n- 接口业务错误、网络请求错误\\n 此类报错会显示相关的交易所对象名称、函数名称、错误消息和原因，本身不会导致实盘异常停止。它们通常是起因而不是直接原因，直接原因一般是**没有判断接口返回值是否合法就直接使用而引发的程序异常**。\\n- ```interrupt```错误\\n 程序正在执行某个操作（例如访问交易所接口）时，用户点击了实盘页面上的**停止**按钮，停止中断了当前操作而打印的日志。它没有影响，只是一条记录。\\n\\n更多问题见[常见问题汇总](https://www.fmz.com/bbs-topic/1427)。\", \"title\": \"实盘报错、异常退出的常见原因\"}], \"desc\": \"「实盘」区别于「回测」，指真正与交易所交互（获取行情、查询持仓、下单撤单等）的策略程序实例。连接交易所生产环境的是实盘，连接交易所模拟环境（很多交易所提供测试环境）的同样是实盘。\\n\\n### 创建实盘\\n在[实盘创建页面](https://www.fmz.com/m/add-robot)选择策略、托管者和交易所账户后创建，需要事先准备好三样东西：\\n- 一个策略：在[策略库](https://www.fmz.com/m/strategies)点击「新建策略」编写并保存。\\n- 一个在线的托管者：在[托管者页面](https://www.fmz.com/m/nodes)点击「部署托管者」，见{@平台基础/托管者托管者}。\\n- 一个交易所账户：在[交易所页面](https://www.fmz.com/m/platforms)点击「添加交易所」配置，见{@平台基础/交易所交易所}。\\n\\n实盘按小时计费，账户余额不足时无法启动，见{@平台基础/账号与计费/实盘计费与充值实盘计费与充值}。\\n\\n### 实盘监控\\n在[实盘管理页面](https://www.fmz.com/m/robots)，运行中的实盘右侧操作栏可以点击「监控」开启实盘监控。开启后，实盘不是因手动操作而退出时，平台会按[推送设置](https://www.fmz.com/m/account#push)发送通知（App、邮箱、Telegram，不发送到WebHook）。\\n\\n### 实盘数据库\\n以实盘ID```123456```为例，它的数据库文件位于所属托管者工作目录下的```logs/storage/123456/123456.db3```（```SQLite```格式），包含以下表：\\n- chart：图表数据。\\n- cfg：状态栏内容、图表配置等最新状态。\\n- kvdb：```_G()```函数持久化保存的数据。\\n- log：实盘日志。\\n- profit：收益数据。\\n\\n同一目录下还有策略进程的标准输出```stdout.log```和标准错误```stderr.log```。\\n\\n让他人查看、操作部分实盘可以使用{@平台基础/账号与计费/子账号子账号}。\", \"title\": \"实盘\"}, {\"_src_hash\": \"7a5b85bf5d5a5f0d94aec2949f2c768dc5071210d137ffb53efa29acf68d0b61\", \"children\": [{\"_src_hash\": \"63f978673659ab284b2be61af83ffd717767737eaca18cc39fdd6a055c6329af\", \"desc\": \"交易插件是一段在托管者上执行的短代码：在交易终端页面点击「执行」时，平台把插件代码和模块选定的交易所账户发送到选定的托管者执行，执行结束后把返回值显示在模块中。下面几个入口使用同一种执行机制：\\n\\n| 入口 | 执行的代码 | 说明 |\\n| - | - | - |\\n| 交易终端插件 | 策略库中类型为「交易插件」的策略 | 在交易终端页面添加、执行 |\\n| 调试工具（开发工具） | 页面中临时编写的JavaScript代码 | 用于测试API调用 |\\n| 扩展API接口{@扩展API接口/扩展API接口详解/PluginRun PluginRun} | 请求中的```source```，或账号中已有的策略 | 供程序调用 |\\n| MCP的```plugin_*```工具 | 平台内置的查询行情、下单等函数 | 供AI助手调用，按```trade```权限授权，见{@扩展API接口/AI接入 AI接入} |\\n\\n这种执行方式不创建实盘、不计费，单次执行最长5分钟，超时中断。适合辅助手动交易的简单任务，例如冰山委托、批量挂单撤单、计算；需要长期运行的逻辑应创建实盘。\\n\\n### 编写\\n\\n在新建策略页面把策略类型设置为「交易插件」即可创建交易插件。交易插件、调试工具和```PluginRun```都只支持JavaScript。\\n\\n插件的入口是```main()```，返回值就是执行结果：返回表格对象、图表对象时，在模块中显示为表格、图表（示例见{@平台基础/交易终端/插件示例插件示例}）。插件中```Log()```输出的日志不会在模块中显示。\\n\\n### 使用\\n\\n- 添加：在交易终端页面打开模块添加菜单，账号策略库中的交易插件会出现在列表中，选择需要的插件添加。\\n- 执行：点击插件模块中的「执行」运行插件。\\n\\n### 数据目录\\n\\n插件和调试工具在托管者上执行时，以托管者运行目录下的```logs/storage/p<数字>/```为工作目录（每个平台账号一个以```p```开头的目录，第一次执行后创建）。如果交易终端使用的交易所账户以密钥文件路径（```file:///xxx.txt```）的方式配置密钥，需要把密钥文件放在这个目录中。\", \"title\": \"插件原理与编写\"}, {\"_src_hash\": \"e0cda512d9fc82bb09d880873933410fce6bfeff10ff1b75c8dd188ee6fab582\", \"desc\": \"插件可以在一段时间内执行代码，完成一些简单的操作，例如冰山委托、挂单、撤单、计算等。插件用```return```返回结果，返回表格、图表对象时直接显示为表格、图表。下面是两个例子，更多范例可以在**策略广场**中查找，例如逐笔小量买入/卖出。\\n\\n### 返回深度快照\\n\\n以表格显示当前盘口前15档：\\n\\n```javascript\\n// 返回深度快照\\nfunction main() {\\n var tbl = {\\n type: 'table',\\n title: '深度快照 @ ' + _D(),\\n cols: ['#', 'Amount', 'Ask', 'Bid', 'Amount'],\\n rows: []\\n }\\n var d = exchange.GetDepth()\\n if (!d) {\\n return '获取深度失败'\\n }\\n var n = Math.min(d.Asks.length, d.Bids.length, 15)\\n for (var i = 0; i < n; i++) {\\n tbl.rows.push([i, d.Asks[i].Amount, d.Asks[i].Price + '#ff0000',\\n d.Bids[i].Price + '#0000ff', d.Bids[i].Amount])\\n }\\n return tbl\\n}\\n```\\n\\n### 画跨期差价\\n\\n期货交易所对象上，取季度合约与当周合约的5分钟K线，画出收盘价差：\\n\\n```javascript\\n// 画跨期差价\\nvar chart = {\\n __isStock: true,\\n title: {text: '差价分析图'},\\n xAxis: {type: 'datetime'},\\n yAxis: {\\n title: {text: '差价'},\\n opposite: false\\n },\\n series: [\\n {name: \\\"diff\\\", data: []}\\n ]\\n}\\n\\nfunction main() {\\n exchange.SetContractType('quarter')\\n var recordsA = exchange.GetRecords(PERIOD_M5)\\n exchange.SetContractType('this_week')\\n var recordsB = exchange.GetRecords(PERIOD_M5)\\n if (!recordsA || !recordsB) {\\n return '获取K线失败'\\n }\\n\\n var n = Math.min(recordsA.length, recordsB.length)\\n for (var i = 0; i < n; i++) {\\n var a = recordsA[recordsA.length - n + i]\\n var b = recordsB[recordsB.length - n + i]\\n chart.series[0].data.push([a.Time, a.Close - b.Close])\\n }\\n return chart\\n}\\n```\", \"title\": \"插件示例\"}], \"desc\": \"平台提供模块化、可定制的[交易终端](https://www.fmz.com/m/trade)页面：可以自由添加行情、交易等各种模块，模块可以拖动、缩放，可以修改模块绑定的交易所、交易对，同一类模块可以添加多个，方便手动交易和半程序化交易。\\n\\n交易终端还支持交易插件：自己编写一段代码作为模块，在选定的托管者上执行，辅助手动交易。\", \"title\": \"交易终端\"}, {\"_src_hash\": \"88d3987d19eb9dcf585de4c3fcae1249e4ed59a119cc6ce1e5419b7360e976c0\", \"children\": [{\"_src_hash\": \"24414933f73cb203f4e328d47f5d8003b65cb4189058d39a54c7e7f8bea13fc3\", \"desc\": \"实盘按小时计费，费用从平台账户余额中扣除；本页说明计费规则、账单与余额预警，以及充值时的注意事项。\\n\\n### 实盘计费\\n- 实盘按小时计费，每个实盘每小时 0.05 USD，不足一小时按一小时计费。\\n- 创建实盘即开始计费，启动时需要预付第一个小时，账户余额不足时实盘无法启动。实盘「停止」/「重启」不会重复计费。\\n- 实盘运行中账户余额耗尽时，平台会停止该实盘；租用的策略到期时，使用该策略的实盘同样会被停止。\\n- 一键租用托管者的服务器费用单独计费，与实盘计费无关，见{@平台基础/托管者/部署托管者/一键租用托管者一键租用托管者}。\\n\\n### 查询账单与余额预警\\n- 在[充值页面](https://www.fmz.com/m/billing)可以查看余额、充值记录和所有计费的账单明细。\\n- 在[账号设置的额度预警](https://www.fmz.com/m/account#alertthreshold)中设置预警阈值：可用余额低于该值时，平台会按[推送设置](https://www.fmz.com/m/account#push)发送通知（App、邮箱、Telegram；24小时内最多通知一次，充值或修改设置后重新计算）；设置为0表示关闭。\\n\\n### 充值\\n在[充值页面](https://www.fmz.com/m/billing)选择充值方式和金额。使用```USDT```充值时务必注意：\\n- 转账网络必须与充值页面选择的网络一致，目前支持TRC20、ERC20、BSC。ERC20与BSC的地址都以```0x```开头，格式相同，最容易选错。\\n- 充值资产选择```USDT```。\\n- 转账地址与充值页面显示的地址一致。\", \"title\": \"实盘计费与充值\"}, {\"_src_hash\": \"d85f9bea27aeaf33f93bbc4ff1a9f73988cd5cb1855080daaabe6e5da6affcc9\", \"desc\": \"把部分实盘交给他人查看和操作，而不交出主账号。\\n\\n### 创建子账号\\n在[账号设置页面](https://www.fmz.com/m/account#shadowmember)打开子账号页签，在操作权限中选择该子账号可以访问的实盘，填写子账号的用户名和登录密码后创建。创建后的子账号显示在同一页面，可以修改、锁定/解锁、删除。\\n\\n![子账号设置](/upload/asset/2e46d725dbe6b471f1b33.png)\\n\\n### 子账号的权限\\n子账号只能看到授权给它的实盘。对这些实盘可以查看日志和图表、修改策略参数、发送交互命令、停止和重启；不能修改实盘的托管者、策略、版本、名称和交易所对象等配置。\\n\\n### 常见用途\\n- 量化团队分工管理多个实盘。\\n- 出租策略时，让租用方协助调试实盘。\", \"title\": \"子账号\"}], \"desc\": \"实盘怎样计费、如何充值，以及如何用子账号把部分实盘交给他人管理。账号的其它设置（推送、二次验证、API接口等）在[账号设置页面](https://www.fmz.com/m/account)。\", \"title\": \"账号与计费\"}], \"desc\": \"平台的几个基本对象：交易所账户、运行策略的托管者、策略库、实盘，以及手动交易用的交易终端和账号与计费。\", \"title\": \"平台基础\"}, {\"_src_hash\": \"66869d17e26e03436b19e725874786c42974e3ad5161770d9a8cd903cefbe2da\", \"children\": [{\"_src_hash\": \"2510f53ce0d95dbd00f32ebd5aecf1bcdbe6c537725c206503ca45a7834be028\", \"children\": [{\"_src_hash\": \"dd48c48518b439a44880b48abc839a5375ee317a64b18752a199de970bcba756\", \"desc\": \"可选的初始化函数：策略开始运行时，在```main()```之前自动调用一次，用于完成初始化任务。\", \"examples\": [{\"examples\": [{\"code\": \"function main(){\\n Log(\\\"main()的第一行\\\", \\\"#FF0000\\\")\\n Log(\\\"退出\\\")\\n}\\n\\n// 初始化函数\\nfunction init(){\\n Log(\\\"初始化\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n Log(\\\"main()的第一行\\\", \\\"#FF0000\\\")\\n Log(\\\"退出\\\")\\n\\n# 初始化函数\\ndef init():\\n Log(\\\"初始化\\\")\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n Log!(\\\"main()的第一行\\\", \\\"#FF0000\\\");\\n Log!(\\\"退出\\\");\\n}\\n\\n// 初始化函数\\nfn init() {\\n Log!(\\\"初始化\\\");\\n}\", \"lang\": \"rust\"}], \"value\": \"```init()```先于```main()```执行，先输出「初始化」，再输出```main()```中的两行日志。\"}], \"title\": \"init()\"}, {\"_src_hash\": \"de14444027cc5c7f57f87d7576fef2240c75ebe7795e077b7d883df7aadc5eca\", \"desc\": \"可选的扫尾函数：策略退出时调用，用于撤单、平仓、保存状态等。最长执行 5 分钟，超时会被强制结束。各语言在哪些情况下调用```onexit()```，见 {@编写策略/策略结构策略结构}。\\n\\n回测中策略通常是不停轮询的死循环，回测数据结束时```main()```并没有正常返回，```JavaScript```、```Python```策略因此不会执行```onexit()```。可以在回测中（```IsVirtual()```为真）捕获回测结束时抛出的异常（EOF），让```main()```返回，从而执行```onexit()```，见第二个示例。```Rust```策略不需要处理：回测结束时 SDK 会先自动执行```onexit()```，再结束策略。\", \"examples\": [{\"examples\": [{\"code\": \"function main(){\\n Log(\\\"开始运行，5秒后停止并执行扫尾函数\\\")\\n Sleep(1000 * 5)\\n}\\n\\n// 扫尾函数实现\\nfunction onexit(){\\n var beginTime = new Date().getTime()\\n while(true){\\n var nowTime = new Date().getTime()\\n Log(\\\"扫尾中，已执行\\\", (nowTime - beginTime) / 1000, \\\"秒\\\")\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import time\\ndef main():\\n Log(\\\"开始运行，5秒后停止并执行扫尾函数\\\")\\n Sleep(1000 * 5)\\n\\n# 扫尾函数实现\\ndef onexit():\\n beginTime = time.time() * 1000\\n while True:\\n ts = time.time() * 1000\\n Log(\\\"扫尾中，已执行\\\", (ts - beginTime) / 1000, \\\"秒\\\")\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n Log!(\\\"开始运行，5秒后停止并执行扫尾函数\\\");\\n Sleep(1000 * 5);\\n}\\n\\n// 扫尾函数实现\\nfn onexit() {\\n let beginTime = Unix() * 1000;\\n loop {\\n let nowTime = Unix() * 1000;\\n Log!(\\\"扫尾中，已执行\\\", (nowTime - beginTime) / 1000, \\\"秒\\\");\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"```main()```5秒后返回，```onexit()```每秒输出一次已执行的时间，直到超过5分钟被强制结束。\"}, {\"examples\": [{\"code\": \"function main() {\\n if (exchange.GetName().startsWith(\\\"Futures_\\\")) {\\n Log(\\\"交易所为期货\\\")\\n exchange.SetContractType(\\\"swap\\\")\\n } else {\\n Log(\\\"交易所为现货\\\")\\n }\\n\\n if (IsVirtual()) {\\n try {\\n onTick()\\n } catch (e) {\\n Log(\\\"error:\\\", e)\\n }\\n } else {\\n onTick()\\n }\\n}\\n\\nfunction onTick() {\\n while (true) {\\n var ticker = exchange.GetTicker()\\n LogStatus(_D(), ticker ? ticker.Last : \\\"--\\\")\\n Sleep(500)\\n }\\n}\\n\\nfunction onexit() {\\n Log(\\\"执行扫尾函数\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n if exchange.GetName().startswith(\\\"Futures_\\\"):\\n Log(\\\"交易所为期货\\\")\\n exchange.SetContractType(\\\"swap\\\")\\n else:\\n Log(\\\"交易所为现货\\\")\\n\\n if IsVirtual():\\n try:\\n onTick()\\n except Exception as e:\\n Log(e)\\n else:\\n onTick()\\n\\ndef onTick():\\n while True:\\n ticker = exchange.GetTicker()\\n LogStatus(_D(), ticker[\\\"Last\\\"] if ticker else \\\"--\\\")\\n Sleep(500)\\n\\ndef onexit():\\n Log(\\\"执行扫尾函数\\\")\", \"lang\": \"python\"}, {\"code\": \"fn onTick() {\\n loop {\\n // 回测结束时SDK先自动执行onexit()，再结束策略，这里不需要特别处理\\n match exchange.GetTicker(None) {\\n Ok(ticker) => LogStatus!(_D(None), ticker.Last),\\n Err(e) => Log!(\\\"error:\\\", e),\\n }\\n Sleep(500);\\n }\\n}\\n\\nfn main() {\\n if exchange.GetName().starts_with(\\\"Futures_\\\") {\\n Log!(\\\"交易所为期货\\\");\\n let _ = exchange.SetContractType(\\\"swap\\\");\\n } else {\\n Log!(\\\"交易所为现货\\\");\\n }\\n\\n onTick();\\n}\\n\\nfn onexit() {\\n Log!(\\\"执行扫尾函数\\\");\\n}\", \"lang\": \"rust\"}], \"value\": \"回测中捕获回测结束时的异常，让```main()```返回，从而执行```onexit()```。\"}], \"title\": \"onexit()\"}, {\"_src_hash\": \"530a6642c783619c202a27f0ceaa0195cbdf22612335e8c62ad46e3b1f7a6de0\", \"desc\": \"可选的异常处理函数，仅支持```JavaScript```：```main()```因未捕获的异常结束时调用，参数```msg```为异常的错误信息。调用了```onerror()```就不再调用```onexit()```。最长执行 5 分钟，超时会被强制结束。\\n\\n回测系统不支持该函数；```Python```、```Rust```策略也不支持。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var arr = []\\n Log(arr[6].Close) // 这里故意引发一个程序异常\\n}\\n\\nfunction onerror(msg) {\\n Log(\\\"错误:\\\", msg)\\n}\", \"lang\": \"javascript\"}], \"value\": \"```main()```中访问不存在的数组元素引发异常，```onerror()```输出错误信息。\"}], \"title\": \"onerror()\"}, {\"_src_hash\": \"558e64476e945d11362b81fa1f932d7239da5ceadeed184ac05493b336386091\", \"desc\": \"策略通常在```main()```中写一个循环：每轮获取行情、计算信号、下单，然后调用 {@fun/Global/Sleep Sleep} 等待下一轮。```Sleep()```在回测中推进回测时间、控制回溯速度，在实盘中控制轮询间隔，从而控制访问交易所 API 的频率。循环中不调用```Sleep()```会以最快速度反复请求交易所接口，容易触发交易所的频率限制。需要在托管者上限制 API 调用频率时，见 {@进阶专题/API限流控制 API限流控制}。\", \"examples\": [{\"examples\": [{\"code\": \"function onTick(){\\n // 在这里写策略逻辑，将会不断调用，例如打印行情信息\\n Log(exchange.GetTicker())\\n}\\n\\nfunction main(){\\n while(true){\\n onTick()\\n // Sleep函数主要用于数字货币策略的轮询频率控制，防止访问交易所API接口过于频繁\\n Sleep(60000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def onTick():\\n Log(exchange.GetTicker())\\n\\ndef main():\\n while True:\\n onTick()\\n Sleep(60000)\", \"lang\": \"python\"}, {\"code\": \"fn onTick() {\\n // 在这里写策略逻辑，将会不断调用，例如打印行情信息\\n Log!(exchange.GetTicker(None));\\n}\\n\\nfn main() {\\n loop {\\n onTick();\\n // Sleep函数主要用于数字货币策略的轮询频率控制，防止访问交易所API接口过于频繁\\n Sleep(60000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"基本框架：每轮执行一次```onTick()```，再用```Sleep()```等待60秒。\"}, {\"examples\": [{\"code\": \"function onTick(){\\n // 这个仅仅是例子，回测或者实盘会很快把资金全部用于下单，实盘请勿使用\\n exchange.Buy(100, 1)\\n}\\n\\nfunction main(){\\n while(true){\\n onTick()\\n // 暂停多久可自定义，单位为毫秒，1秒等于1000毫秒\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def onTick():\\n exchange.Buy(100, 1)\\n\\ndef main():\\n while True:\\n onTick()\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn onTick() {\\n // 这个仅仅是例子，回测或者实盘会很快把资金全部用于下单，实盘请勿使用\\n let _ = exchange.Buy(100, 1);\\n}\\n\\nfn main() {\\n loop {\\n onTick();\\n // 暂停多久可自定义，单位为毫秒，1秒等于1000毫秒\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"每隔1秒挂一个价格为100、数量为1的买单（仅作演示，会很快把资金全部用于下单）。\"}, {\"examples\": [{\"code\": \"function onTick() {\\n Log(\\\"K-line updated, new BAR generated\\\")\\n}\\n\\nfunction main() {\\n var exName = exchange.GetName()\\n if (exName.includes(\\\"Futures_\\\")) {\\n exchange.SetContractType(\\\"swap\\\")\\n }\\n\\n var lastTs = 0\\n while (true) {\\n var r = _C(exchange.GetRecords)\\n if (r.length > 0 && r[r.length - 1].Time != lastTs) {\\n onTick()\\n lastTs = r[r.length - 1].Time\\n }\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def onTick():\\n Log(\\\"K-line updated, new BAR generated\\\")\\n\\ndef main():\\n exName = exchange.GetName()\\n if \\\"Futures_\\\" in exName:\\n exchange.SetContractType(\\\"swap\\\")\\n\\n lastTs = 0\\n while True:\\n r = _C(exchange.GetRecords)\\n if len(r) > 0 and r[-1][\\\"Time\\\"] != lastTs:\\n onTick()\\n lastTs = r[-1][\\\"Time\\\"]\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn onTick() {\\n Log!(\\\"K-line updated, new BAR generated\\\");\\n}\\n\\nfn main() {\\n let exName = exchange.GetName();\\n if exName.contains(\\\"Futures_\\\") {\\n let _ = exchange.SetContractType(\\\"swap\\\");\\n }\\n\\n let mut lastTs = 0;\\n loop {\\n let r = _C!(exchange.GetRecords(None, None, None));\\n if r.len() > 0 && r[r.len() - 1].Time != lastTs {\\n onTick();\\n lastTs = r[r.len() - 1].Time;\\n }\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"按K线更新处理（On Bar）：最新一根K线的时间变化时才执行```onTick()```。\"}], \"title\": \"主循环\"}, {\"_src_hash\": \"1a1c1a4875e1a8eadd71d38403cbc4dc148b76fadba486514af3b3025e0a199c\", \"desc\": \"除了按固定间隔轮询，策略也可以等待事件到达后再处理，减少无效请求，也能更快地响应行情变化。\\n\\n### EventLoop\\n\\n{@fun/Threads/EventLoop EventLoop} 等待```exchange.Go()```、```HttpQuery_Go()```等并发任务完成、WebSocket 连接有可读数据、线程消息等事件；有事件时返回事件信息，策略再去读取对应的数据。第一次调用```EventLoop()```时才开始记录事件，所以先调用一次```EventLoop(-1)```再发起并发任务：\\n\\n```javascript\\nfunction main() {\\n EventLoop(-1) // 开始记录事件，避免错过之后发生的事件\\n var r1 = exchange.Go(\\\"GetTicker\\\")\\n var r2 = exchange.Go(\\\"GetDepth\\\")\\n var ev = EventLoop(1000) // 等待任意一个并发任务完成，最多等 1 秒\\n Log(\\\"event:\\\", ev)\\n Log(\\\"ticker:\\\", r1.wait(), \\\"depth:\\\", r2.wait())\\n}\\n```\\n\\n### ctx.subscribe / ctx.poll\\n\\n```JavaScript```和```Rust```策略还可以使用托管者的事件订阅接口：```ctx.subscribe()```订阅某个账户、某个品种的行情或订单回报，返回流 ID；```ctx.poll()```取出下一条事件（可以设置等待超时），策略按事件的```kind```分别处理。```Python```策略不支持。\\n\\n```javascript\\nfunction main() {\\n ctx.subscribe(0, \\\"BTC_USDT\\\", {channel: \\\"ticker\\\"}) // 第一个参数是账户在 exchanges 中的下标\\n ctx.subscribe(0, \\\"\\\", {channel: \\\"orders\\\"}) // 订单回报\\n while (true) {\\n const ev = ctx.poll([], 1000) // [] 表示所有订阅，最多等 1 秒\\n if (!ev) {\\n continue\\n }\\n if (ev.kind === 1) {\\n Log(\\\"ticker:\\\", ev.symbol, ev.bid, ev.ask, ev.last)\\n } else if (ev.kind === 16) {\\n Log(\\\"order:\\\", ev.id, ev.state, ev.filledQty)\\n }\\n }\\n}\\n```\\n\\n- ```channel```可选```ticker```、```bbo```、```depth```、```trade```、```kline```（```interval```为周期秒数）、```orders```。\\n- 事件的```kind```：1 为 ticker，3 为深度（事件只表示订单簿已更新，档位用```ctx.book(ev.ex, ev.symbol, n)```读取），4 为成交，5 为 K 线，16 为订单回报。\\n- 行情类订阅消费不及时会只保留最新数据或丢弃最旧的数据，订单回报不会丢弃，策略需要持续调用```ctx.poll()```。\\n- ```EventLoop()```与```ctx.poll()```从同一批事件队列中取事件，一个策略只使用其中一种。\\n\\n```Rust```策略中的写法为```ctx::subscribe()```、```ctx::poll()```，事件为原始结构，价格、数量是定点整数：\\n\\n```rust\\nfn main() {\\n let s = ctx::subscribe(0, \\\"BTC_USDT\\\", ctx::SubOpts::ticker()).unwrap();\\n loop {\\n match ctx::poll(&[s], Some(1000)) {\\n ctx::Polled::Event(ev) => Log!(\\\"event kind:\\\", ev.kind),\\n ctx::Polled::Stopped => break,\\n _ => {}\\n }\\n }\\n}\\n```\", \"title\": \"事件驱动\"}], \"desc\": \"```JavaScript```、```Python```、```Rust```策略由几个约定名称的函数组成，托管者在固定的时机调用它们。My语言、PINE、Workflow 策略不需要编写这些函数。\\n\\n### 生命周期函数\\n\\n| 函数 | 是否必须 | 调用时机 |\\n| - | - | - |\\n| ```main()``` | 必须 | 入口函数，策略的主体。```main()```返回，策略即运行结束。 |\\n| ```init()``` | 可选 | 在```main()```之前调用一次，用于初始化。 |\\n| ```onexit()``` | 可选 | 策略退出时调用，用于扫尾（撤单、平仓、保存状态等）。 |\\n| ```onerror(msg)``` | 可选 | 仅```JavaScript```：```main()```因未捕获的异常结束时调用，```msg```为错误信息。调用了```onerror()```就不再调用```onexit()```。 |\\n| ```destroy()``` | 可选 | 仅```JavaScript```模板类库：策略退出时，在```onexit()```或```onerror()```之后调用，见 {@编写策略/模板类库模板类库}。 |\\n\\n退出时调用哪个函数：\\n\\n| 退出原因 | JavaScript | Python | Rust |\\n| - | - | - | - |\\n| ```main()```正常返回 | ```onexit()``` | ```onexit()``` | ```onexit()``` |\\n| 停止实盘 | ```onexit()``` | ```onexit()``` | ```onexit()``` |\\n| 未捕获的异常、```panic``` | ```onerror(msg)``` | 都不调用 | ```onexit()``` |\\n\\n### 注意事项\\n- ```onexit()```、```onerror()```最长执行 5 分钟（时长由服务端按任务下发，默认 5 分钟），超时会被强制结束。\\n- 回测中策略通常是不停轮询的死循环，回测结束时```main()```并没有正常返回，```JavaScript```、```Python```策略因此不会执行```onexit()```，处理方法见 {@编写策略/策略结构/onexit() onexit()}；```Rust```策略在回测结束时会自动执行```onexit()```。\\n- ```JavaScript```策略的```main()```返回时，用```threading```创建的子线程会被终止；还没有到期的```setTimeout```回调会先执行完，再调用```onexit()```。\\n- ```JavaScript```、```Python```模板类库可以定义自己的```init()```，在模板加载时执行，早于策略的```init()```。\\n\\n### 主循环与事件驱动\\n\\n大多数策略在```main()```中写一个循环：每轮获取数据、计算、下单，然后```Sleep()```等待下一轮，见 {@编写策略/策略结构/主循环主循环}。也可以等待行情、订单等事件到达后再处理，见 {@编写策略/策略结构/事件驱动事件驱动}。全部 API 函数的分类速查见 {@编写策略/API函数速查 API函数速查}。\", \"title\": \"策略结构\"}, {\"_src_hash\": \"a1818f9fc4a145b510de594a3de29671e36f1c69988b17f0dd3c5965ffbaacc2\", \"children\": [{\"_src_hash\": \"ecd313bbc6a763a38a6320c5bd32756b01d37a5d1219f303056951b4880413a9\", \"desc\": \"平台支持用```JavaScript```编写策略。运行时基于 QuickJS 引擎，支持```async```/```await```、```class```、```BigInt```等现代语法；实盘时策略在托管者上运行，回测时在浏览器端的回测系统中运行。也可以用 TypeScript 编写，见本页末尾「用 TypeScript 编写」。\\n\\n### 策略结构与参数\\n\\n策略入口为```function main()```，可选的```init()```、```onexit()```、```onerror(msg)```由托管者自动调用，见 {@编写策略/策略结构策略结构}。界面参数是同名的全局变量，可以直接读取，也可以在代码中修改，见 {@编写策略/策略参数策略参数}。\\n\\n### 错误与返回值\\n\\nAPI 函数调用失败（交易所返回错误、网络问题等）时返回```null```，并在日志中输出错误信息。使用返回值之前先判断，或者用 {@fun/Global/_C _C} 重试：\\n\\n```javascript\\nfunction main() {\\n var ticker = exchange.GetTicker()\\n // 调用失败时返回 null\\n if (ticker) {\\n Log(ticker)\\n }\\n\\n // 失败时自动重试，直到返回有效数据\\n var account = _C(exchange.GetAccount)\\n Log(account)\\n}\\n```\\n\\n程序异常（例如读取```undefined```的属性）和接口业务报错的日志中会显示出错位置在策略代码中的行号，便于调试和排查。\\n\\n### 字符串与ArrayBuffer\\n\\nJavaScript 的字符串是 UTF-16 编码。平台 API 返回的文本如果不是合法的 UTF-8 字节序列，为了不丢失数据，会返回```ArrayBuffer```（原始字节）。所有可以传入字符串的 API 参数也都接受```ArrayBuffer```。\\n\\n```javascript\\nfunction stringToHex(str) {\\n let hex = ''\\n for (let i = 0; i < str.length; i++) {\\n const charCode = str.charCodeAt(i).toString(16)\\n hex += charCode.length === 1 ? '0' + charCode : charCode\\n }\\n return hex\\n}\\n\\nfunction main() {\\n // “𠮷”的 Unicode 码点超出 16 位，在 JavaScript 字符串中占两个 UTF-16 码元\\n const inputString = \\\"abc𠮷123\\\"\\n\\n // Encode 按 UTF-8 编码后输出 hex\\n const encodedHex = Encode(\\\"raw\\\", \\\"string\\\", \\\"hex\\\", inputString)\\n Log(encodedHex) // 616263f0a0aeb7313233\\n\\n // charCodeAt 取的是 UTF-16 码元，“𠮷”被写成 d842、dfb7，结果不是 UTF-8 编码\\n const manuallyEncodedHex = stringToHex(inputString)\\n Log(manuallyEncodedHex) // 616263d842dfb7313233\\n\\n // 合法的 UTF-8 字节可以还原为字符串\\n const decodedString = Encode(\\\"raw\\\", \\\"hex\\\", \\\"string\\\", encodedHex)\\n Log(decodedString) // abc𠮷123\\n\\n // 不是合法的 UTF-8 字节，返回 ArrayBuffer\\n // （如果 inputString 改为 \\\"abcG123\\\"，两种编码结果相同，这里得到的是字符串）\\n const outputD = Encode(\\\"raw\\\", \\\"hex\\\", \\\"string\\\", manuallyEncodedHex)\\n Log(outputD instanceof ArrayBuffer) // true\\n\\n // 查看 ArrayBuffer 中的原始字节\\n const bufferD = new Uint8Array(outputD)\\n let hexBufferD = ''\\n for (let i = 0; i < bufferD.length; i++) {\\n hexBufferD += bufferD[i].toString(16).padStart(2, '0')\\n }\\n Log(hexBufferD) // 616263d842dfb7313233\\n}\\n```\\n\\n### 异步与多线程\\n\\n- ```setTimeout```/```clearTimeout```：回调在主线程调用```Sleep()```等待期间执行；```main()```返回时还没到期的定时器会先执行完，再调用```onexit()```。\\n- ```fetch(url)```：返回```Promise```，结果为响应对象（```ok```、```status```、```headers```属性，```text()```、```json()```直接返回内容）。托管者中的```fetch```在调用时就同步完成请求，返回的是已经完成的```Promise```，所以用```Promise.all```组合多个```fetch```并不会并发请求。\\n- 交易所 API（例如```exchange.GetTicker()```）是同步阻塞调用，包装进```Promise```或```async```函数也不会并发执行。\\n- 需要并发时使用 {@fun/Threads/exchange.Go exchange.Go}、{@fun/Network/HttpQuery_Go HttpQuery_Go}，或者用 {@fun/Threads/threading/Thread Thread} 创建线程，见 {@进阶专题/JavaScript多线程 JavaScript多线程}。\\n\\n```javascript\\nasync function main() {\\n let resp = await fetch(\\\"https://www.okx.com/api/v5/market/books?instId=BTC-USDT\\\")\\n if (resp.ok) {\\n Log(resp.json())\\n } else {\\n Log(\\\"status:\\\", resp.status)\\n }\\n}\\n```\\n\\n### 库与依赖\\n\\nJavaScript 策略可以直接使用内置的```TA```指标库和```talib```指标库，各语言可用的内置库见 {@编写策略/内置库内置库}。其它第三方 JavaScript 库可以在运行时下载后用```eval```加载，示例见同一页。\\n\\n### 用 TypeScript 编写\\n\\nTypeScript 不是单独的语言选项：创建策略时选择```JavaScript```，在代码中（通常是首行）写一行```//@ts-check```注释（或点击策略编辑区右上角的「TypeScript」按钮），平台就按 TypeScript 处理，在回测和实盘运行前先编译为 JavaScript。通过 AI/MCP 工具保存策略时，语言可以写```typescript```，平台按 JavaScript 策略保存，并在代码开头自动加上```//@ts-check```，见 {@扩展API接口/AI接入 AI接入}。\\n\\n平台 API 的类型声明由策略编辑器内置提供，不需要在代码中引用：全局函数、```exchange```对象、```ITicker```、```IRecord```、```IOrder```、```IPosition```等数据结构接口，以及```TA```、```talib```等。静态类型检查能在编写时发现参数个数、属性名、类型用错之类的问题。运行时的语言特性、API 和库与 JavaScript 相同。\\n\\n```typescript\\n//@ts-check\\nfunction getSignal(ticker: ITicker, ma: number): \\\"buy\\\" | \\\"sell\\\" | null {\\n if (ticker.Last > ma) {\\n return \\\"buy\\\"\\n }\\n return ticker.Last < ma ? \\\"sell\\\" : null\\n}\\n\\nfunction main() {\\n const records = exchange.GetRecords()\\n const ticker = exchange.GetTicker()\\n if (records && ticker && records.length > 20) {\\n const ma = TA.MA(records, 20)\\n Log(getSignal(ticker, ma[ma.length - 1]))\\n }\\n}\\n```\", \"title\": \"JavaScript\"}, {\"_src_hash\": \"5fbd1f03adaaf7090a075298d9db1358223c0ff4f17900632482720e672025f1\", \"desc\": \"平台支持用```Python 3```编写策略，不支持 Python 2。实盘以及在托管者上进行的回测，使用托管者所在机器上安装的 Python 解释器运行策略。\\n\\n### 解释器\\n\\n实盘按以下顺序查找解释器，使用第一个能启动、并且版本为 Python 3 的程序：\\n1. 策略代码首行```#!```指定的解释器，例如```#!/opt/venv/bin/python3```；写成```#!/usr/bin/env python3.11```时取```python3.11```；\\n2. 环境变量```PYTHON_BIN```指定的解释器；\\n3. ```python3```；\\n4. ```python```。\\n\\n首行指定的解释器不可用时，托管者退回后面的候选，并在实盘目录的```stderr.log```中留一行说明。不想改策略代码时，也可以在启动托管者之前设置环境变量来指定解释器（例如虚拟环境中的 Python）：\\n\\n```bash\\nexport PYTHON_BIN=/opt/venv/bin/python3\\n```\\n\\n在托管者上进行的回测不读```PYTHON_BIN```：按首行```#!```指定的解释器、```python3```、```python```的顺序，在```PATH```中查找第一个存在的程序。\\n\\n### 策略结构与参数\\n\\n策略入口为```def main()```，可选的```init()```、```onexit()```由托管者自动调用（Python 不支持```onerror()```），见 {@编写策略/策略结构策略结构}。界面参数是同名的全局变量；在函数中给参数重新赋值时，需要先用```global```声明。\\n\\n### 错误与返回值\\n\\nAPI 函数调用失败时返回```None```，并在日志中输出错误信息。使用返回值之前先判断，或者用```_C()```重试。策略中未捕获的异常会结束运行，错误信息记录在日志中。\\n\\n### 输出\\n\\n```print()```的输出写入托管者目录下的```logs/storage/<实盘ID>/stdout.log```（错误输出写入同目录的```stderr.log```），不会出现在实盘日志里。需要显示在日志中的内容请用 {@fun/Log/Log Log}。\\n\\n### 第三方库\\n\\n策略可以导入解释器中已经安装的任何库。安装时要使用托管者运行策略的那个解释器，例如：\\n\\n```bash\\npython3 -m pip install numpy\\n# 首行用 #! 指定了解释器时，用该解释器安装，例如\\n/opt/venv/bin/python3 -m pip install numpy\\n# 设置了 PYTHON_BIN 时\\n$PYTHON_BIN -m pip install numpy\\n```\\n\\n使用```talib```需要在托管者所在机器上安装 TA-Lib（```talib```包）和```numpy```。\\n\\n### 自定义模块\\n\\n策略运行时的当前目录是实盘目录```logs/storage/<实盘ID>/```（用相对路径打开的文件落在这里，随实盘保留）；```PYTHONPATH```是托管者为本次运行创建的临时目录，运行结束后会被删除。当前目录不在模块搜索路径中，放在实盘目录下的```.py```文件不会被自动找到。导入自己编写的模块有两种方式：\\n- 把模块安装到解释器的```site-packages```中（例如做成包用```pip install```安装，或者直接复制到```site-packages```目录）；\\n- 在策略中先把模块所在目录的绝对路径加入```sys.path```，再导入。\\n\\n例如模块文件```/home/user/fmz_modules/mymath.py```：\\n\\n```python\\n# mymath.py\\ndef add(a, b):\\n return a + b\\n```\\n\\n策略代码：\\n\\n```python\\nimport sys\\nsys.path.append(\\\"/home/user/fmz_modules\\\") # 模块所在目录的绝对路径\\n\\nimport mymath\\n\\ndef main():\\n Log(\\\"mymath.add(1, 2):\\\", mymath.add(1, 2))\\n```\\n\\n把核心代码做成模块放在自己的托管者上，策略代码中只保留调用部分，也是一种不把核心代码上传到平台的做法。\", \"title\": \"Python\"}, {\"_src_hash\": \"edb4e8a99eec3249791e01fc67b9c47df36121ef1aa81345896cc2a19215d3c2\", \"desc\": \"平台支持用```Rust```编写策略。Rust 策略先编译再运行：回测时由平台服务器编译，默认在云端（平台服务器）回测，也可以选择「本地」回测节点在浏览器中运行；实盘时编译通过后在托管者上运行。策略编辑器为 Rust 集成了```rust-analyzer```，提供代码补全与实时诊断。\\n\\n### 策略结构\\n\\n策略代码只需要一个```fn main()```。平台 API（```exchange```、```exchanges```、```TA```、```Log!```、```_C!```等）已经自动导入，不需要写```use```或```mod```声明。\\n\\n可选的```fn init()```、```fn onexit()```由托管者自动调用，定义即可，不需要注册：```init()```在```main()```之前执行；```onexit()```在```main()```正常返回、实盘被停止、策略```panic```、回测结束时都会执行。Rust 不支持```onerror()```。详见 {@编写策略/策略结构策略结构}。\\n\\n```rust\\nfn init() {\\n Log!(\\\"初始化\\\");\\n}\\n\\nfn main() {\\n // 可能失败的 API 返回 Result，_C! 宏在失败时重试，直到调用成功\\n let ticker = _C!(exchange.GetTicker(None));\\n Log!(\\\"Last:\\\", ticker.Last);\\n}\\n\\nfn onexit() {\\n Log!(\\\"策略退出，执行扫尾处理\\\");\\n}\\n```\\n\\n日志等部分功能以宏的形式提供（注意感叹号）：```Log!()```、```LogStatus!()```、```Panic!()```、```_G!()```、```_C!()```；```LogProfit()```、```Sleep()```、```_D()```、```_N()```、```HttpQuery()```等是普通函数。\\n\\n### 参数类型\\n\\n界面参数以同名的全局常量注入策略，只能读取，不能在代码中修改（需要变化的值请复制到局部变量）。类型由参数种类决定：\\n\\n| 参数种类 | Rust 类型 |\\n| - | - |\\n| 数字型 | ```f64``` |\\n| 布尔型 | ```bool``` |\\n| 字符串 | ```&str``` |\\n| 下拉框（单选） | ```f64```（选项索引）；选项绑定了字符串数据时为```&str``` |\\n| 下拉框（多选） | ```&[i64]```、```&[f64]```或```&[&str]```；选项值类型混杂时为 JSON 文本```&str``` |\\n| 加密串 | ```&str```或```Decrypted```（可解引用为```str```） |\\n\\n- 整数用途需要自行转换，例如```let n = Period as usize;```。\\n- 选填参数没有填写时为该类型的零值：```0.0```、```\\\"\\\"```、```false```，多选下拉框为空。\\n- 加密串参数在服务端不能预先解密时（例如私有托管者），注入为```static```的```Decrypted```类型，第一次使用时才解密。它实现了```Display```，可以直接用于```format!```；传给```Log!```或其它需要```&str```的地方写```&*参数名```（对```&str```类型的参数同样适用）：\\n\\n```rust\\nfn main() {\\n let key: &str = &*ApiKey; // ApiKey 为加密串参数\\n Log!(\\\"key length:\\\", key.len());\\n}\\n```\\n\\n- 参数名与代码中的其它名字冲突时，可以用```args::参数名```引用参数。\\n\\n### 错误与返回值\\n\\n可能失败的 API 调用返回```Result```，用 Rust 惯用的方式处理（JavaScript 中失败返回```null```）：\\n\\n```rust\\nfn main() {\\n // 方式一：模式匹配\\n if let Ok(ticker) = exchange.GetTicker(None) {\\n Log!(ticker);\\n }\\n\\n // 方式二：_C! 宏在失败时重试，直到调用成功\\n let ticker = _C!(exchange.GetTicker(None));\\n Log!(ticker);\\n}\\n```\\n\\n可选参数（例如```GetTicker```的```symbol```参数）不传时用```None```占位，传值时直接传入，例如```exchange.GetTicker(\\\"BTC_USDT\\\")```。\\n\\n### JSON\\n\\n平台 API 返回的原始 JSON 文本（例如```exchange.IO()```的返回值、各结构体的```Info```字段）用内置的```JSONParse()```解析，得到```Option```；用```v[\\\"key\\\"]```、```v[0]```取子节点，用```as_f64()```、```as_str()```、```as_bool()```等方法取值。```JsonValue```实现了```Display```，```v.to_string()```或```format!(\\\"{}\\\", v)```得到紧凑的 JSON 文本。SDK 没有提供构造 JSON 的便捷接口，生成 JSON 文本可以用```format!```拼接，或者引入```serde_json```。\\n\\n### 第三方 crate\\n\\n策略源码是唯一的代码文件（没有单独的```Cargo.toml```）。在源码最顶部用```---```包裹的 frontmatter 声明依赖，构建时合并进```Cargo.toml```：\\n\\n```rust\\n---\\n[dependencies]\\nserde_json = \\\"1\\\"\\n---\\n/*backtest\\nstart: 2024-01-01 00:00:00\\nend: 2024-02-01 00:00:00\\nperiod: 1h\\n*/\\nfn main() {\\n let v: serde_json::Value = serde_json::from_str(r#\\\"{\\\"a\\\": 1}\\\"#).unwrap();\\n Log!(\\\"a:\\\", v[\\\"a\\\"].to_string());\\n}\\n```\\n\\n- frontmatter 必须在源码开头，前面只能有空行或以```#!```开头的行；```/*backtest ... */```回测配置块要放在 frontmatter 结束的```---```之后。策略中还没有回测配置块时，「保存回测设置」会把配置块插入到源码最前面，这时需要把它移到 frontmatter 之后（之后再保存会在原位置更新）。\\n- 策略和它引用的模板类库中，依赖块只能写在其中一处，两处都写会编译失败。\\n- 编译环境中没有系统 OpenSSL，需要 TLS 的 crate（HTTP/WebSocket 客户端等）请选用纯 Rust 实现的```rustls```（例如```tokio-tungstenite```开启```rustls-tls-webpki-roots```特性），避免依赖```native-tls```/```openssl-sys```；WebSocket 连接优先使用内置的 {@fun/Network/Dial Dial} 函数，不需要第三方 crate。\\n\\n### 内置库\\n\\nRust 策略可以使用```TA```指标库，不支持```talib```，见 {@编写策略/内置库内置库}。\", \"title\": \"Rust\"}, {\"_src_hash\": \"19312a76d3c8aab2d7fec9a25424f28a38b4674e6c772a6affe8db787e0a3371\", \"desc\": \"平台支持用My语言（麦语言）编写策略，兼容文华麦语言的大部分语法、指令和函数。My语言把复杂算法拆解成函数，用简洁的语法和金融函数库描述交易逻辑。\\n\\n策略示例：基于平移布林通道的系统\\n\\n```My\\nM := 12; // 参数范围 1, 20\\nN := 3; // 参数范围 1, 10\\nSDEV := 2; // 参数范围 1, 10\\nP := 16; // 参数范围 1, 20\\n\\n// 该策略为趋势跟踪交易策略，适用较大周期，如日线。\\n// 该模型仅用作模型开发案例，依此入市，风险自负。\\n\\n////////////////////////////////////////////////////////\\n\\n// 平移BOLL通道计算\\nMID:=MA(C,N); // 计算中轨\\nTMP:=STD(C,M)*SDEV; // 计算标准差\\nDISPTOP:=REF(MID,P)+TMP; // 平移BOLL通道上轨\\nDISPBOTTOM:=REF(MID,P)-TMP; // 平移BOLL通道下轨\\n\\n// 系统入场\\nH>=DISPTOP,BPK;\\nL<=DISPBOTTOM,SPK;\\nAUTOFILTER;\\n```\\n\\n- [FMZ量化My语言文档](https://www.fmz.com/bbs-topic/2569)\\n- [FMZ量化My语言--My语言交易类库参数](https://www.fmz.com/bbs-topic/5768)\", \"title\": \"My语言（麦语言）\"}, {\"_src_hash\": \"5b0c1192e440940a32a3ea0a103460e4216a10b025646679351662ec8405fa8b\", \"desc\": \"平台支持并兼容```Trading View```的PINE语言脚本。PINE语言用于编写可以回测和实盘交易的指标与策略，社区已有超过10万个公开的PINE脚本，可以直接借用来实现自己的交易想法，不必从零开始编写。\\n\\n策略示例：超级趋势策略\\n\\n```pine\\nstrategy(\\\"supertrend\\\", overlay=true)\\n\\n[supertrend, direction] = ta.supertrend(input(5, \\\"factor\\\"), input.int(10, \\\"atrPeriod\\\"))\\nplot(direction < 0 ? supertrend : na, \\\"Up direction\\\", color = color.green, style=plot.style_linebr)\\nplot(direction > 0 ? supertrend : na, \\\"Down direction\\\", color = color.red, style=plot.style_linebr)\\n\\nif direction < 0\\n if supertrend > supertrend[2]\\n strategy.entry(\\\"entry long\\\", strategy.long)\\n else if strategy.position_size < 0\\n strategy.close_all()\\nelse if direction > 0\\n if supertrend < supertrend[3]\\n strategy.entry(\\\"entry short\\\", strategy.short)\\n else if strategy.position_size > 0\\n strategy.close_all()\\n```\\n\\n- [PINE Script 文档](https://www.fmz.com/bbs-topic/9315)\", \"title\": \"PINE语言\"}, {\"_src_hash\": \"42362f0a14ffde529345050b607e3b66fb63083e7b8e3d30be88a3efbd0750aa\", \"desc\": \"平台支持Workflow工作流方式编写策略。工作流是一种可视化的策略设计方式，通过节点连接和配置来构建交易逻辑，无需编写代码即可实现策略。\\n\\n### 工作流特点\\n- 可视化拖拽设计，所见即所得\\n- 预置丰富的功能节点（数据获取、指标计算、条件判断、交易执行等）\\n- 降低编程门槛，适合快速搭建和验证策略\\n- 支持回测功能，可视化查看节点执行状态\\n\\n### 学习资源\\n- [工作流系列视频教程](https://www.fmz.com/class/workflow)\", \"title\": \"Workflow工作流\"}], \"desc\": \"平台支持用```JavaScript```、```Python```、```Rust```、[```PINE```](https://www.fmz.com/bbs-topic/9315)、[```My语言```](https://www.fmz.com/bbs-topic/2569)（麦语言）和```Workflow```工作流编写策略。\\n\\n```JavaScript```、```Python```、```Rust```策略直接调用平台的全部API；PINE、My语言兼容TradingView、文华的脚本语法；Workflow工作流用可视化节点搭建策略，不需要写代码。\", \"title\": \"编程语言\"}, {\"_src_hash\": \"d0232e55f657b4b6eff7d4528e4fc751e81981861b35f61ccec3c1f8d45a9ce0\", \"children\": [{\"_src_hash\": \"582c9c6a4cf9e0c8ff75a135fa64bc9fccca598c735988566844fe6b35255218\", \"desc\": \"界面参数在策略编辑页面代码编辑区下方的策略参数区设置，共有5种类型。下表中的变量名只是示例：\\n\\n| 类型 | 变量示例 | 代码中的值 | 默认值 |\\n| - | - | - | - |\\n| 数字型（number） | ```pNum``` | 数值；Rust 中为```f64``` | 输入数值，例如```100``` |\\n| 布尔型（true/false） | ```pBool``` | 布尔值 | 用开关控件设置，不能设为选填 |\\n| 字符串（string） | ```pStr``` | 字符串 | 直接输入，例如```abc```，不加引号 |\\n| 下拉框（selected） | ```pCombox``` | 选中选项的索引或绑定的数据；支持多选时为数组 | 选中一个或多个选项 |\\n| 加密串（string） | ```pSecretStr``` | 字符串 | 直接输入，例如```xyz```，不加引号 |\\n\\n### 参数的设置项\\n- 变量：参数在策略代码中的全局变量名，不要使用当前编程语言的保留字（关键字）。\\n- 描述：参数绑定的控件的显示名称。\\n- 备注：在回测、实盘界面上鼠标停在参数控件上时显示的说明。\\n- 默认值与「选填」：默认值旁的「选填」控件默认为选填状态，可以改为必填。必填参数在回测、实盘时没有设置，就无法开始回测或启动实盘。\\n- 组件配置：参数绑定的界面控件类型，以及最小值、最大值、分组、过滤器等，见{@编写策略/策略参数/组件配置组件配置}。\\n\\n### 注意事项\\n- 参数在代码中是全局变量，可以在代码中修改（Rust 除外：Rust 中参数是全局常量，不能修改）。\\n- 「加密串」参数的用法与「字符串」参数相同，只是加密发送，不会明文传输。\\n- 选填参数没有填写时：字符串参数的值为空字符串；数字型、下拉框、加密串参数的值为空值。```Rust```策略中为该类型的零值：数字为```0```，字符串、加密串为空字符串，布尔为```false```。\\n- 下拉框参数在「组件配置」中没有开启「支持多选」时，值为当前选中选项的索引，给选项绑定了数据时为该数据；开启「支持多选」后，值为包含所有选中选项的索引（或绑定数据）的数组。\", \"title\": \"界面参数种类\"}, {\"_src_hash\": \"644d4b1599e143e3633d6f2e67f51ceac15ef5a2e6e0897987ad32f8330adf8e\", \"desc\": \"策略界面参数和策略交互控件都有「组件配置」选项，用于设置参数（或交互控件）对应的界面控件，以及最小值、最大值、分组、过滤器等。\\n\\n各种类型可选的组件（第一个为默认组件）：\\n\\n| 类型 | 组件 |\\n| - | - |\\n| 数字型（number） | 输入框、时间选择器、滑动输入条 |\\n| 布尔型（true/false） | 开关 |\\n| 字符串（string） | 输入框、文本框、时间选择器、颜色选择器、币种、交易代码 |\\n| 下拉框（selected） | 下拉框、分段控制器、币种、交易代码 |\\n| 加密串（string），仅策略参数 | 加密输入框 |\\n| 按钮（button），仅交互控件 | 按钮（没有输入项） |\\n\\n### 分组\\n\\n在组件配置的「分组」输入框中输入一个标签名，可以把若干个策略参数划分到同一个分组中（代替平台旧功能「策略分组」）。交互控件同样可以分组（代替旧功能「交互控件分组」）。\\n\\n### 过滤器\\n\\n策略参数的组件配置中，「过滤器」输入框可以填写判定表达式，控制参数是否可用（代替平台旧功能「参数依赖」）。过滤器默认为空，不做任何过滤；过滤条件为真时，当前参数可用。可以使用```a > b```、```a == 1```、```a```、```!a```、```a >= 1 && a <= 10```等表达式，例如：\\n- ```a == 1```：参数```a```等于1时可用，否则不可用。\\n- ```a >= 1 && a <= 10```：```a```大于等于1并且小于等于10时可用，否则不可用。\\n- ```!a```：过滤条件为「非a」；```a```可以是布尔值，也可以是数值（```!0```为真）。\", \"title\": \"组件配置\"}, {\"_src_hash\": \"e2a31579cba1c1fe5321e127f68ae783b975fca1039ac58f58c08a8918e2c1e5\", \"desc\": \"回测时设置的策略参数可以保存到策略代码中；实盘的参数可以导出为文件，再导入到其它实盘。\\n\\n### 保存回测参数\\n在回测页面修改策略参数后点击「保存回测设置」，参数和回测配置一起以注释块的形式保存在策略代码开头，见 {@回测系统/回测配置与保存回测配置与保存}。例如策略有以下参数：\\n\\n| 变量 | 描述 | 类型 | 默认值 |\\n| - | - | - | - |\\n| number | 数值类型 | 数字型（number） | 1 |\\n| string | 字符串 | 字符串（string） | Hello FMZ |\\n| combox | 下拉框 | 下拉框（selected） | 1\\\\|2\\\\|3 |\\n| bool | 布尔值 | 布尔型（true/false） | true |\\n| numberA | 数值A（过滤器为```isShowA```，```isShowA```为真时才可用） | 数字型（number） | 2 |\\n| isShowA | 是否显示numberA参数 | 布尔型（true/false） | false |\\n\\n修改参数值后保存，策略代码开头得到的配置块如下（```JavaScript```、```Rust```用```/*backtest ... */```，```Python```用```'''backtest ... '''```）：\\n\\n```javascript\\n/*backtest\\nstart: 2020-02-29 00:00:00\\nend: 2020-03-29 00:00:00\\nperiod: 1d\\nargs: [[\\\"number\\\",2],[\\\"string\\\",\\\"Hello\\\"],[\\\"combox\\\",2],[\\\"bool\\\",false],[\\\"numberA\\\",666],[\\\"isShowA\\\",true]]\\n*/\\n```\\n\\n```python\\n'''backtest\\nstart: 2020-02-29 00:00:00\\nend: 2020-03-29 00:00:00\\nperiod: 1d\\nargs: [[\\\"number\\\",2],[\\\"string\\\",\\\"Hello\\\"],[\\\"combox\\\",2],[\\\"bool\\\",false],[\\\"numberA\\\",666],[\\\"isShowA\\\",true]]\\n'''\\n```\\n\\n```Rust```策略如果在开头用 frontmatter 声明了依赖，回测配置块要放在 frontmatter 之后，见 {@编写策略/编程语言/Rust Rust}。\\n\\n### 导入导出实盘参数\\n1. 在实盘页面点击「参数设置」，再点击「导出参数」，参数保存为一个```json```文件。\\n2. 在要导入的实盘页面点击「导入参数」，选择导出的文件。\\n3. 点击「更新参数」保存，导入的参数才会生效。\", \"title\": \"保存参数设置\"}], \"desc\": \"在策略界面上设置，在策略代码中以同名的全局变量（Rust 中为全局常量）出现，直接用变量名访问。各语言的差异：\\n- ```JavaScript```、```My语言```：可以直接读取参数，也可以在代码中修改参数变量。\\n- ```Python```：可以直接读取；在函数中给参数变量重新赋值时，需要先用```global```声明。\\n- ```Rust```：参数是常量，只能读取，不能修改；各种参数对应的类型见 {@编写策略/编程语言/Rust Rust}。\\n- ```PINE```：使用```input()```函数创建界面参数。\\n\\n![策略参数设置界面](/upload/asset/2e46b5e593de3b2f11445.png)\", \"title\": \"策略参数\"}, {\"_src_hash\": \"272de84678d5c2e1bd8888206393a8529070bd9090e6f61461c76d95e30be569\", \"children\": [{\"_src_hash\": \"ad5a29d99ea52313b426151280145c99eea54eea28a6f6633bcc171a3f6db20c\", \"desc\": \"交互控件有5种类型，点击控件的按钮后，策略中的{@fun/Global/GetCommand GetCommand}收到一条字符串消息。下表中的变量名只是示例：\\n\\n| 类型 | 变量示例 | 默认值 | ```GetCommand()```收到的消息 |\\n| - | - | - | - |\\n| 数字型（number） | ```cmdNum``` | 选填，可留空 | 输入```123```后点击：```cmdNum:123``` |\\n| 布尔型（true/false） | ```cmdBool``` | 必选，开启或关闭 | 开关打开时点击：```cmdBool:true``` |\\n| 字符串（string） | ```cmdStr``` | 选填，可留空 | 输入```abc```后点击：```cmdStr:abc``` |\\n| 下拉框（selected） | ```cmdCombox``` | 选填，可留空 | 选中第二个选项后点击：```cmdCombox:1```（选项索引，从0开始） |\\n| 按钮（button） | ```cmdBtn``` | 不绑定输入项 | 点击：```cmdBtn``` |\\n\\n消息的格式是```变量名:值```，按钮只有变量名。交互控件的描述、备注、组件配置与策略参数相同，见{@编写策略/策略参数/界面参数种类界面参数种类}和{@编写策略/策略参数/组件配置组件配置}。\\n\\n### 示例：用交互控件动态修改策略参数\\n\\n在策略编辑页面的「策略交互」中添加一个字符串类型的交互控件，变量名为```changeSymbol```。交互控件的设置界面：\\n\\n![设置交互控件](/upload/asset/1741a2b35e569c5e07e3.png)\\n\\n实盘运行时，在该控件的输入框中填入```ETH_USDT```并点击按钮，```GetCommand()```会收到消息```changeSymbol:ETH_USDT```。策略检测到这条消息后更新对应的变量（策略界面上的参数也是全局变量，这里用代码中的全局变量演示）：\\n\\n```javascript\\n// 策略参数\\nvar symbol = \\\"BTC_USDT\\\"\\n\\nfunction main() {\\n while (true) {\\n var cmd = GetCommand()\\n if (cmd) {\\n var arr = cmd.split(\\\":\\\")\\n if (arr.length == 2 && arr[0] == \\\"changeSymbol\\\") {\\n // 检测到 changeSymbol 控件触发，更新参数\\n Log(\\\"symbol参数改为：\\\", arr[1])\\n symbol = arr[1]\\n }\\n }\\n\\n LogStatus(_D(), \\\"，当前symbol参数：\\\", symbol)\\n Sleep(3000)\\n }\\n}\\n```\", \"title\": \"交互控件种类\"}, {\"_src_hash\": \"0231ff148afb4598b70a0f11c52c6a885ade1db3f02f24b64830841fe0ab6f48\", \"desc\": \"除了在「策略交互」栏中设计交互控件，还可以在策略状态栏中输出交互控件。状态栏中目前只支持按钮，按钮与输入控件的全部字段、点击后{@fun/Global/GetCommand GetCommand}收到的命令格式见{@fun/Log/LogStatus LogStatus}的「状态栏按钮」，本页只介绍常见写法。\\n\\n状态栏中的按钮分为三种：\\n- 普通按钮：点击后弹出确认框，确认后策略收到```cmd```。\\n ```json\\n {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"平仓|Close\\\", \\\"cmd\\\": \\\"close\\\",\\n \\\"description\\\": \\\"平掉全部持仓|close all positions\\\"}\\n ```\\n- 带一个输入控件的按钮：用```input```设置输入控件，策略收到```cmd:输入值```。\\n ```json\\n {\\n \\\"type\\\": \\\"button\\\",\\n \\\"name\\\": \\\"开仓|Open\\\",\\n \\\"cmd\\\": \\\"open\\\",\\n \\\"input\\\": {\\\"type\\\": \\\"number\\\", \\\"name\\\": \\\"amount\\\", \\\"label\\\": \\\"开仓数量|amount\\\",\\n \\\"default\\\": 1, \\\"required\\\": true}\\n }\\n ```\\n- 带一组输入控件的按钮：用```group```设置一组输入控件，策略收到```cmd:JSON```，键为各控件的```name```。下例中「价格」控件只在下单方式选「限价单」时显示：\\n ```json\\n {\\n \\\"type\\\": \\\"button\\\",\\n \\\"cmd\\\": \\\"order\\\",\\n \\\"name\\\": \\\"下单|Order\\\",\\n \\\"group\\\": [\\n {\\\"type\\\": \\\"selected\\\", \\\"name\\\": \\\"orderType\\\", \\\"label\\\": \\\"下单方式|order type\\\", \\\"default\\\": 0,\\n \\\"settings\\\": {\\\"options\\\": [\\\"市价单|market\\\", \\\"限价单|limit\\\"]}},\\n {\\\"type\\\": \\\"number\\\", \\\"name\\\": \\\"price\\\", \\\"label\\\": \\\"价格|price\\\",\\n \\\"settings\\\": {\\\"filter\\\": \\\"orderType==1\\\"}},\\n {\\\"type\\\": \\\"number\\\", \\\"name\\\": \\\"amount\\\", \\\"label\\\": \\\"数量|amount\\\", \\\"default\\\": 1,\\n \\\"required\\\": true}\\n ]\\n }\\n ```\\n\\n写这些控件时注意：\\n- 显示条件写在```settings.filter```里（例如```\\\"filter\\\": \\\"orderType==1\\\"```），引用同一组中其它控件的```name```；写在控件顶层的```filter```不起作用。\\n- 必填写在控件顶层（```\\\"required\\\": true```）；写在```settings```里的```required```不起作用。\\n- 状态栏的每一行只能有一段用``` ` ```包裹的JSON。多个按钮要分行输出，或者放进状态栏表格（一个单元格放多个按钮时写成按钮数组）。\\n- 文字支持中英文双语，写作```\\\"中文|English\\\"```，按页面语言显示。\\n\\n输出时把按钮对象编码成JSON字符串，用``` ` ```包裹后传给```LogStatus()```。以JavaScript为例：\\n\\n```javascript\\nfunction main() {\\n var btnClose = {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"平仓|Close\\\", \\\"cmd\\\": \\\"close\\\"}\\n var btnOpen = {\\n \\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"开仓|Open\\\", \\\"cmd\\\": \\\"open\\\",\\n \\\"input\\\": {\\\"type\\\": \\\"number\\\", \\\"name\\\": \\\"amount\\\", \\\"label\\\": \\\"开仓数量|amount\\\", \\\"default\\\": 1}\\n }\\n // 每行一段JSON：两个按钮分两行输出\\n LogStatus(\\\"`\\\" + JSON.stringify(btnClose) + \\\"`\\\\n`\\\" + JSON.stringify(btnOpen) + \\\"`\\\")\\n while (true) {\\n var cmd = GetCommand()\\n if (cmd) {\\n Log(\\\"收到命令：\\\", cmd) // \\\"close\\\", \\\"open:2\\\"\\n }\\n Sleep(1000)\\n }\\n}\\n```\\n\\n把按钮放进状态栏表格、按钮的颜色与尺寸（```class```）、下拉框多选与自定义选项、滑动条和日期选择等控件外观，见{@fun/Log/LogStatus LogStatus}。\", \"title\": \"状态栏中的交互控件\"}], \"desc\": \"```JavaScript```、```Python```、```Rust```、My语言策略可以设计交互控件，策略的交互控件用来在策略实盘运行时给运行的策略程序发送交互指令。对于```JavaScript```、```Python```、```Rust```语言类型的策略，在策略代码中使用 {@fun/Global/GetCommand GetCommand} 函数获取交互控件产生的消息。交互控件的「组件配置」与策略参数相同，见 {@编写策略/策略参数/组件配置组件配置}。\\n\\n![交互控件](/upload/asset/2e4320d0cc33c15eb935d.png)\\n\\n在策略中设计好处理交互控件消息的代码，在实盘时使用交互控件可以实现（不限于）诸如以下功能：\\n- 手动平掉策略持仓。\\n- 动态修改策略参数，避免重启策略实盘。\\n- 切换策略逻辑。\\n- 触发打印某些调试信息、数据，用来测试某些功能。\", \"title\": \"交互控件\"}, {\"_src_hash\": \"133ba430c45ba605bc3bafec6f13b27f37368c87ddc801288180ac48f35fffc7\", \"children\": [{\"_src_hash\": \"701e5bd7639104e25ac4fec9c0f944b43f9ab3c755c0b5a10c29662d142a59d5\", \"desc\": \"导出函数是模板类库对外提供的接口，引用该模板类库的策略可以调用它们；各语言的导出方式见{@编写策略/模板类库模板类库}。\", \"examples\": [{\"examples\": [{\"code\": \"/*\\n-- 策略引用该模板以后直接用 $.Test() 调用此方法\\n-- main 函数在策略中不会执行，只作为调试模板的入口\\n*/\\n$.Test = function() {\\n Log('Test')\\n}\\n\\nfunction main() {\\n $.Test()\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def Test():\\n Log(\\\"template call\\\")\\n\\n# 导出Test函数，策略可以通过ext.Test()调用\\next.Test = Test\", \"lang\": \"python\"}, {\"code\": \"// 策略引用该模板以后直接用 ext::Test() 调用此函数\\n// 供策略调用的函数必须声明为 pub\\npub fn Test() {\\n Log!(\\\"template call\\\");\\n}\", \"lang\": \"rust\"}], \"value\": \"各语言在模板类库中声明并实现导出函数```Test```。\"}], \"title\": \"模板类库的导出函数\"}, {\"_src_hash\": \"be30af4657cee374b511e85eb782c8e8c1f909be978542b4c738781072f6f555\", \"desc\": \"模板类库也可以设置自己的界面参数，模板类库的参数在模板类库代码中是以全局变量的形式使用的（Rust 中为全局常量）。例如给模板类库设置一个参数：\\n\\n![模板参数](/upload/asset/2e4ab550b85e6a1cac08e.png)\\n\\n| 策略代码中参数的变量名 | 策略界面上显示的参数名称 | 类型 | 默认值 |\\n| - | - | - | - |\\n| param1 | 模板参数1 | 数字型（number） | 99 |\\n\\n下面的示例中，模板导出读取、修改参数的函数，策略调用它们。```Rust```模板的参数是常量，只能读取，不能修改，所以 Rust 中只能实现读取参数：\\n\\n```rust\\n// 模板代码\\npub fn GetParam1() -> f64 {\\n Log!(\\\"param1:\\\", param1);\\n param1\\n}\\n```\\n\\n```rust\\n// 策略代码\\nfn main() {\\n Log!(\\\"调用 ext::GetParam1:\\\", ext::GetParam1());\\n}\\n```\", \"examples\": [{\"examples\": [{\"code\": \"$.SetParam1 = function(p1) {\\n param1 = p1\\n}\\n\\n$.GetParam1 = function() {\\n Log(\\\"param1:\\\", param1)\\n return param1\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def SetParam1(p1):\\n global param1\\n param1 = p1\\n\\ndef GetParam1():\\n Log(\\\"param1:\\\", param1)\\n return param1\\n\\next.SetParam1 = SetParam1\\next.GetParam1 = GetParam1\", \"lang\": \"python\"}], \"value\": \"模板类库代码：导出读取和修改```param1```参数的函数。\"}, {\"examples\": [{\"code\": \"function main () {\\n Log(\\\"调用 $.GetParam1:\\\", $.GetParam1())\\n Log(\\\"调用 $.SetParam1\\\", \\\"#FF0000\\\")\\n $.SetParam1(20)\\n Log(\\\"调用 $.GetParam1:\\\", $.GetParam1())\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n Log(\\\"调用 ext.GetParam1:\\\", ext.GetParam1())\\n Log(\\\"调用 ext.SetParam1\\\", \\\"#FF0000\\\")\\n ext.SetParam1(20)\\n Log(\\\"调用 ext.GetParam1:\\\", ext.GetParam1())\", \"lang\": \"python\"}], \"value\": \"引用上面模板类库的策略代码：用导出函数读取、修改```param1```参数。\"}], \"title\": \"模板类库的参数\"}, {\"_src_hash\": \"7c36c7f9ab41a47ad0fdc24bdae20408883fc51ebc04cfdb93bb6e3453cf6f83\", \"desc\": \"策略引用模板类库时，需要当前登录的发明者量化交易平台账号的策略库中存在可用的模板类库。在[策略编辑页面](https://www.fmz.com/m/add-strategy)的模板栏中勾选需要引用的模板，保存策略后即可完成引用。\\n\\n![模板引用截图](/upload/asset/2e4ee2ec7b3e7b1649af8.png)\", \"title\": \"引用模板类库\"}], \"desc\": \"发明者量化交易平台中可复用的代码模块，是策略代码的一种类别。支持模板类库的语言有：```JavaScript```、```Python```、```Rust```。创建策略时如果类别设置为模板类库，会在当前登录账号的策略库中创建一个模板类库，创建后不能再修改类别为普通策略。\\n\\n![创建模板类库页面](/upload/asset/2e4c55da99fd457ca94a0.png)\\n\\n各语言中导出、调用模板函数的方式：\\n\\n| 语言 | 模板中导出 | 策略中调用 |\\n| - | - | - |\\n| JavaScript | 挂到```$```上：```$.Test = function() {...}``` | ```$.Test()``` |\\n| Python | 挂到```ext```上：```ext.Test = Test``` | ```ext.Test()``` |\\n| Rust | 模板代码并入```ext```模块，供策略调用的函数声明为```pub fn``` | ```ext::Test()``` |\\n\\n- 模板中的```main()```函数在策略中不会执行，只作为单独回测、调试模板时的入口。\\n- ```JavaScript```模板可以定义```init()```和```destroy()```：```init()```在模板加载时执行（早于策略的```init()```），```destroy()```在策略退出时、```onexit()```或```onerror()```之后执行。```Python```模板可以定义```init()```，在模板加载时执行。\\n- ```Rust```模板和策略都可以用 frontmatter 声明第三方 crate，但依赖块只能写在其中一处，两处都写会编译失败。\", \"title\": \"模板类库\"}, {\"_src_hash\": \"682537dcabc3bebd13d952ef41f83c251aa351a300b2f935d4bd8370149eee7c\", \"children\": [], \"desc\": \"策略可以直接使用平台内置的```TA```、```talib```指标库和各语言的JSON支持，不需要另外引入。各语言可用情况：\\n\\n| 库 | JavaScript | Python | Rust |\\n| - | - | - | - |\\n| ```TA```指标库 | ✓ | ✓ | ✓ |\\n| ```talib```指标库 | ✓ | ✓（需在托管者所在机器安装 TA-Lib 和 numpy） | ✗ |\\n| JSON | 语言内置```JSON``` | 标准库```json``` | ```JSONParse()```/```JsonValue``` |\\n\\n完整的函数列表与参数见手册 {@fun/TA TA}、{@fun/Talib Talib}。\\n\\n### TA指标库\\n\\n平台的```TA```指标库优化了常用指标算法（[开源TA库代码](https://www.fmz.com/bbs-topic/409)）。K 线数量不足以计算指标时，对应位置返回无效值。\\n\\n```javascript\\nfunction main(){\\n var records = exchange.GetRecords()\\n if (!records) {\\n return\\n }\\n var macd = TA.MACD(records)\\n var atr = TA.ATR(records, 14)\\n\\n // 打印最后一组指标值\\n Log(macd[0][records.length-1], macd[1][records.length-1], macd[2][records.length-1])\\n Log(atr[atr.length-1])\\n}\\n```\\n\\n```rust\\nfn main() {\\n let r = exchange.GetRecords(None, None, None).unwrap();\\n let macd = TA.MACD(&r, None, None, None);\\n let atr = TA.ATR(&r, 14);\\n Log!(macd[0][r.len() - 1], macd[1][r.len() - 1], macd[2][r.len() - 1]);\\n Log!(atr[atr.len() - 1]);\\n}\\n```\\n\\n### talib指标库\\n\\n```javascript\\nfunction main() {\\n var records = exchange.GetRecords()\\n if (!records) {\\n return\\n }\\n var cci = talib.CCI(records, 14)\\n Log(cci)\\n}\\n```\\n\\n```python\\n# Python 需要在托管者所在机器安装 TA-Lib 与 numpy，未安装时调用 talib 会报错提示安装\\ndef main():\\n records = exchange.GetRecords()\\n if not records:\\n return\\n cci = talib.CCI(records.High, records.Low, records.Close, 14)\\n Log(cci)\\n```\\n\\n### JavaScript：动态加载第三方库\\n\\n其它第三方 JavaScript 库可以在运行时下载后用```eval```加载：\\n\\n```javascript\\nfunction main() {\\n // via. https://cdnjs.com/libraries\\n eval(HttpQuery(\\\"https://cdnjs.cloudflare.com/ajax/libs/mathjs/13.2.0/math.min.js\\\"))\\n\\n Log(math.round(math.e, 3)) // 2.718\\n Log(math.atan2(3, -3) / math.pi) // 0.75\\n Log(math.log(10000, 10)) // 4\\n Log(math.sqrt(-4)) // {\\\"mathjs\\\":\\\"Complex\\\",\\\"re\\\":0,\\\"im\\\":2}\\n}\\n```\", \"title\": \"内置库\"}, {\"_src_hash\": \"c9ae46bffb9e02fcec44f247b1e2822078092bae0ba780ed49a3ce4414e3e768\", \"children\": [], \"desc\": \"策略界面上的文字可以同时写中文和英文，网页按当前语言显示其中一种，切换语言后刷新网页生效：\\n- 策略名称、策略参数的描述：写成```中文|英文```。\\n- 策略描述、使用说明等```Markdown```文本：写成```[trans]中文|英文[/trans]```或```[trans]中文||英文[/trans]```。\\n- 策略代码中输出字符串的函数，例如```Log()```、```LogStatus()```：写法与```Markdown```文本相同；状态栏按钮的文字直接写```中文|英文```，不加```[trans]```标签。\\n\\n```javascript\\nfunction main() {\\n Log(\\\"[trans]日志|log[/trans]\\\")\\n // 按钮中不用加[trans]标签\\n var btn = {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"平仓|cover\\\",\\n \\\"description\\\": \\\"描述|description\\\"}\\n var table = {\\n type: \\\"table\\\",\\n title: \\\"[trans]操作|option[/trans]\\\",\\n cols: [\\\"[trans]列1|col1[/trans]\\\", \\\"[trans]列2|col2[/trans]\\\", \\\"[trans]操作|option[/trans]\\\"],\\n rows: [\\n [\\\"[trans]比特币|BTC[/trans]\\\", \\\"[trans]以太坊|ETH[/trans]\\\", btn]\\n ]\\n }\\n LogStatus(\\\"[trans]信息|message[/trans]\\\", \\\"\\\\n`\\\" + JSON.stringify(table) + \\\"`\\\")\\n throw \\\"[trans]错误|error[/trans]\\\"\\n}\\n```\\n\\n```python\\nimport json\\n\\ndef main():\\n Log(\\\"[trans]日志|log[/trans]\\\")\\n btn = {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"平仓|cover\\\",\\n \\\"description\\\": \\\"描述|description\\\"}\\n table = {\\n \\\"type\\\": \\\"table\\\",\\n \\\"title\\\": \\\"[trans]操作|option[/trans]\\\",\\n \\\"cols\\\": [\\\"[trans]列1|col1[/trans]\\\", \\\"[trans]列2|col2[/trans]\\\", \\\"[trans]操作|option[/trans]\\\"],\\n \\\"rows\\\": [\\n [\\\"[trans]比特币|BTC[/trans]\\\", \\\"[trans]以太坊|ETH[/trans]\\\", btn]\\n ]\\n }\\n LogStatus(\\\"[trans]信息|message[/trans]\\\", \\\"\\\\n`\\\" + json.dumps(table) + \\\"`\\\")\\n raise Exception(\\\"[trans]错误|error[/trans]\\\")\\n```\\n\\n```rust\\nfn main() {\\n Log!(\\\"[trans]日志|log[/trans]\\\");\\n let table = r#\\\"{\\n \\\"type\\\": \\\"table\\\",\\n \\\"title\\\": \\\"[trans]操作|option[/trans]\\\",\\n \\\"cols\\\": [\\\"[trans]列1|col1[/trans]\\\", \\\"[trans]列2|col2[/trans]\\\", \\\"[trans]操作|option[/trans]\\\"],\\n \\\"rows\\\": [\\n [\\\"[trans]比特币|BTC[/trans]\\\", \\\"[trans]以太坊|ETH[/trans]\\\",\\n {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"平仓|cover\\\",\\n \\\"description\\\": \\\"描述|description\\\"}]\\n ]\\n }\\\"#;\\n LogStatus!(\\\"[trans]信息|message[/trans]\\\", format!(\\\"\\\\n`{}`\\\", table));\\n Panic!(\\\"[trans]错误|error[/trans]\\\");\\n}\\n```\", \"title\": \"界面文字中英文\"}, {\"_src_hash\": \"5eb1b02556928cfdb233f12c21ff731ff5841d39647375c33c9853a6381b98eb\", \"desc\": [\"按API手册的分类列出全部函数、结构体和常量，每项一句话说明，点击名称查看完整文档。本页由```doc_tools/gen_api_index.py```根据手册生成。\\n\\n### 内置函数\\n\\n#### Global\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Global/Version Version} | 返回当前系统版本号。 |\\n| {@fun/Global/IsVirtual IsVirtual} | 用于判断策略的运行环境是否为回测系统。 |\\n| {@fun/Global/GetOS GetOS} | 获取托管者所在设备的操作系统信息。 |\\n| {@fun/Global/GetPid GetPid} | 获取实盘进程的 ID。 |\\n| {@fun/Global/GetMeta GetMeta} | 获取在生成策略注册码时写入的```Meta```值。 |\\n| {@fun/Global/Sleep Sleep} | 休眠函数，使程序暂停运行一段指定的时间。 |\\n| {@fun/Global/Unix Unix} | 获取当前时刻的秒级时间戳。 |\\n| {@fun/Global/UnixNano UnixNano} | 获取当前时刻的纳秒级时间戳。 |\\n| {@fun/Global/_D _D} | 将毫秒时间戳或者```Date```对象转换为时间字符串。 |\\n| {@fun/Global/GetCommand GetCommand} | 获取策略交互命令。 |\\n| {@fun/Global/GetLastError GetLastError} | 获取最近一次的错误信息。 |\\n| {@fun/Global/SetErrorFilter SetErrorFilter} | 过滤错误日志。 |\\n| {@fun/Global/_N _N} | 格式化一个浮点数。 |\\n| {@fun/Global/_C _C} | 重试函数，用于接口容错。 |\\n| {@fun/Global/_Cross _Cross} | 返回数组```arr1```与数组```arr2```的交叉周期数。 |\\n| {@fun/Global/JSON.parse JSON.parse} | 解码（解析）JSON字符串，是ECMAScript标准内建对象```JSON```的方法。 |\\n| {@fun/Global/JSON.stringify JSON.stringify} | 编码JSON字符串，是ECMAScript标准内建对象```JSON```的方法。 |\\n| {@fun/Global/Encode Encode} | 该函数根据传入的参数对数据进行编码。 |\\n| {@fun/Global/MD5 MD5} | 计算参数```data```的 MD5 哈希值。 |\\n| {@fun/Global/UUID UUID} | 创建一个 UUID。 |\\n\\n#### Log\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Log/Log Log} | 输出日志。 |\\n| {@fun/Log/LogStatus LogStatus} | 在回测系统或者实盘页面状态栏输出信息。 |\\n| {@fun/Log/LogProfit LogProfit} | 记录盈亏值，打印盈亏数值并根据盈亏数值绘制收益曲线。 |\\n| {@fun/Log/LogProfitReset LogProfitReset} | 清空所有收益日志及收益图表。 |\\n| {@fun/Log/LogReset LogReset} | 清除日志。 |\\n| {@fun/Log/LogVacuum LogVacuum} | 用于在调用 ```LogReset()``` 函数清除日志后，回收 SQLite 删除数据时所占用的存储空间。 |\\n| {@fun/Log/EnableLog EnableLog} | 启用或禁用订单信息的日志记录。 |\\n| {@fun/Log/Chart Chart} | 自定义图表画图函数。 |\\n| {@fun/Log/KLineChart KLineChart} | 该函数用于使用类似```Pine```语言的画图方式进行策略运行时的自定义画图。 |\\n| {@fun/Log/console.log console.log} | 用于在实盘页面中的「调试信息」栏中输出调试信息。 |\\n| {@fun/Log/console.error console.error} | 用于在实盘页面中的「调试信息」栏中错误输出。 |\\n| {@fun/Log/exchange.Log exchange.Log} | 在日志栏区域输出下单、撤单日志。 |\\n\\n#### Market\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Market/exchange.GetTicker exchange.GetTicker} | 获取现货或合约的Ticker结构，即行情数据；不传```symbol```时取当前设置的交易对、合约代码的行情。 |\\n| {@fun/Market/exchange.GetTickers exchange.GetTickers} | 获取交易所聚合行情数据（Ticker结构的数组）。 |\\n| {@fun/Market/exchange.GetDepth exchange.GetDepth} | 获取当前设置的交易对、合约代码所对应的现货或合约的Depth结构，即订单簿数据。 |\\n| {@fun/Market/exchange.GetTrades exchange.GetTrades} | 获取当前设置的交易对、合约代码所对应的现货或合约的Trade结构数组，即市场的成交数据。 |\\n| {@fun/Market/exchange.GetRecords exchange.GetRecords} | 获取当前设置的交易对、合约代码所对应的现货或合约的Record结构数组，即K线数据。 |\\n| {@fun/Market/exchange.GetMarkets exchange.GetMarkets} | 获取交易所市场信息。 |\\n| {@fun/Market/exchange.GetRawJSON exchange.GetRawJSON} | 获取当前交易所对象（exchange、exchanges）最近一次```rest```请求返回的原始内容。 |\\n| {@fun/Market/exchange.SetData exchange.SetData} | 设置策略运行时所加载的数据。 |\\n| {@fun/Market/exchange.GetData exchange.GetData} | 获取由```exchange.SetData()```函数加载的数据，或外部链接提供的数据。 |\\n\\n#### Trade\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Trade/exchange.Buy exchange.Buy} | 下买单。 |\\n| {@fun/Trade/exchange.Sell exchange.Sell} | 下达卖单。 |\\n| {@fun/Trade/exchange.CreateOrder exchange.CreateOrder} | 下单。 |\\n| {@fun/Trade/exchange.ModifyOrder exchange.ModifyOrder} | 修改现有的普通订单，可以修改订单的价格和数量。 |\\n| {@fun/Trade/exchange.CancelOrder exchange.CancelOrder} | 取消订单。 |\\n| {@fun/Trade/exchange.GetOrder exchange.GetOrder} | 获取订单信息。 |\\n| {@fun/Trade/exchange.GetOrders exchange.GetOrders} | 获取当前未完成的订单。 |\\n| {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders} | 获取当前交易对、合约的历史订单，并支持指定具体的交易品种。 |\\n| {@fun/Trade/exchange.CreateConditionOrder exchange.CreateConditionOrder} | 创建条件单。 |\\n| {@fun/Trade/exchange.ModifyConditionOrder exchange.ModifyConditionOrder} | 修改现有的条件单，可以修改条件单的数量、触发条件和执行价格。 |\\n| {@fun/Trade/exchange.CancelConditionOrder exchange.CancelConditionOrder} | 取消条件单。 |\\n| {@fun/Trade/exchange.GetConditionOrder exchange.GetConditionOrder} | 获取指定条件单的信息。 |\\n| {@fun/Trade/exchange.GetConditionOrders exchange.GetConditionOrders} | 获取未完成的条件单（尚未触发或尚未取消的条件单）。 |\\n| {@fun/Trade/exchange.GetHistoryConditionOrders exchange.GetHistoryConditionOrders} | 获取当前交易对、合约的历史条件单（包括已触发、已取消、已过期的条件单），并支持指定具体的交易品种。 |\\n\\n#### Account\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Account/exchange.GetAccount exchange.GetAccount} | 请求交易所账户信息。 |\\n| {@fun/Account/exchange.GetAssets exchange.GetAssets} | 请求交易所账户的资产信息。 |\\n\\n#### Futures\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Futures/exchange.SetContractType exchange.SetContractType} | 设置exchange交易所对象当前的合约代码。 |\\n| {@fun/Futures/exchange.GetContractType exchange.GetContractType} | 获取exchange交易所对象当前设置的合约代码。 |\\n| {@fun/Futures/exchange.SetDirection exchange.SetDirection} | 设置调用exchange.Buy函数、exchange.Sell函数进行期货合约下单时的订单方向。 |\\n| {@fun/Futures/exchange.SetMarginLevel exchange.SetMarginLevel} | 设置```symbol```参数所指定的交易对、合约的杠杆值。 |\\n| {@fun/Futures/exchange.GetPositions exchange.GetPositions} | 获取持仓信息。 |\\n| {@fun/Futures/exchange.GetFundings exchange.GetFundings} | 获取当前周期资金费率数据。 |\\n\\n#### Exchange\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Exchange/exchange.GetName exchange.GetName} | 获取当前交易所对象所绑定的交易所名称。 |\\n| {@fun/Exchange/exchange.GetLabel exchange.GetLabel} | 获取配置交易所对象时设置的自定义标签。 |\\n| {@fun/Exchange/exchange.GetCurrency exchange.GetCurrency} | 获取当前设置的交易对。 |\\n| {@fun/Exchange/exchange.SetCurrency exchange.SetCurrency} | 切换交易所对象exchange当前的交易对。 |\\n| {@fun/Exchange/exchange.GetQuoteCurrency exchange.GetQuoteCurrency} | 获取当前交易对的计价币名称，即```quoteCurrency```。 |\\n| {@fun/Exchange/exchange.GetPeriod exchange.GetPeriod} | 获取回测或实盘运行策略时，在发明者量化交易平台网站页面上所设置的 K 线周期，即调用 ```exchange.GetRecords()``` 函数且不传入参数时使用的默认 K 线周期。 |\\n| {@fun/Exchange/exchange.SetMaxBarLen exchange.SetMaxBarLen} | 设置K线的最大长度。 |\\n| {@fun/Exchange/exchange.SetPrecision exchange.SetPrecision} | 设置```exchange```交易所对象的价格与下单量的精度，设置后系统会自动忽略数据中超出精度的多余部分。 |\\n| {@fun/Exchange/exchange.GetRate exchange.GetRate} | 获取交易所对象当前设置的汇率。 |\\n| {@fun/Exchange/exchange.SetRate exchange.SetRate} | 设置交易所对象当前的汇率。 |\\n| {@fun/Exchange/exchange.SetBase exchange.SetBase} | 设置exchange交易所对象所使用的交易所API接口基地址。 |\\n| {@fun/Exchange/exchange.GetBase exchange.GetBase} | 获取当前交易所 API 接口的基础地址。 |\\n| {@fun/Exchange/exchange.SetProxy exchange.SetProxy} | 设置exchange交易所对象的代理配置。 |\\n| {@fun/Exchange/exchange.SetTimeout exchange.SetTimeout} | 设置exchange交易所对象```rest```请求的超时时间。 |\\n| {@fun/Exchange/exchange.Encode exchange.Encode} | 签名加密计算。 |\\n\\n#### IO\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/IO/exchange.IO exchange.IO} | 调用交易所对象相关的其它接口。 |\\n| ```exchange.IO(\\\"api\\\", ...)``` | 调用交易所未封装的原始REST接口，签名由平台自动处理。 |\\n| ```exchange.IO(\\\"currency\\\", ...)``` | 在运行时切换交易所对象的当前交易对。 |\\n| ```exchange.IO(\\\"base\\\", ...)``` | 查询或切换交易所接口的基地址。 |\\n| ```exchange.IO(mode, value)``` | 切换交易所的交易模式：模拟盘/实盘、全仓/逐仓、双向/单向持仓、统一账户、杠杆模式、自成交预防等。 |\\n| ```exchange.IO(\\\"rate\\\", ...)``` | 按函数限制API函数的调用频率：```rate```为平滑限流，```quota```为额度限流。 |\\n\\n#### Network\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Network/HttpQuery HttpQuery} | 发送Http请求。 |\\n| {@fun/Network/HttpQuery_Go HttpQuery_Go} | 发送Http请求，```HttpQuery```函数的异步版本。 |\\n| {@fun/Network/Dial Dial} | 用于原始的```Socket```访问，支持```tcp```、```tls```（也可写作```ssl```）协议，以及WebSocket的```ws```、```wss```协议。 |\\n| {@fun/Network/Mail Mail} | 发送邮件。 |\\n| {@fun/Network/Mail_Go Mail_Go} | ```Mail```函数的异步版本。 |\\n\\n#### Storage\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Storage/_G _G} | 持久化保存数据。 |\\n| {@fun/Storage/DBExec DBExec} | 数据库接口函数。 |\\n| {@fun/Storage/SetChannelData SetChannelData} | 在频道上发布最新的状态数据。 |\\n| {@fun/Storage/GetChannelData GetChannelData} | 订阅指定实盘的频道数据。 |\\n\\n#### Threads\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/exchange.Go exchange.Go} | 多线程异步支持函数，可以把所有支持的函数的操作变成异步并发执行。 |\\n| {@fun/Threads/EventLoop EventLoop} | 监听事件，在有任意```WebSocket```可读数据或者```exchange.Go()```、```HttpQuery_Go()```等并发的任务完成以后返回。 |\\n| {@fun/Threads/ctx.subscribe ctx.subscribe} | 订阅某个账户上一个品种的行情推送，或账户的订单回报，返回事件流ID。 |\\n| {@fun/Threads/ctx.poll ctx.poll} | 取出下一条订阅事件，可以设置等待超时。 |\\n| {@fun/Threads/ctx.book ctx.book} | 读取托管者维护的订单簿。 |\\n\\n#### Threads/threading\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/threading/Thread threading.Thread} | 创建并发线程。 |\\n| {@fun/Threads/threading/getThread threading.getThread} | 根据指定的线程ID获取线程对象。 |\\n| {@fun/Threads/threading/mainThread threading.mainThread} | 获取主线程的线程对象，即策略中```main()```函数所在的线程。 |\\n| {@fun/Threads/threading/currentThread threading.currentThread} | 获取当前线程的线程对象。 |\\n| {@fun/Threads/threading/Lock threading.Lock} | 创建线程锁对象。 |\\n| {@fun/Threads/threading/Condition threading.Condition} | 创建一个条件变量对象，该对象用于在多线程并发环境中实现线程间的同步与通信。 |\\n| {@fun/Threads/threading/Event threading.Event} | 创建一个*线程事件*对象，该对象用于线程间的同步，允许一个线程等待另一个线程的通知或信号。 |\\n| {@fun/Threads/threading/Dict threading.Dict} | 创建一个字典对象，用于在并发线程间传递和共享数据。 |\\n| {@fun/Threads/threading/Serve threading.Serve} | 在策略进程内创建Http服务、TCP服务、Websocket服务（基于Http协议），返回Server对象。 |\\n| {@fun/Threads/threading/pending threading.pending} | 获取当前策略程序中正在运行的并发线程数量。 |\\n\\n#### Threads/Thread\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/Thread/peekMessage Thread.peekMessage} | 从线程接收消息。 |\\n| {@fun/Threads/Thread/postMessage Thread.postMessage} | 向线程发送消息。 |\\n| {@fun/Threads/Thread/join Thread.join} | 等待线程退出，并回收系统资源。 |\\n| {@fun/Threads/Thread/terminate Thread.terminate} | 强制终止线程，释放创建线程时占用的硬件资源。 |\\n| {@fun/Threads/Thread/getData Thread.getData} | 访问线程环境中记录的变量。 |\\n| {@fun/Threads/Thread/setData Thread.setData} | 在线程环境中存储变量。 |\\n| {@fun/Threads/Thread/id Thread.id} | 返回当前多线程对象实例的```threadId```。 |\\n| {@fun/Threads/Thread/name Thread.name} | 返回当前多线程对象实例的名称。 |\\n| {@fun/Threads/Thread/eventLoop Thread.eventLoop} | 监听当前线程（调用者所在线程）接收到的事件。 |\\n\\n#### Threads/ThreadLock\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/ThreadLock/acquire ThreadLock.acquire} | 请求线程锁（加锁）。 |\\n| {@fun/Threads/ThreadLock/release ThreadLock.release} | 释放线程锁（解锁）。 |\\n\\n#### Threads/ThreadEvent\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/ThreadEvent/set ThreadEvent.set} | 设置事件信号。 |\\n| {@fun/Threads/ThreadEvent/clear ThreadEvent.clear} | 清除信号。 |\\n| {@fun/Threads/ThreadEvent/wait ThreadEvent.wait} | 设置事件（信号）等待，在事件（信号）被设置之前会阻塞；支持设置超时参数。 |\\n| {@fun/Threads/ThreadEvent/isSet ThreadEvent.isSet} | 判断事件（信号）是否已被设置。 |\\n\\n#### Threads/ThreadCondition\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/ThreadCondition/notify ThreadCondition.notify} | 唤醒一个正在等待的线程（如果存在）。 |\\n| {@fun/Threads/ThreadCondition/notifyAll ThreadCondition.notifyAll} | 唤醒所有正在等待的线程。 |\\n| {@fun/Threads/ThreadCondition/wait ThreadCondition.wait} | 在特定条件下使线程进入等待状态。 |\\n| {@fun/Threads/ThreadCondition/acquire ThreadCondition.acquire} | 请求线程锁（加锁）。 |\\n| {@fun/Threads/ThreadCondition/release ThreadCondition.release} | 释放线程锁（解锁）。 |\\n\\n#### Threads/ThreadDict\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/ThreadDict/get ThreadDict.get} | 获取字典对象中记录的键值。 |\\n| {@fun/Threads/ThreadDict/set ThreadDict.set} | 设置键值对。 |\\n\\n#### Threads/Server\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Threads/Server/addr Server.addr} | 返回服务实际监听的地址和端口。 |\\n| {@fun/Threads/Server/close Server.close} | 停止接收新连接，正在执行的处理函数继续执行完（优雅关闭）。 |\\n| {@fun/Threads/Server/stop Server.stop} | 先关闭服务（同```close()```），再强制结束所有正在执行的处理函数线程。 |\\n| {@fun/Threads/Server/join Server.join} | 等待服务关闭且所有处理函数执行完毕。 |\\n| {@fun/Threads/Server/pending Server.pending} | 返回当前正在执行的处理函数数量，即正在处理的连接或请求数。 |\\n\\n#### TA\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/TA/TA.MACD TA.MACD} | 计算指数平滑异同移动平均线（MACD）指标。 |\\n| {@fun/TA/TA.KDJ TA.KDJ} | 计算随机指标（KDJ）。 |\\n| {@fun/TA/TA.RSI TA.RSI} | 计算相对强弱指标（RSI）。 |\\n| {@fun/TA/TA.ATR TA.ATR} | 计算平均真实波幅指标（ATR）。 |\\n| {@fun/TA/TA.OBV TA.OBV} | 计算能量潮指标（OBV）。 |\\n| {@fun/TA/TA.MA TA.MA} | 计算移动平均线指标（Moving Average）。 |\\n| {@fun/TA/TA.EMA TA.EMA} | 计算指数移动平均线（EMA）指标。 |\\n| {@fun/TA/TA.BOLL TA.BOLL} | 计算布林带指标。 |\\n| {@fun/TA/TA.Alligator TA.Alligator} | 计算鳄鱼线指标（Alligator）。 |\\n| {@fun/TA/TA.CMF TA.CMF} | 计算蔡金资金流量指标（Chaikin Money Flow）。 |\\n| {@fun/TA/TA.Highest TA.Highest} | 计算周期内最高价。 |\\n| {@fun/TA/TA.Lowest TA.Lowest} | 计算周期最低价。 |\\n| {@fun/TA/TA.SMA TA.SMA} | 计算简单移动平均线（SMA）指标。 |\\n\\n#### Talib/OverlapStudies\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/OverlapStudies/talib.ACCBANDS talib.ACCBANDS} | 计算加速带（Acceleration Bands），返回上轨、中轨、下轨。 |\\n| {@fun/Talib/OverlapStudies/talib.BBANDS talib.BBANDS} | 计算布林带（Bollinger Bands），返回上轨、中轨、下轨。 |\\n| {@fun/Talib/OverlapStudies/talib.DEMA talib.DEMA} | 计算双重指数移动平均线（Double Exponential Moving Average）。 |\\n| {@fun/Talib/OverlapStudies/talib.EMA talib.EMA} | 计算指数移动平均线（Exponential Moving Average）。 |\\n| {@fun/Talib/OverlapStudies/talib.HT_TRENDLINE talib.HT_TRENDLINE} | 计算希尔伯特变换瞬时趋势线（Hilbert Transform - Instantaneous Trendline）。 |\\n| {@fun/Talib/OverlapStudies/talib.KAMA talib.KAMA} | 计算考夫曼自适应移动平均线（Kaufman Adaptive Moving Average）。 |\\n| {@fun/Talib/OverlapStudies/talib.MA talib.MA} | 计算移动平均线（Moving Average）。 |\\n| {@fun/Talib/OverlapStudies/talib.MAMA talib.MAMA} | 计算MESA自适应移动平均线（MESA Adaptive Moving Average），返回MAMA、FAMA。 |\\n| {@fun/Talib/OverlapStudies/talib.MAVP talib.MAVP} | 计算可变周期移动平均线（Moving Average with Variable Period）。 |\\n| {@fun/Talib/OverlapStudies/talib.MIDPOINT talib.MIDPOINT} | 计算周期中点（MidPoint over Period）。 |\\n| {@fun/Talib/OverlapStudies/talib.MIDPRICE talib.MIDPRICE} | 计算周期中点价格（Midpoint Price over Period）。 |\\n| {@fun/Talib/OverlapStudies/talib.SAR talib.SAR} | 计算抛物线转向指标（Parabolic SAR）。 |\\n| {@fun/Talib/OverlapStudies/talib.SAREXT talib.SAREXT} | 计算扩展抛物线转向指标（Parabolic SAR - Extended）。 |\\n| {@fun/Talib/OverlapStudies/talib.SMA talib.SMA} | 计算简单移动平均线（Simple Moving Average）。 |\\n| {@fun/Talib/OverlapStudies/talib.T3 talib.T3} | 计算T3三重指数移动平均线（Triple Exponential Moving Average (T3)）。 |\\n| {@fun/Talib/OverlapStudies/talib.TEMA talib.TEMA} | 计算三重指数移动平均线（Triple Exponential Moving Average）。 |\\n| {@fun/Talib/OverlapStudies/talib.TRIMA talib.TRIMA} | 计算三角移动平均线（Triangular Moving Average）。 |\\n| {@fun/Talib/OverlapStudies/talib.WMA talib.WMA} | 计算加权移动平均线（Weighted Moving Average）。 |\\n\\n#### Talib/MomentumIndicators\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/MomentumIndicators/talib.ADX talib.ADX} | 计算平均趋向指数（Average Directional Movement Index）。 |\\n| {@fun/Talib/MomentumIndicators/talib.ADXR talib.ADXR} | 计算平均趋向指数评估（Average Directional Movement Index Rating）。 |\\n| {@fun/Talib/MomentumIndicators/talib.APO talib.APO} | 计算绝对价格振荡指标（Absolute Price Oscillator）。 |\\n| {@fun/Talib/MomentumIndicators/talib.AROON talib.AROON} | 计算阿隆指标（Aroon），返回阿隆下降线、阿隆上升线。 |\\n| {@fun/Talib/MomentumIndicators/talib.AROONOSC talib.AROONOSC} | 计算阿隆振荡指标（Aroon Oscillator）。 |\\n| {@fun/Talib/MomentumIndicators/talib.BOP talib.BOP} | 计算均势指标（Balance Of Power）。 |\\n| {@fun/Talib/MomentumIndicators/talib.CCI talib.CCI} | 计算顺势指标（Commodity Channel Index）。 |\\n| {@fun/Talib/MomentumIndicators/talib.CMO talib.CMO} | 计算钱德动量摆动指标（Chande Momentum Oscillator）。 |\\n| {@fun/Talib/MomentumIndicators/talib.DX talib.DX} | 计算动向指数（Directional Movement Index）。 |\\n| {@fun/Talib/MomentumIndicators/talib.IMI talib.IMI} | 计算日内动量指标（Intraday Momentum Index）。 |\\n| {@fun/Talib/MomentumIndicators/talib.MACD talib.MACD} | 计算指数平滑异同移动平均线（Moving Average Convergence/Divergence），返回MACD线、信号线、柱状线。 |\\n| {@fun/Talib/MomentumIndicators/talib.MACDEXT talib.MACDEXT} | 计算可指定均线类型的MACD（MACD with Controllable MA Type），返回MACD线、信号线、柱状线。 |\\n| {@fun/Talib/MomentumIndicators/talib.MACDFIX talib.MACDFIX} | 计算快慢周期固定为12/26的MACD（Moving Average Convergence/Divergence Fix 12/26），返回MACD线、信号线、柱状线。 |\\n| {@fun/Talib/MomentumIndicators/talib.MFI talib.MFI} | 计算资金流量指标（Money Flow Index）。 |\\n| {@fun/Talib/MomentumIndicators/talib.MINUS_DI talib.MINUS_DI} | 计算下降方向线（Minus Directional Indicator）。 |\\n| {@fun/Talib/MomentumIndicators/talib.MINUS_DM talib.MINUS_DM} | 计算下降动向值（Minus Directional Movement）。 |\\n| {@fun/Talib/MomentumIndicators/talib.MOM talib.MOM} | 计算动量（Momentum）。 |\\n| {@fun/Talib/MomentumIndicators/talib.PLUS_DI talib.PLUS_DI} | 计算上升方向线（Plus Directional Indicator）。 |\\n| {@fun/Talib/MomentumIndicators/talib.PLUS_DM talib.PLUS_DM} | 计算上升动向值（Plus Directional Movement）。 |\\n| {@fun/Talib/MomentumIndicators/talib.PPO talib.PPO} | 计算价格振荡百分比（Percentage Price Oscillator）。 |\\n| {@fun/Talib/MomentumIndicators/talib.ROC talib.ROC} | 计算变动率（Rate of Change），公式为`((price/prevPrice)-1)*100`。 |\\n| {@fun/Talib/MomentumIndicators/talib.ROCP talib.ROCP} | 计算变动率百分比（Rate of Change Percentage），公式为`(price-prevPrice)/prevPrice`。 |\\n| {@fun/Talib/MomentumIndicators/talib.ROCR talib.ROCR} | 计算变动率比值（Rate of Change Ratio），公式为`price/prevPrice`。 |\\n| {@fun/Talib/MomentumIndicators/talib.ROCR100 talib.ROCR100} | 计算百倍变动率比值（Rate of Change Ratio 100 Scale），公式为`(price/prevPrice)*100`。 |\\n| {@fun/Talib/MomentumIndicators/talib.RSI talib.RSI} | 计算相对强弱指标（Relative Strength Index）。 |\\n| {@fun/Talib/MomentumIndicators/talib.STOCH talib.STOCH} | 计算随机指标（Stochastic），返回慢速K、慢速D。 |\\n| {@fun/Talib/MomentumIndicators/talib.STOCHF talib.STOCHF} | 计算快速随机指标（Stochastic Fast），返回快速K、快速D。 |\\n| {@fun/Talib/MomentumIndicators/talib.STOCHRSI talib.STOCHRSI} | 计算随机相对强弱指标（Stochastic Relative Strength Index），返回快速K、快速D。 |\\n| {@fun/Talib/MomentumIndicators/talib.TRIX talib.TRIX} | 计算三重指数平滑平均线变动率（1-day Rate-Of-Change (ROC) of a Triple Smooth EMA）。 |\\n| {@fun/Talib/MomentumIndicators/talib.ULTOSC talib.ULTOSC} | 计算终极振荡指标（Ultimate Oscillator）。 |\\n| {@fun/Talib/MomentumIndicators/talib.WILLR talib.WILLR} | 计算威廉指标（Williams' %R）。 |\\n\\n#### Talib/VolumeIndicators\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/VolumeIndicators/talib.AD talib.AD} | 计算蔡金累积/派发线（Chaikin A/D Line）。 |\\n| {@fun/Talib/VolumeIndicators/talib.ADOSC talib.ADOSC} | 计算佳庆指标（Chaikin A/D Oscillator）。 |\\n| {@fun/Talib/VolumeIndicators/talib.OBV talib.OBV} | 计算能量潮（On Balance Volume）。 |\\n\\n#### Talib/VolatilityIndicators\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/VolatilityIndicators/talib.ATR talib.ATR} | 计算平均真实波幅（Average True Range）。 |\\n| {@fun/Talib/VolatilityIndicators/talib.NATR talib.NATR} | 计算归一化平均真实波幅（Normalized Average True Range）。 |\\n| {@fun/Talib/VolatilityIndicators/talib.TRANGE talib.TRANGE} | 计算真实波幅（True Range）。 |\\n\\n#### Talib/CycleIndicators\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/CycleIndicators/talib.HT_DCPERIOD talib.HT_DCPERIOD} | 计算希尔伯特变换主导周期（Hilbert Transform - Dominant Cycle Period）。 |\\n| {@fun/Talib/CycleIndicators/talib.HT_DCPHASE talib.HT_DCPHASE} | 计算希尔伯特变换主导周期相位（Hilbert Transform - Dominant Cycle Phase）。 |\\n| {@fun/Talib/CycleIndicators/talib.HT_PHASOR talib.HT_PHASOR} | 计算希尔伯特变换相量分量（Hilbert Transform - Phasor Components），返回同相分量、正交分量。 |\\n| {@fun/Talib/CycleIndicators/talib.HT_SINE talib.HT_SINE} | 计算希尔伯特变换正弦波（Hilbert Transform - SineWave），返回正弦线、超前正弦线。 |\\n| {@fun/Talib/CycleIndicators/talib.HT_TRENDMODE talib.HT_TRENDMODE} | 计算希尔伯特变换趋势与周期模式（Hilbert Transform - Trend vs Cycle Mode）。 |\\n\\n#### Talib/PriceTransform\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/PriceTransform/talib.AVGDEV talib.AVGDEV} | 计算平均绝对偏差（Average Deviation）。 |\\n| {@fun/Talib/PriceTransform/talib.AVGPRICE talib.AVGPRICE} | 计算平均价格（Average Price）。 |\\n| {@fun/Talib/PriceTransform/talib.MEDPRICE talib.MEDPRICE} | 计算中间价（Median Price）。 |\\n| {@fun/Talib/PriceTransform/talib.TYPPRICE talib.TYPPRICE} | 计算典型价格（Typical Price）。 |\\n| {@fun/Talib/PriceTransform/talib.WCLPRICE talib.WCLPRICE} | 计算加权收盘价（Weighted Close Price）。 |\\n\\n#### Talib/StatisticFunctions\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/StatisticFunctions/talib.BETA talib.BETA} | 计算贝塔系数（Beta）。 |\\n| {@fun/Talib/StatisticFunctions/talib.CORREL talib.CORREL} | 计算皮尔逊相关系数（Pearson's Correlation Coefficient (r)）。 |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG talib.LINEARREG} | 计算线性回归（Linear Regression）。 |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG_ANGLE talib.LINEARREG_ANGLE} | 计算线性回归角度（Linear Regression Angle）。 |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG_INTERCEPT talib.LINEARREG_INTERCEPT} | 计算线性回归截距（Linear Regression Intercept）。 |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG_SLOPE talib.LINEARREG_SLOPE} | 计算线性回归斜率（Linear Regression Slope）。 |\\n| {@fun/Talib/StatisticFunctions/talib.STDDEV talib.STDDEV} | 计算标准差（Standard Deviation）。 |\\n| {@fun/Talib/StatisticFunctions/talib.TSF talib.TSF} | 计算时间序列预测（Time Series Forecast）。 |\\n| {@fun/Talib/StatisticFunctions/talib.VAR talib.VAR} | 计算方差（Variance）。 |\\n\\n#### Talib/MathTransform\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/MathTransform/talib.ACOS talib.ACOS} | 逐个元素计算反余弦（Vector Trigonometric ACos）。 |\\n| {@fun/Talib/MathTransform/talib.ASIN talib.ASIN} | 逐个元素计算反正弦（Vector Trigonometric ASin）。 |\\n| {@fun/Talib/MathTransform/talib.ATAN talib.ATAN} | 逐个元素计算反正切（Vector Trigonometric ATan）。 |\\n| {@fun/Talib/MathTransform/talib.CEIL talib.CEIL} | 把每个元素向上取整（Vector Ceil）。 |\\n| {@fun/Talib/MathTransform/talib.COS talib.COS} | 逐个元素计算余弦（Vector Trigonometric Cos）。 |\\n| {@fun/Talib/MathTransform/talib.COSH talib.COSH} | 逐个元素计算双曲余弦（Vector Trigonometric Cosh）。 |\\n| {@fun/Talib/MathTransform/talib.EXP talib.EXP} | 逐个元素计算以e为底的指数（Vector Arithmetic Exp）。 |\\n| {@fun/Talib/MathTransform/talib.FLOOR talib.FLOOR} | 把每个元素向下取整（Vector Floor）。 |\\n| {@fun/Talib/MathTransform/talib.LN talib.LN} | 逐个元素计算自然对数（Vector Log Natural）。 |\\n| {@fun/Talib/MathTransform/talib.LOG10 talib.LOG10} | 逐个元素计算常用对数（Vector Log10）。 |\\n| {@fun/Talib/MathTransform/talib.SIN talib.SIN} | 逐个元素计算正弦（Vector Trigonometric Sin）。 |\\n| {@fun/Talib/MathTransform/talib.SINH talib.SINH} | 逐个元素计算双曲正弦（Vector Trigonometric Sinh）。 |\\n| {@fun/Talib/MathTransform/talib.SQRT talib.SQRT} | 逐个元素计算平方根（Vector Square Root）。 |\\n| {@fun/Talib/MathTransform/talib.TAN talib.TAN} | 逐个元素计算正切（Vector Trigonometric Tan）。 |\\n| {@fun/Talib/MathTransform/talib.TANH talib.TANH} | 逐个元素计算双曲正切（Vector Trigonometric Tanh）。 |\\n\\n#### Talib/MathOperators\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/MathOperators/talib.ADD talib.ADD} | 把两个数组逐个元素相加（Vector Arithmetic Add）。 |\\n| {@fun/Talib/MathOperators/talib.DIV talib.DIV} | 用第一个数组逐个元素除以第二个数组（Vector Arithmetic Div）。 |\\n| {@fun/Talib/MathOperators/talib.MAX talib.MAX} | 计算周期最大值（Highest Value over a Specified Period）。 |\\n| {@fun/Talib/MathOperators/talib.MAXINDEX talib.MAXINDEX} | 计算周期最大值索引（Index of Highest Value over a Specified Period）。 |\\n| {@fun/Talib/MathOperators/talib.MIN talib.MIN} | 计算周期最小值（Lowest Value over a Specified Period）。 |\\n| {@fun/Talib/MathOperators/talib.MININDEX talib.MININDEX} | 计算周期最小值索引（Index of Lowest Value over a Specified Period）。 |\\n| {@fun/Talib/MathOperators/talib.MINMAX talib.MINMAX} | 计算周期最小值和最大值（Lowest and Highest Values over a Specified Period），返回最小值、最大值。 |\\n| {@fun/Talib/MathOperators/talib.MINMAXINDEX talib.MINMAXINDEX} | 计算周期最小值和最大值索引（Indexes of Lowest and Highest Values over a Specified Period），返回最小值索引、最大值索引。 |\\n| {@fun/Talib/MathOperators/talib.MULT talib.MULT} | 把两个数组逐个元素相乘（Vector Arithmetic Mult）。 |\\n| {@fun/Talib/MathOperators/talib.SUB talib.SUB} | 用第一个数组逐个元素减去第二个数组（Vector Arithmetic Subtraction）。 |\\n| {@fun/Talib/MathOperators/talib.SUM talib.SUM} | 计算周期求和（Summation）。 |\\n\\n#### Talib/PatternRecognition\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/Talib/PatternRecognition/talib.CDL2CROWS talib.CDL2CROWS} | 识别两只乌鸦（Two Crows）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDL3BLACKCROWS talib.CDL3BLACKCROWS} | 识别三只乌鸦（Three Black Crows）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDL3INSIDE talib.CDL3INSIDE} | 识别三内部上涨和下跌（Three Inside Up/Down）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDL3LINESTRIKE talib.CDL3LINESTRIKE} | 识别三线打击（Three-Line Strike）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDL3OUTSIDE talib.CDL3OUTSIDE} | 识别三外部上涨和下跌（Three Outside Up/Down）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDL3STARSINSOUTH talib.CDL3STARSINSOUTH} | 识别南方三星（Three Stars In The South）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDL3WHITESOLDIERS talib.CDL3WHITESOLDIERS} | 识别三个白兵（Three Advancing White Soldiers）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLABANDONEDBABY talib.CDLABANDONEDBABY} | 识别弃婴（Abandoned Baby）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLADVANCEBLOCK talib.CDLADVANCEBLOCK} | 识别前进受阻（Advance Block）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLBELTHOLD talib.CDLBELTHOLD} | 识别捉腰带线（Belt-hold）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLBREAKAWAY talib.CDLBREAKAWAY} | 识别脱离（Breakaway）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLCLOSINGMARUBOZU talib.CDLCLOSINGMARUBOZU} | 识别收盘光头光脚线（Closing Marubozu）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLCONCEALBABYSWALL talib.CDLCONCEALBABYSWALL} | 识别藏婴吞没（Concealing Baby Swallow）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLCOUNTERATTACK talib.CDLCOUNTERATTACK} | 识别反击线（Counterattack）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLDARKCLOUDCOVER talib.CDLDARKCLOUDCOVER} | 识别乌云压顶（Dark Cloud Cover）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLDOJI talib.CDLDOJI} | 识别十字星（Doji）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLDOJISTAR talib.CDLDOJISTAR} | 识别跳空十字星（Doji Star）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLDRAGONFLYDOJI talib.CDLDRAGONFLYDOJI} | 识别蜻蜓十字（Dragonfly Doji）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLENGULFING talib.CDLENGULFING} | 识别吞没（Engulfing Pattern）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLEVENINGDOJISTAR talib.CDLEVENINGDOJISTAR} | 识别黄昏十字星（Evening Doji Star）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLEVENINGSTAR talib.CDLEVENINGSTAR} | 识别黄昏之星（Evening Star）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLGAPSIDESIDEWHITE talib.CDLGAPSIDESIDEWHITE} | 识别向上/向下跳空并列阳线（Up/Down-gap side-by-side white lines）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLGRAVESTONEDOJI talib.CDLGRAVESTONEDOJI} | 识别墓碑十字（Gravestone Doji）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHAMMER talib.CDLHAMMER} | 识别锤头线（Hammer）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHANGINGMAN talib.CDLHANGINGMAN} | 识别上吊线（Hanging Man）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHARAMI talib.CDLHARAMI} | 识别母子线（Harami Pattern）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHARAMICROSS talib.CDLHARAMICROSS} | 识别十字孕线（Harami Cross Pattern）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHIGHWAVE talib.CDLHIGHWAVE} | 识别风高浪大线（High-Wave Candle）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHIKKAKE talib.CDLHIKKAKE} | 识别陷阱（Hikkake Pattern）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHIKKAKEMOD talib.CDLHIKKAKEMOD} | 识别修正陷阱（Modified Hikkake Pattern）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLHOMINGPIGEON talib.CDLHOMINGPIGEON} | 识别家鸽（Homing Pigeon）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLIDENTICAL3CROWS talib.CDLIDENTICAL3CROWS} | 识别三胞胎乌鸦（Identical Three Crows）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLINNECK talib.CDLINNECK} | 识别颈内线（In-Neck Pattern）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLINVERTEDHAMMER talib.CDLINVERTEDHAMMER} | 识别倒锤头线（Inverted Hammer）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLKICKING talib.CDLKICKING} | 识别反冲（Kicking）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLKICKINGBYLENGTH talib.CDLKICKINGBYLENGTH} | 识别按较长光头光脚线定方向的反冲（Kicking - bull/bear determined by the longer marubozu）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLLADDERBOTTOM talib.CDLLADDERBOTTOM} | 识别梯底（Ladder Bottom）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLLONGLEGGEDDOJI talib.CDLLONGLEGGEDDOJI} | 识别长脚十字（Long Legged Doji）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLLONGLINE talib.CDLLONGLINE} | 识别长蜡烛线（Long Line Candle）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLMARUBOZU talib.CDLMARUBOZU} | 识别光头光脚线（Marubozu）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLMATCHINGLOW talib.CDLMATCHINGLOW} | 识别相同低价（Matching Low）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLMATHOLD talib.CDLMATHOLD} | 识别铺垫（Mat Hold）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLMORNINGDOJISTAR talib.CDLMORNINGDOJISTAR} | 识别十字晨星（Morning Doji Star）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLMORNINGSTAR talib.CDLMORNINGSTAR} | 识别晨星（Morning Star）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLONNECK talib.CDLONNECK} | 识别颈上线（On-Neck Pattern）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLPIERCING talib.CDLPIERCING} | 识别刺透（Piercing Pattern）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLRICKSHAWMAN talib.CDLRICKSHAWMAN} | 识别黄包车夫（Rickshaw Man）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLRISEFALL3METHODS talib.CDLRISEFALL3METHODS} | 识别上升/下降三法（Rising/Falling Three Methods）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLSEPARATINGLINES talib.CDLSEPARATINGLINES} | 识别分离线（Separating Lines）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLSHOOTINGSTAR talib.CDLSHOOTINGSTAR} | 识别射击之星（Shooting Star）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLSHORTLINE talib.CDLSHORTLINE} | 识别短蜡烛线（Short Line Candle）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLSPINNINGTOP talib.CDLSPINNINGTOP} | 识别纺锤线（Spinning Top）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLSTALLEDPATTERN talib.CDLSTALLEDPATTERN} | 识别停顿（Stalled Pattern）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLSTICKSANDWICH talib.CDLSTICKSANDWICH} | 识别条形三明治（Stick Sandwich）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLTAKURI talib.CDLTAKURI} | 识别探水竿（Takuri (Dragonfly Doji with very long lower shadow)）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLTASUKIGAP talib.CDLTASUKIGAP} | 识别跳空并列阴阳线（Tasuki Gap）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLTHRUSTING talib.CDLTHRUSTING} | 识别插入线（Thrusting Pattern）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLTRISTAR talib.CDLTRISTAR} | 识别三星（Tristar Pattern）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLUNIQUE3RIVER talib.CDLUNIQUE3RIVER} | 识别奇特三河床（Unique 3 River）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLUPSIDEGAP2CROWS talib.CDLUPSIDEGAP2CROWS} | 识别向上跳空的两只乌鸦（Upside Gap Two Crows）K线形态。 |\\n| {@fun/Talib/PatternRecognition/talib.CDLXSIDEGAP3METHODS talib.CDLXSIDEGAP3METHODS} | 识别上升/下降跳空三法（Upside/Downside Gap Three Methods）K线形态。 |\\n\\n#### OS\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/OS/ListFilesResult ListFilesResult} | 文件列表对象，用于记录目录列表信息。 |\\n| {@fun/OS/FileStat FileStat} | 文件统计信息对象。 |\\n\\n#### OS/os\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/OS/os/open os.open} | 以指定模式打开文件。 |\\n| {@fun/OS/os/fgets os.fgets} | 一次性读取整个文件的内容。 |\\n| {@fun/OS/os/fputs os.fputs} | 向文件写入内容。 |\\n| {@fun/OS/os/mmap os.mmap} | 读取整个文件，以 ArrayBuffer 返回文件的二进制数据。 |\\n| {@fun/OS/os/getRootDir os.getRootDir} | 获取文件操作的根目录路径。 |\\n| {@fun/OS/os/listFiles os.listFiles} | 列出目录中的文件和子目录。 |\\n| {@fun/OS/os/exists os.exists} | 检查指定的文件或目录是否存在。 |\\n| {@fun/OS/os/remove os.remove} | 删除指定文件或空目录。 |\\n| {@fun/OS/os/mkdir os.mkdir} | 创建目录。 |\\n| {@fun/OS/os/rmdir os.rmdir} | 删除目录及其所有内容。 |\\n| {@fun/OS/os/rename os.rename} | 重命名文件或移动文件。 |\\n| {@fun/OS/os/stat os.stat} | 获取文件的详细统计信息。 |\\n| {@fun/OS/os/exit os.exit} | 退出程序。 |\\n\\n#### OS/File\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@fun/OS/File/close File.close} | 关闭文件并释放相关资源。 |\\n| {@fun/OS/File/puts File.puts} | 向文件写入一个或多个字符串。 |\\n| {@fun/OS/File/printf File.printf} | 格式化写入数据到文件。 |\\n| {@fun/OS/File/flush File.flush} | 刷新文件缓冲区，确保数据写入磁盘。 |\\n| {@fun/OS/File/tell File.tell} | 获取当前文件指针的位置。 |\\n| {@fun/OS/File/seek File.seek} | 将文件指针移动到指定位置。 |\\n| {@fun/OS/File/eof File.eof} | 检查文件指针是否已到达文件末尾。 |\\n| {@fun/OS/File/read File.read} | 从文件中读取数据。 |\\n| {@fun/OS/File/write File.write} | 向文件写入字符串数据。 |\\n| {@fun/OS/File/getline File.getline} | 从文件中读取下一行内容。 |\\n| {@fun/OS/File/toString File.toString} | 获取文件对象的字符串表示形式。 |\\n\\n### 结构体\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@struct/Ticker Ticker} | ```exchange.GetTicker()```返回的行情：最高价、最低价、卖一价、买一价、最新成交价、开盘价、成交量与持仓量。 |\\n| {@struct/Depth Depth} | ```exchange.GetDepth()```返回的市场深度：卖盘```Asks```、买盘```Bids```（OrderBook数组）与时间戳。 |\\n| {@struct/OrderBook OrderBook} | 市场深度（Depth）里卖盘、买盘的一档：价格与数量。 |\\n| {@struct/Trade Trade} | ```exchange.GetTrades()```返回的市场成交记录：成交Id、时间、价格、数量与方向。 |\\n| {@struct/Record Record} | K线柱的数据结构，标准的OHLC格式，用于绘制K线图和技术指标计算分析。 |\\n| {@struct/Market Market} | ```exchange.GetMarkets()```返回的品种市场信息：交易币与计价币、价格与数量的步长和精度、下单数量与金额的上下限、合约面值。 |\\n| {@struct/Order Order} | ```exchange.GetOrder()```、```exchange.GetOrders()```等返回的订单：订单Id、价格、数量、成交数量、成交均价、状态、方向、开平仓、合约代码与条件单配置。 |\\n| {@struct/Condition Condition} | 条件单的配置：条件单类型，以及止盈、止损的触发价与委托价。 |\\n| {@struct/Account Account} | ```exchange.GetAccount()```返回的账户信息：计价币与交易币的可用、冻结数量，期货另有权益与未实现盈亏。 |\\n| {@struct/Asset Asset} | ```exchange.GetAssets()```返回的数组中的一项：一个币种的可用数量与冻结数量。 |\\n| {@struct/Position Position} | ```exchange.GetPositions()```返回的持仓：品种、杠杆、持仓量与冻结量、持仓均价、浮动盈亏、持仓方向、合约代码与保证金。 |\\n| {@struct/Funding Funding} | ```exchange.GetFundings()```返回的资金费率信息：品种、结算周期、时间与费率；仅加密货币永续合约有资金费率。 |\\n\\n#### OtherStruct\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@struct/OtherStruct/HttpQuery-options HttpQuery-options} | 此JSON结构用于配置HttpQuery函数和HttpQuery_Go函数发送HTTP请求的各项参数。 |\\n| {@struct/OtherStruct/HttpQuery-return HttpQuery-return} | 该JSON结构是调用HttpQuery函数时，在参数```options```结构中将debug字段指定为true后，HttpQuery函数在调试模式下返回的数据结构。 |\\n| {@struct/OtherStruct/LogStatus-table LogStatus-table} | 此JSON结构用于配置策略状态栏中显示的表格内容。 |\\n| {@struct/OtherStruct/LogStatus-btnTypeOne LogStatus-btnTypeOne} | 状态栏按钮JSON结构的旧写法（输入控件不带```settings```），平台仍然兼容；新代码使用LogStatus-btnTypeTwo，字段说明见LogStatus的「状态栏按钮」。 |\\n| {@struct/OtherStruct/LogStatus-btnTypeTwo LogStatus-btnTypeTwo} | 状态栏按钮的JSON结构（当前写法，输入控件带```settings```）。 |\\n| {@struct/OtherStruct/Chart-options Chart-options} | 该JSON用于设置自定义画图函数```Chart()```的图表配置信息，图表库使用的是Highcharts。 |\\n| {@struct/OtherStruct/Chart-return Chart-return} | Chart函数返回的图表对象，用于写入数据、更新配置和清空图表。 |\\n| {@struct/OtherStruct/KLineChart-options KLineChart-options} | 此JSON用于设置自定义绘图函数```KLineChart```的图表配置信息。 |\\n| {@struct/OtherStruct/KLineChart-return KLineChart-return} | KLineChart函数返回的图表对象，以类似```Pine```语言的方式在K线上画图。 |\\n| {@struct/OtherStruct/SetData-data SetData-data} | 该JSON用于设置```exchange.SetData()```函数所要加载的数据。 |\\n| {@struct/OtherStruct/EventLoop-return EventLoop-return} | 该JSON是```EventLoop()```函数返回的数据结构。 |\\n| {@struct/OtherStruct/exchange.Go-return exchange.Go-return} | exchange.Go函数返回的并发对象，用```wait()```方法取得并发调用的结果。 |\\n| {@struct/OtherStruct/DBExec-return DBExec-return} | 该JSON是```DBExec()```函数返回的数据结构；使用```Dial()```函数创建的对象的```exec()```方法执行SQL语句时，也返回此JSON数据结构。 |\\n| {@struct/OtherStruct/Dial-return Dial-return} | Dial函数返回的连接对象。 |\\n| {@struct/OtherStruct/Thread.join-return Thread.join-return} | 该JSON是```Thread```对象的成员函数```join()```返回的数据结构，用于保存```JavaScript```语言策略中并发线程的相关信息。 |\\n\\n### 内置变量与常量\\n\\n#### EXCHANGE\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/EXCHANGE/exchange exchange} | 在策略实盘设置、回测设置中添加的第一个交易所对象。 |\\n| {@var/EXCHANGE/exchanges exchanges} | 交易所对象数组，包含在策略实盘设置或回测设置中添加的所有交易所对象，其中 exchanges[0] 即为 exchange。 |\\n\\n#### ORDER_STATE\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/ORDER_STATE/ORDER_STATE_PENDING ORDER_STATE_PENDING} | 订单未完成（挂单中，可能已部分成交），值为```0```。 |\\n| {@var/ORDER_STATE/ORDER_STATE_CLOSED ORDER_STATE_CLOSED} | 订单已完成（全部成交），值为```1```。 |\\n| {@var/ORDER_STATE/ORDER_STATE_CANCELED ORDER_STATE_CANCELED} | 订单已取消，值为```2```。 |\\n| {@var/ORDER_STATE/ORDER_STATE_UNKNOWN ORDER_STATE_UNKNOWN} | 订单状态未知（其它状态），值为```3```。 |\\n\\n#### ORDER_TYPE\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/ORDER_TYPE/ORDER_TYPE_BUY ORDER_TYPE_BUY} | 买单，值为```0```。 |\\n| {@var/ORDER_TYPE/ORDER_TYPE_SELL ORDER_TYPE_SELL} | 卖单，值为```1```。 |\\n\\n#### ORDER_CONDITION_TYPE\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_OCO ORDER_CONDITION_TYPE_OCO} | OCO订单（One-Cancels-the-Other，二选一）：同时设置止盈和止损条件，其中一个触发后另一个自动取消，值为```0```。 |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_TP ORDER_CONDITION_TYPE_TP} | 止盈单（Take Profit）：价格达到止盈触发价时下单，值为```1```。 |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_SL ORDER_CONDITION_TYPE_SL} | 止损单（Stop Loss）：价格达到止损触发价时下单，用于限制损失，值为```2```。 |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_GENERIC ORDER_CONDITION_TYPE_GENERIC} | 通用条件单：具体行为取决于交易所，只出现在查询结果中，值为```3```。 |\\n\\n#### POSITION_DIRECTION\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/POSITION_DIRECTION/PD_LONG PD_LONG} | 多头持仓，值为```0```。 |\\n| {@var/POSITION_DIRECTION/PD_SHORT PD_SHORT} | 空头持仓，值为```1```。 |\\n\\n#### ORDER_OFFSET\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/ORDER_OFFSET/ORDER_OFFSET_OPEN ORDER_OFFSET_OPEN} | 开仓，值为```0```。 |\\n| {@var/ORDER_OFFSET/ORDER_OFFSET_CLOSE ORDER_OFFSET_CLOSE} | 平仓，值为```1```。 |\\n\\n#### PERIOD\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/PERIOD/PERIOD_M1 PERIOD_M1} | 1分钟K线周期，值为```60```。 |\\n| {@var/PERIOD/PERIOD_M3 PERIOD_M3} | 3分钟K线周期，值为```180```。 |\\n| {@var/PERIOD/PERIOD_M5 PERIOD_M5} | 5分钟K线周期，值为```300```。 |\\n| {@var/PERIOD/PERIOD_M15 PERIOD_M15} | 15分钟K线周期，值为```900```。 |\\n| {@var/PERIOD/PERIOD_M30 PERIOD_M30} | 30分钟K线周期，值为```1800```。 |\\n| {@var/PERIOD/PERIOD_H1 PERIOD_H1} | 1小时K线周期，值为```3600```。 |\\n| {@var/PERIOD/PERIOD_H2 PERIOD_H2} | 2小时K线周期，值为```7200```。 |\\n| {@var/PERIOD/PERIOD_H4 PERIOD_H4} | 4小时K线周期，值为```14400```。 |\\n| {@var/PERIOD/PERIOD_H6 PERIOD_H6} | 6小时K线周期，值为```21600```。 |\\n| {@var/PERIOD/PERIOD_H12 PERIOD_H12} | 12小时K线周期，值为```43200```。 |\\n| {@var/PERIOD/PERIOD_D1 PERIOD_D1} | 1天K线周期，值为```86400```。 |\\n| {@var/PERIOD/PERIOD_D3 PERIOD_D3} | 3天K线周期，值为```259200```。 |\\n| {@var/PERIOD/PERIOD_W1 PERIOD_W1} | 1周K线周期，值为```604800```。 |\\n\\n#### LOG_TYPE\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY} | 买单日志，值为```0```。 |\\n| {@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL} | 卖单日志，值为```1```。 |\\n| {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL} | 撤单日志，值为```2```。 |\\n\\n### 通用约定\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@conventions/symbol 品种代码} | 交易所对象的函数用字符串参数```symbol```指定品种。 |\\n| {@conventions/errors 失败与空值} | ### 调用失败返回空值 |\\n\\n### 交易所\\n\\n| 名称 | 说明 |\\n| - | - |\\n| {@exchanges/capabilities 能力矩阵} | 各交易所对象对标准函数与交易模式指令的支持情况。 |\"], \"title\": \"API函数速查\"}], \"desc\": \"介绍策略结构（生命周期、主循环、事件驱动）、各编程语言的说明、策略参数、交互控件、模板类库、内置库、策略界面文字的中英文写法，以及全部 API 函数的分类速查。\", \"title\": \"编写策略\"}, {\"_src_hash\": \"b2ef397d9c19797aa172580dbb1d94a9a3ec5a227c299fb6257d63ef557b2804\", \"children\": [{\"_src_hash\": \"1f109b30b0c9c7c618fdb5acae43920f63139b18b61d401375a11da54ba524e8\", \"children\": [{\"_src_hash\": \"7ea9e6c890f95ac5f1d5a5d4ee421688952ef8fdb5954535b10b043b53fc45cd\", \"desc\": \"策略编辑器内置AI助手，可以根据描述生成策略代码，解释、修改选中的代码，调整策略参数和交互控件，并自动回测、分析回测结果。\\n\\n- AI助手面板\\n 代码编辑区右侧是AI助手面板，可以收起和展开。在输入框中描述需求即可对话；先在编辑器中选中代码，选中的代码会作为对话的上下文。\\n AI给出的代码、参数和交互控件修改以差异形式显示，可以逐处「接受」或「拒绝」，也可以全部接受；修改策略或自动回测前会先询问是否允许。\\n- 选中代码的快捷操作\\n 选中代码后点击鼠标右键，菜单中有AI操作（例如解释这段代码、优化代码），也可以用```⌘1```、```⌘2```……（Windows为```Ctrl+1```、```Ctrl+2```……）触发。\\n\\n ![策略编辑器中的AI助手解释代码](/upload/asset/16aa01684eda4e8163ed.png)\\n- 智能补全\\n 在右键菜单中选择开启或关闭智能补全，快捷键为```⌘J```（Windows为```Ctrl+J```）。\\n\\nAI助手按使用量从账户余额扣费，对话中会显示本次费用。\\n\\n除了编辑器内的AI助手，也可以把自己使用的外部AI助手接入平台，通过对话管理策略、回测和实盘，见{@扩展API接口/AI接入 AI接入}。\", \"title\": \"AI助手\"}, {\"_src_hash\": \"8fe62a954909122634b24599f756adba484905fb01bab82b924266be7b19e142\", \"desc\": \"线上策略编辑页面把策略代码、策略描述、使用说明、开发记录等信息分开记录。\\n\\n![策略文档选项说明](/upload/asset/2e47983c191c1779bd52e.png)\\n\\n- 代码：策略程序的源码。\\n 平台上一个完整的策略包含：策略源码、{@编写策略/策略参数策略参数}设计、{@编写策略/交互控件交互控件}设计、{@编写策略/模板类库模板类库}引用。\\n- 笔记：记录策略开发过程中的内容。\\n- 描述：策略公开展示时显示的介绍。\\n- 手册：只有租用策略后才能看到的说明。\", \"title\": \"策略文档\"}, {\"_src_hash\": \"b7fa9843397c2186a44dc4f7aa1eabd03bdc719f7628efdf82a55e4cf5f57901\", \"desc\": \"历史版本是策略在某一时刻的快照，可以用来回滚、对比代码，也可以让实盘运行指定的版本。在**策略编辑页面**「代码」编辑区内点击「历史版本」按钮，打开历史版本管理页面。\\n\\n### 创建与管理快照\\n- 创建：当前策略还没有快照时，点击「立即创建」；已有快照时，点击右侧快照列表上方的「创建历史版本」。快照包括策略代码、笔记、描述、手册、参数设计、交互设计等。\\n- 管理：可以修改快照名称、删除快照，或把策略恢复到某个快照的版本。\\n- 预览：点击页面左下角的「预览」，查看选中快照中的代码、笔记、描述、手册、参数设计、交互设计等。\\n- 对比：点击页面左下角的「对比」，比较选中快照与当前策略的差异。\\n\\n### 实盘运行历史版本\\n- **设置默认运行版本**：在历史版本管理页面选中某个版本，点击菜单中的「修改」，在弹框中勾选「设置为默认版本」。不设置时默认运行最新版本。\\n- **在实盘中使用历史版本**：创建实盘或修改实盘参数时，策略所有者可以选择策略的某个历史版本来运行；此功能仅对策略所有者有效。\\n- **出租策略的版本控制**：租用方只能运行策略所有者设置的默认运行版本，不能选择其他历史版本；所有者通过设置默认运行版本控制出租策略使用的版本。\", \"title\": \"历史版本管理\"}], \"desc\": \"在[新建策略页面](https://www.fmz.com/m/add-strategy)或者从[策略库](https://www.fmz.com/m/strategies)打开一个现有策略，进入**编辑页面**（例如策略ID为123456的地址为```https://www.fmz.com/m/edit-strategy/123456```）编写策略。\\n\\n![线上策略编辑器界面](/upload/asset/2e50fff4160187be92248.png)\\n\\n本章介绍编辑器的辅助功能。与编辑页面相关的其它功能：\\n- {@开发工具/远程编辑远程编辑}：用本地编辑器编写，自动同步到平台。\\n- {@回测系统/回测配置与保存回测配置与保存}：把回测配置和策略参数随策略保存。\\n- {@平台基础/策略库/完整策略的导入与导出完整策略的导入与导出}：导出、导入包含参数等全部信息的完整策略。\\n\\n### 编辑器快捷操作\\n\\n- **命令面板**：在代码编辑区点击鼠标右键，选择「命令面板」，可以查看各项功能的快捷键和编辑器命令。\\n\\n ![策略编辑器中菜单的命令面板显示](/upload/asset/2e429269f02185dfbab3b.png)\\n\\n- **定义与引用跳转**：选中要查询的内容，点击鼠标右键：\\n - 转到定义：跳转到所查询内容的定义位置。\\n - 转到引用：跳转到所查询内容的引用位置。\\n - 快速查看-速览定义：不离开当前代码行，查看选中代码的定义。\\n - 快速查看-查看引用：不离开当前代码行，查看其它代码行对它的引用，并可快速跳转。\\n\\n- **语法手册速查**：在「代码」编辑区按住```⌘```（Mac）或```Ctrl```（Windows）不放，把鼠标移到**变量名**或**函数名**上会出现跳转链接，点击后弹出「语法手册」并定位到该内容。\\n\\n ![策略编辑器中语法手册速查](/upload/asset/2e4d0722af99164f69996.png)\", \"title\": \"策略编辑器\"}, {\"_src_hash\": \"bfbde1609d17c6abfbaf64a8464d1646c899bdd7d01176f6bc3f08d7b54fa4af\", \"children\": [], \"desc\": \"[调试工具](https://www.fmz.com/m/debug)页面提供了一个用于快速测试实盘代码的免费环境，目前仅支持```JavaScript```语言。\\n\\n![调试工具](/upload/asset/2e48d6d1bc77e46099058.png)\\n\\n使用调试工具测试代码时，代码将直接在指定的托管者上运行，最长运行时间为5分钟。支持调用发明者量化交易平台的所有API函数，但仅支持单个交易所对象。\", \"title\": \"调试工具\"}, {\"_src_hash\": \"bf9d51bd08019586148eabbbfd5e4e6d10b626152cb43b04d405cbaedeeac9e0\", \"children\": [], \"desc\": \"可以用本地编辑器编写策略，保存时自动同步到发明者量化交易平台。支持```VSCode```、```Vim```、```Sublime Text 3```，```JavaScript```策略还可以用```WebStorm```，```Python```策略还可以用```PyCharm```。\\n\\n![远程编辑截图](/upload/asset/2e4e8975d1e32517fd989.png)\\n\\n### 使用步骤\\n1. 在策略编辑页面点击「远程编辑」。弹出的窗口上方是各编辑器插件的下载链接，点击跳转到对应的插件页面安装，不同编辑器的安装方式略有差别。\\n2. 窗口中显示当前策略的远程同步密钥（token）。密钥为空时，点击「更新密钥」生成。\\n3. 把策略源码保存到本地，在源码第一行插入窗口中给出的密钥行（例如```JavaScript```为```// fmz@<密钥>```，```Python```为```# fmz@<密钥>```），之后每次保存都会自动同步到平台。\\n\\n也可以不装插件，用```curl```直接上传本地源码（窗口中有带密钥的完整命令），例如：\\n\\n```bash\\ncurl -T quant.js -H \\\"Authorization: Bearer <密钥>\\\" https://www.fmz.com/rsync\\n```\\n\\n### 管理密钥\\n- 「更新密钥」：生成新密钥，原密钥随即失效。\\n- 「删除密钥」：删除当前策略的密钥，关闭远程编辑。\\n- 策略超过30天没有任何修改（网页保存或远程同步）时，同步会被拒绝（返回码405）；在网页上保存一次策略或「更新密钥」即可恢复。\\n- 用```curl```上传时，源码不能超过8MB。\\n\\n拿到密钥的人可以改写这个策略的源码，不要把密钥公开。\", \"title\": \"远程编辑\"}], \"desc\": \"编写和调试策略的工具：策略编辑器（含AI助手和历史版本）、调试工具，以及用本地编辑器远程编辑策略。\", \"title\": \"开发工具\"}, {\"_src_hash\": \"fab552dd29add20dfa0800bedfa98a368ddbe0b418a6980a4c51004f162185f8\", \"children\": [{\"_src_hash\": \"570b8e082f044205154a07ddad0adcd3a500dfc4cee651189ea41f5ec9e8334a\", \"desc\": \"回测用平台的历史行情驱动策略代码：回测引擎维护一个虚拟时钟，为每个交易所对象维护一个模拟账户，策略调用的行情、下单、账户等函数都由引擎按历史数据应答。回测结果只反映策略在历史行情下的表现，历史行情不能代表未来，对回测结果要理性、客观地看待。\\n\\n### 发起回测\\n\\n- 网页：打开策略编辑页面，切换到「模拟回测」分页，设置回测配置和策略参数后点击「开始回测」（快捷键见{@回测系统/回测页面快捷键回测页面快捷键}）。回测配置可以保存进策略源码，见{@回测系统/回测配置与保存回测配置与保存}。\\n- AI助手：通过MCP工具```run_backtest```发起回测、```get_backtest```读取结果，见{@扩展API接口/AI接入 AI接入}。MCP发起的回测只使用模拟级Tick模式。\\n- 本机：使用开源的本地回测引擎，见{@回测系统/本地回测引擎本地回测引擎}。\\n\\n### 回测配置项\\n\\n| 配置项 | 说明 |\\n| - | - |\\n| 时间范围 | 回测的开始时间和结束时间。 |\\n| K线周期 | 策略调用```GetRecords()```默认得到的K线周期。 |\\n| 底层K线周期 | 模拟级Tick模式下用来生成tick的K线周期。 |\\n| 模式 | 模拟级Tick或实盘级Tick，见{@回测系统/回测模式与撮合回测模式与撮合}。 |\\n| 交易所、交易对 | 每个交易所对象有各自的模拟账户；交易对写成```BTC_USDT```的形式。 |\\n| 初始资金 | 计价币（如USDT）和交易币（如BTC）的初始余额。 |\\n| 手续费 | 挂单（maker）和吃单（taker）费率，单位为百分比。 |\\n| 滑点 | 加在模拟盘口买一价、卖一价外侧的跳数（价格最小变动单位的个数），默认为0。 |\\n| 网络延迟 | 策略每调用一次交易所接口，虚拟时钟前进的毫秒数，默认为200。 |\\n| 深度档位、每档数量 | ```GetDepth()```返回的档位数（1～20）和模拟盘口每档的数量。 |\\n| K线最大条数 | 第一次调用```GetRecords()```时返回的历史K线条数上限（100～5000，默认300）。 |\\n| 日志条数 | 回测保留的运行日志、收益日志、图表数据的条数上限。 |\\n| 数据源 | 默认使用平台的历史数据，也可以使用{@回测系统/自定义数据源自定义数据源}。 |\\n\\n补充说明：\\n- 底层K线周期越小，生成的tick越接近真实行情，回测也越慢；策略K线由底层K线合成，K线周期不能小于底层K线周期。\\n- 加密货币期货交易所的合约默认为```swap```（永续合约），要使用其它合约时先在策略中调用```exchange.SetContractType()```设置。\\n- 币本位合约以交易币作保证金，需要设置交易币余额。\\n- 手续费默认取该交易所市场的配置。限价单下单时立即成交按吃单费率计算，挂在盘口上之后才成交按挂单费率计算。\\n- 滑点只在模拟级Tick模式下生效，实盘级Tick模式直接使用回放的真实盘口；实盘级Tick模式下，深度档位是向数据源请求的真实深度档数。\\n\\n### 容错测试\\n\\n回测页面另外提供「容错测试」：按一定概率（默认0.5）让交易所接口调用失败，并且每种接口的第一次调用一定失败，失败时记录错误日志```FaultTolerant Test```。用于检验策略对接口失败的处理，例如是否用```_C()```重试。\\n\\n### 回测中的策略\\n\\n- ```IsVirtual()```返回```true```，不应在回测中执行的逻辑可以据此跳过，见{@fun/Global/IsVirtual IsVirtual}。\\n- 时间是虚拟时间：```Unix()```、```_D()```等读取的是回测时钟，```Sleep()```推动时钟前进。时钟越过结束时间时，引擎抛出```EOF```异常结束回测，此时```JavaScript```、```Python```策略不会调用```onexit()```（处理方法见 {@编写策略/策略结构/onexit() onexit()}）；```Rust```策略会自动调用```onexit()```。\\n- 回测中```GetCommand()```收不到交互命令，不支持```onerror()```，网络请求类功能受限。\", \"title\": \"概述与发起回测\"}, {\"_src_hash\": \"e2749e2279484d796b47a8d01c8fb81017b8728f964b1e8164757226846dc496\", \"desc\": \"回测分为**模拟级Tick**和**实盘级Tick**两种模式。两者都基于真实的历史数据：模拟级Tick由K线生成tick，实盘级Tick回放真实记录的tick，后者更精确，也更慢。\\n\\n### 模拟级Tick\\n\\n回测引擎在每根底层K线的开盘价、最高价、最低价、收盘价构成的价格框架内，沿开盘→最低/最高→收盘的路径生成2～14个模拟tick，K线的成交量分摊到这些tick上；策略调用行情接口时得到的是当前模拟tick的数据。因此每根底层K线上有多个回测时间点，策略可以在一根K线内多次交易，而不是只能按收盘价成交。底层K线周期越小，生成的tick越接近真实走势，回测也越慢。机制详见[回测系统模拟级别机制说明](https://www.fmz.com/bbs-topic/662)、[回测系统机制说明](https://www.fmz.com/digest-topic/4009)。\\n\\n模拟盘口：卖一价 = 当前tick收盘价 + 一跳 + 滑点，买一价 = 收盘价 − 一跳 − 滑点（滑点以跳数计）；```GetDepth()```从买一、卖一开始向外返回若干档模拟深度，相邻两档的间隔等于买一与卖一的价差（2跳 + 2倍滑点），每档数量为配置中的「每档数量」。\\n\\n### 实盘级Tick\\n\\n使用平台真实记录的逐秒tick数据，包含盘口深度（档位可设置，最多20档），可以选择回放逐笔成交数据；```GetDepth()```、```GetTrades()```返回回放的真实数据。平台数据服务对每个品种的单次数据请求有上限（50MB，另有53万条记录的上限），两种模式都受此限制（自定义数据源不受限），实盘级Tick数据量大、回测慢，受到的影响最明显，可回测的时间范围因此受限；需要更长的时间范围时，可以降低深度档位、不使用逐笔成交数据。较早的时间段可能没有实盘级数据，时间范围不宜选得过早。实盘级Tick模式下，策略循环中的```Sleep()```宜设得短一些（例如100毫秒）。\\n\\n### 行情时刻的推进\\n\\n两种模式下，在某个行情时刻，```GetTicker()```、```GetDepth()```、```GetTrades()```、```GetRecords()```各调用一次不会推动回测时间；再次调用其中同一个函数时，回测时间跳到下一个行情时刻。\\n\\n### 撮合规则\\n\\n两种模式使用相同的撮合规则：\\n\\n- 按价格触及成交，并且一次全部成交，回测中不会出现部分成交。\\n- 市价单在当前tick按卖一价/买一价成交；现货市价买单的数量是计价币金额。\\n- 限价买单价格大于等于卖一价、限价卖单价格小于等于买一价时成交，挂单后的每个tick都会检查。下单时立即成交的，按市场价成交并收取吃单（taker）手续费；挂在盘口之后被价格触及而成交的，按委托价成交并收取挂单（maker）手续费。\\n- 实盘级Tick模式下，挂在买一/卖一价位上的订单，要等排在它前面的挂单量被消耗后才成交。\\n- 期货开仓按名义价值 ÷ 杠杆冻结保证金，另外冻结预估的手续费；行情数据中包含资金费率时，永续合约按资金费率结算资金费。\\n\\n### 数据粒度的影响\\n\\n同一个策略在不同的数据粒度下（实盘级Tick、底层K线周期较小的模拟级Tick、底层K线周期较大的模拟级Tick等）回测，交易次数和盈亏都会不同。数据粒度大时回测快，但结果可能失真，回测时应尽量使用较小的数据粒度。可以用下面的策略在几种粒度下分别回测对比：\\n\\n```javascript\\n/*backtest\\nstart: 2025-04-01 08:00:00\\nend: 2025-04-18 00:00:00\\nperiod: 1m\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"balance\\\":1000000}]\\nmode: 1\\n*/\\n\\nvar delta = 50\\nvar lotSize = 0.001\\nvar lastPrice = null\\nvar direction = null\\n\\nfunction main() {\\n while (true) {\\n var ticker = _C(exchange.GetTicker)\\n if (!lastPrice) {\\n lastPrice = ticker.Last\\n }\\n var diff = ticker.Last - lastPrice\\n if ((!direction || direction == \\\"long\\\") && diff >= delta) {\\n // 价格上涨超过阈值 -> 做空\\n exchange.Sell(ticker.Last, lotSize)\\n Log(\\\"Short @\\\", ticker.Last)\\n direction = \\\"short\\\"\\n } else if ((!direction || direction == \\\"short\\\") && diff <= -delta) {\\n // 价格下跌超过阈值 -> 做多\\n exchange.Buy(ticker.Last, lotSize)\\n Log(\\\"Long @\\\", ticker.Last)\\n direction = \\\"long\\\"\\n }\\n // Tick 模式中尽量短，K线模式中没有影响\\n Sleep(100)\\n }\\n}\\n```\", \"title\": \"回测模式与撮合\"}, {\"_src_hash\": \"b38fa0c7ee25c74b7120be3f9885678a89a08db21d8cee12e472f2213db83af2\", \"desc\": \"「模拟回测」分页中的回测配置（时间范围、交易所、手续费等）和策略参数可以随策略保存，再次打开策略时自动载入。\\n\\n### 保存\\n\\n- 点击「保存回测设置」：把回测配置和策略参数以注释（```backtest```注释块）的形式写在策略源码开头。\\n- 点击「保存策略」：平台同时记录当前的回测配置和策略参数。\\n\\n### 载入\\n\\n- 打开或刷新策略编辑页面时，优先载入源码中```backtest```注释块记录的配置。\\n- 源码中没有```backtest```注释块时，载入最后一次「保存策略」时记录的配置。\\n- 在源码中手动修改了```backtest```注释块后，点击注释块上方的「回测设置」按钮，把修改同步到回测页面的选项中。\\n\\n### 注释块格式\\n\\n在该语言的块注释起始符后紧接着写```backtest```，之后每行一个```键: 值```：\\n\\n```javascript\\n/*backtest\\nstart: 2024-01-01 00:00:00\\nend: 2024-03-01 00:00:00\\nperiod: 1h\\nbasePeriod: 15m\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"balance\\\":10000,\\\"stocks\\\":0,\\\"fee\\\":[0.1,0.1]}]\\nargs: [[\\\"fast\\\",5],[\\\"slow\\\",20]]\\n*/\\n```\\n\\n各语言的注释写法：JavaScript、Rust、PINE语言使用```/*backtest ... */```；Python使用```'''backtest ... '''```；My语言使用```(*backtest ... *)```。\\n\\n| 键 | 格式 | 说明 |\\n| - | - | - |\\n| start、end | ```YYYY-MM-DD HH:mm:ss``` | 开始、结束时间，按浏览器所在时区解析。 |\\n| period | ```1m```、```1h```、```1d```等，或秒数 | 策略K线周期。 |\\n| basePeriod | 同上 | 底层K线周期，不写时与```period```相同；实盘级Tick模式下忽略。 |\\n| mode | ```1``` | 实盘级Tick模式；不写为模拟级Tick模式。 |\\n| exchanges | JSON数组 | 每个元素对应一个交易所对象，字段见下表。 |\\n| args | JSON数组 | 策略参数，```[[\\\"参数名\\\", 值], ...]```；第三个元素为模板Id时设置该模板的参数：```[\\\"参数名\\\", 值, 模板Id]```。 |\\n\\n```exchanges```元素的字段，除```eid```、```currency```外都可以省略：\\n\\n| 字段 | 说明 |\\n| - | - |\\n| eid | 交易所Id，例如```Binance```、```Futures_OKX```。 |\\n| currency | 交易对，例如```BTC_USDT```。 |\\n| balance、stocks | 计价币、交易币的初始余额。 |\\n| fee | ```[挂单费率, 吃单费率]```，单位为百分比。 |\\n| feeMin | 每笔成交的最低手续费，只对部分市场生效。 |\\n| depthDeep、depthAmount | 深度档位、模拟盘口每档的数量。 |\\n| tradesMode | 实盘级Tick模式下是否回放逐笔成交：```\\\"0\\\"```回放，```\\\"1\\\"```不回放。 |\\n| feeder | 自定义数据源地址，见{@回测系统/自定义数据源自定义数据源}。 |\\n\\n回测页面上的其他选项（滑点、网络延迟、容错概率、K线最大条数等）不写进注释块，而是在「保存策略」时随策略记录保存。本地回测引擎也读取这个注释块，但只读取其中一部分键，见{@回测系统/本地回测引擎本地回测引擎}。\", \"title\": \"回测配置与保存\"}, {\"_src_hash\": \"dd6470282516587ab608bcc65984e23b1370d637156c2044460a87a54b6bb09d\", \"desc\": \"回测系统支持哪些编程语言和交易所，以及各语言策略在哪里回测。\\n\\n### 编程语言\\n\\n回测系统支持以下语言编写的策略：JavaScript、Python、Rust、[PINE语言](https://www.fmz.com/bbs-topic/9315)、[My语言](https://www.fmz.com/bbs-topic/2569)、Workflow工作流。\\n\\n- JavaScript策略在浏览器中回测，回测引擎以WebAssembly形式运行，不需要安装任何软件。JavaScript策略回测时可以在Chrome浏览器的DevTools中调试，见[参考说明](https://www.fmz.com/digest-topic/9459)。\\n- Rust策略由平台服务器编译；策略中通过frontmatter声明的第三方crate在编译时自动获取，本地不需要安装工具链。回测节点默认为「云端」（在平台服务器上运行），也可以选择「本地」，在浏览器中运行。\\n- Python策略的回测节点默认为「云端」（平台的公共服务器），也可以选择自己的托管者，或者选择「本地: Python3」在浏览器中回测（以Pyodide运行）。在托管者上回测与实盘一样依赖托管者所在系统的Python 3环境，需要的第三方库要自行安装；公共服务器只提供常用的库。\\n- Workflow工作流策略回测时可以可视化查看各节点的执行状态和数据流转。\\n\\n### 交易所\\n\\n回测数据来自平台的历史数据，可以回测的交易所以回测页面中可选的为准（也可以通过MCP工具```list_exchanges```查看，```backtest```为```true```的交易所有历史数据）。\\n\\n- 加密货币：主流交易所的现货和期货，例如```Binance```与```Futures_Binance```、```OKX```与```Futures_OKX```、```HTX```与```Futures_HTX```、```Bybit```与```Futures_Bybit```、```Bitget```与```Futures_Bitget```、```GateIO```与```Futures_GateIO```，支持交易所的全部品种。\\n\\n 这里列的是回测用的交易所ID（回测配置```/*backtest*/```与MCP工具```run_backtest```中的```eid```，与历史数据服务器的名称一致）。大多数交易所与实盘中```exchange.GetName()```的返回值相同，少数不同：回测的```OKX```、```Futures_OKX```对应实盘的```OKEX```、```Futures_OKCoin```（OKX 期货）；回测的```HTX```、```Futures_HTX```对应实盘的```Huobi```、```Futures_HuobiDM```（HTX 期货）。策略中按交易所名称分支时，要同时考虑这两种写法。\\n- 富途证券（```Futures_Futu```）：港股、美股等市场。回测只支持日线级别数据，```currency```设置为```STOCK```，在策略中用```exchange.SetContractType()```设置股票代码：\\n\\n```javascript\\n/*backtest\\nstart: 2024-05-01 00:00:00\\nend: 2025-02-17 00:00:00\\nperiod: 1d\\nbasePeriod: 1d\\nexchanges: [{\\\"eid\\\":\\\"Futures_Futu\\\",\\\"currency\\\":\\\"STOCK\\\",\\\"fee\\\":[0.03,0.03]}]\\n*/\\n\\nfunction main() {\\n // 设置股票代码：特斯拉\\n var info = exchange.SetContractType(\\\"TSLA.US\\\")\\n // 合约信息：InstrumentID、PriceTick、LotTick、VolumeMultiple等\\n Log(\\\"info:\\\", info)\\n // 回测时间点的日线行情\\n Log(exchange.GetTicker())\\n}\\n```\", \"title\": \"支持范围\"}, {\"_src_hash\": \"b0cf39c0614a1fc23e5a75d541ebe4432e02ba326b7520f273d1b87d2b1fbf62\", \"desc\": \"回测结束后，回测页面显示收益曲线、统计指标、状态信息、日志信息和账户信息。\\n\\n### 收益曲线\\n\\n策略调用```LogProfit()```（{@fun/Log/LogProfit LogProfit}）时，收益曲线由记录的收益值组成，下面的统计指标也按这个收益序列计算。策略不调用```LogProfit()```时，回测页面按回测引擎记录的账户快照计算盈亏，据此画出曲线、计算统计指标（使用第一个交易所账户的盈亏）。\\n\\nMCP工具```get_backtest```返回的```profit```、```max_drawdown```来自```LogProfit()```记录的收益，其中```max_drawdown```是收益序列从峰值到谷值的最大回落（绝对值，不是比例）；策略没有收益记录时，```profit```为回测引擎统计的收益，并且不返回```max_drawdown```。\\n\\n### 统计指标\\n\\n统计指标由收益序列```profits```（每个元素为```[时间戳, 收益]```）和初始资产```totalAssets```按下面的算法计算：\\n\\n| 指标 | 含义 |\\n| - | - |\\n| 收益率（totalReturns） | 最后一个收益值 ÷ 初始资产。 |\\n| 年化收益（annualizedReturns） | 收益率 × 一年的时长（yearDays天）÷ 回测时长，按比例线性折算。 |\\n| 最大回撤（maxDrawdown） | 资产（初始资产 + 收益）相对此前最高点下跌的最大比例。 |\\n| 胜率（winningRate） | 收益序列中高于前一个点的点所占的比例（第一个点与0比较）。 |\\n| 波动率（volatility） | 每天的收益额 ÷ 初始资产，乘以yearDays折算为年化值，取这些值的总体标准差。 |\\n| 夏普比率（sharpeRatio） | （年化收益 − 无风险利率3%）÷ 波动率；波动率为0时为0。 |\\n\\n- 最大回撤：maxDrawdownStartTime为回撤开始前资产最高点的时间，maxDrawdownTime为回撤最深的时间。\\n- 胜率：统计的是收益记录，不是逐笔交易的胜率。\\n- 波动率：把回测时间按天切分计算每天的收益，没有收益记录的日子按0计。\\n- yearDays是年化时使用的一年天数，固定为365。波动率是把每日收益率直接乘以yearDays年化，而不是常见的乘以√yearDays，因此这里的夏普比率不宜与其他平台的数值直接比较。\\n\\n算法源码：\\n\\n```javascript\\nfunction returnAnalyze(totalAssets, profits, ts, te, period, yearDays) {\\n // 按天统计\\n period = 86400000\\n if (profits.length == 0) {\\n return null\\n }\\n var freeProfit = 0.03 // 无风险利率\\n var yearRange = yearDays * 86400000\\n var totalReturns = profits[profits.length - 1][1] / totalAssets\\n var annualizedReturns = (totalReturns * yearRange) / (te - ts)\\n\\n // MaxDrawDown\\n var maxDrawdown = 0\\n var maxAssets = totalAssets\\n var maxAssetsTime = 0\\n var maxDrawdownTime = 0\\n var maxDrawdownStartTime = 0\\n var winningRate = 0\\n var winningResult = 0\\n for (var i = 0; i < profits.length; i++) {\\n if (i == 0) {\\n if (profits[i][1] > 0) {\\n winningResult++\\n }\\n } else {\\n if (profits[i][1] > profits[i - 1][1]) {\\n winningResult++\\n }\\n }\\n if ((profits[i][1] + totalAssets) > maxAssets) {\\n maxAssets = profits[i][1] + totalAssets\\n maxAssetsTime = profits[i][0]\\n }\\n if (maxAssets > 0) {\\n var drawDown = 1 - (profits[i][1] + totalAssets) / maxAssets\\n if (drawDown > maxDrawdown) {\\n maxDrawdown = drawDown\\n maxDrawdownTime = profits[i][0]\\n maxDrawdownStartTime = maxAssetsTime\\n }\\n }\\n }\\n if (profits.length > 0) {\\n winningRate = winningResult / profits.length\\n }\\n // trim profits\\n var i = 0\\n var datas = []\\n var sum = 0\\n var preProfit = 0\\n var perRatio = 0\\n var rangeEnd = te\\n if ((te - ts) % period > 0) {\\n rangeEnd = (parseInt(te / period) + 1) * period\\n }\\n for (var n = ts; n < rangeEnd; n += period) {\\n var dayProfit = 0.0\\n var cut = n + period\\n while (i < profits.length && profits[i][0] < cut) {\\n dayProfit += (profits[i][1] - preProfit)\\n preProfit = profits[i][1]\\n i++\\n }\\n perRatio = ((dayProfit / totalAssets) * yearRange) / period\\n sum += perRatio\\n datas.push(perRatio)\\n }\\n\\n var sharpeRatio = 0\\n var volatility = 0\\n if (datas.length > 0) {\\n var avg = sum / datas.length;\\n var std = 0;\\n for (i = 0; i < datas.length; i++) {\\n std += Math.pow(datas[i] - avg, 2);\\n }\\n volatility = Math.sqrt(std / datas.length);\\n if (volatility !== 0) {\\n sharpeRatio = (annualizedReturns - freeProfit) / volatility\\n }\\n }\\n\\n return {\\n totalAssets: totalAssets,\\n yearDays: yearDays,\\n totalReturns: totalReturns,\\n annualizedReturns: annualizedReturns,\\n sharpeRatio: sharpeRatio,\\n volatility: volatility,\\n maxDrawdown: maxDrawdown,\\n maxDrawdownTime: maxDrawdownTime,\\n maxAssetsTime: maxAssetsTime,\\n maxDrawdownStartTime: maxDrawdownStartTime,\\n winningRate: winningRate\\n }\\n}\\n```\\n\\n### 数据下载\\n\\n- 状态栏数据下载：回测结束后，在「状态信息」栏右上角点击「下载表格」，下载回测结束时状态栏数据的CSV文件。\\n- 日志数据下载：在「日志信息」栏右上角点击「下载表格」，下载回测日志的CSV文件。\", \"title\": \"结果解读\"}, {\"_src_hash\": \"3c937225a511a52b30837a1be910eb4989f2f83ba9d8e0c8d84279148c026d4b\", \"desc\": \"回测时按设置的范围生成多组参数，逐组回测。在「模拟回测」分页的策略参数部分，勾选参数右侧的**调优**选项后出现调优设置：\\n\\n- 最小值：参数的起始值。\\n- 最大值：参数递增后的最大值。\\n- 步长：每次递增的量。\\n- 并发线程：参数调优时同时执行的回测数。该选项只对在浏览器中运行的回测生效：JavaScript、PINE、My语言策略，以及回测节点选择「本地」的Python、Rust策略；其它情况按1个并发执行。引用的模板的参数同样可以勾选调优，参与参数组合。\\n\\n回测系统按```最小值```、```最大值```、```步长```生成参数组合，对每种组合各回测一次。只有**数字型（number）**的策略参数可以设置调优。\", \"title\": \"参数调优\"}, {\"_src_hash\": \"d6a6669ff2b981f4f451e7e26ff187cf29508042e3f92620d0c3eb6fa0ba4689\", \"children\": [{\"_src_hash\": \"2249f2bb367b0d8da2bb0aebc7a3d4c2eec893c0253ec2ce73e6da25dd3b5acf\", \"desc\": \"自定义数据源返回JSON数据，格式为下面两种之一，系统自动识别：模拟级Tick用K线数据，实盘级Tick用盘口深度和逐笔成交数据。数值都按精度放大为整数，见下文「数值精度」。\\n\\n### 模拟级Tick\\n\\n```json\\n{\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 5,\\n \\\"quotePrecision\\\": 3,\\n \\\"minQty\\\": 0.00001,\\n \\\"maxQty\\\": 9000,\\n \\\"minNotional\\\": 5,\\n \\\"maxNotional\\\": 9000000,\\n \\\"priceTick\\\": 0.01,\\n \\\"volumeTick\\\": 0.00001,\\n \\\"marginLevel\\\": 10\\n },\\n \\\"schema\\\":[\\\"time\\\", \\\"open\\\", \\\"high\\\", \\\"low\\\", \\\"close\\\", \\\"vol\\\"],\\n \\\"data\\\":[\\n [1564315200000, 9531300, 9531300, 9497060, 9497060, 787],\\n [1564316100000, 9495160, 9495160, 9474260, 9489460, 338]\\n ]\\n}\\n```\\n\\n### 实盘级Tick\\n\\n数据中包含盘口深度，深度格式为```[价格, 量]```的数组，可以有多档：```asks```按价格升序，```bids```按价格降序。\\n\\n```json\\n{\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 5,\\n \\\"quotePrecision\\\": 3,\\n \\\"minQty\\\": 0.00001,\\n \\\"maxQty\\\": 9000,\\n \\\"minNotional\\\": 5,\\n \\\"maxNotional\\\": 9000000,\\n \\\"priceTick\\\": 0.01,\\n \\\"volumeTick\\\": 0.00001,\\n \\\"marginLevel\\\": 10\\n },\\n \\\"schema\\\":[\\\"time\\\", \\\"asks\\\", \\\"bids\\\", \\\"trades\\\", \\\"close\\\", \\\"vol\\\"],\\n \\\"data\\\":[\\n [1564315200000, [[9531300, 10]], [[9531300, 10]],\\n [[1564315200000, 0, 9531300, 10]], 9497060, 787],\\n [1564316100000, [[9531300, 10]], [[9531300, 10]],\\n [[1564316100000, 0, 9531300, 10]], 9497060, 787]\\n ]\\n}\\n```\\n\\n### 顶层字段\\n\\n| 字段 | 说明 |\\n| - | - |\\n| detail | 请求品种的详细信息，例如交易币、计价币、精度、最小下单量，见下文「detail字段」 |\\n| schema | ```data```数组中各列的属性，区分大小写 |\\n| data | 按```schema```的列结构记录的数据 |\\n\\n```schema```可用的列：```time```、```open```、```high```、```low```、```close```、```vol```、```asks```、```bids```、```trades```、```position```（持仓量）、```data```（自定义数据）。其中```asks```、```bids```、```trades```的格式：\\n\\n| 列 | 格式 | 示例（实盘级Tick范例中的数据） |\\n| - | - | - |\\n| asks / bids | ```[[价格, 数量], ...]``` | ```[[9531300, 10]]``` |\\n| trades | ```[[时间, 方向, 价格, 数量], ...]```，方向0为买、1为卖 | ```[[1564315200000, 0, 9531300, 10]]``` |\\n\\n### 数值精度\\n\\n请求中固定带```round=true```，返回的数值都写成按精度放大后的整数，以免传输过程中丢失浮点数精度：\\n\\n- 价格类数值（```open```、```high```、```low```、```close```，```asks```/```bids```和```trades```中的价格）= 实际值 × 10^```quotePrecision```。\\n- 数量类数值（```vol```，```asks```/```bids```和```trades```中的数量）= 实际值 × 10^```basePrecision```。\\n\\n例如上面的范例中```quotePrecision```为3，```9531300```表示价格9531.300；```basePrecision```为5，```787```表示数量0.00787。时间列（```time```及```trades```中的时间）是毫秒时间戳，不放大。\\n\\n### detail字段\\n\\n| 字段 | 说明 |\\n| - | - |\\n| eid | 交易所Id，注意同一交易所的现货与期货是不同的eid |\\n| symbol | 交易品种代码 |\\n| alias | 该品种在交易所中的symbol |\\n| baseCurrency | 交易币种 |\\n| quoteCurrency | 计价币种 |\\n| marginCurrency | 保证金币种 |\\n| basePrecision | 交易币种精度 |\\n| quotePrecision | 计价币种精度 |\\n| minQty | 最小下单量 |\\n| maxQty | 最大下单量 |\\n| minNotional | 最小下单金额 |\\n| maxNotional | 最大下单金额 |\\n| priceTick | 价格一跳 |\\n| volumeTick | 下单量最小变动数值（下单量一跳） |\\n| marginLevel | 期货杠杆值 |\\n| contractType | 永续合约设置为```swap```，回测系统会继续请求资金费率、价格指数数据 |\\n\\n### 永续合约的资金费率与价格指数\\n\\n期货交易所的永续合约回测时，自定义数据源还需要提供资金费率数据和价格指数数据：\\n\\n- 行情数据的```detail```中包含```\\\"contractType\\\": \\\"swap\\\"```时，回测系统才会继续请求资金费率数据，并且只在策略持有该永续合约的仓位、或者调用```GetFundings()```时才请求。声明了```swap```却拿不到资金费率数据时，回测报错```symbol ... not found```。\\n- 收到资金费率数据后，回测系统才会继续请求价格指数数据。\\n- 资金费率数据只读取```open```列作为费率值，并按资金费率数据```detail```中的```priceTick```截断，所以其```priceTick```要足够小（例如```0.00000001```）。\\n- 资金费率数据相邻两条间隔8小时，与K线数据一样按精度放大为整数，可以为负值。下例中```quotePrecision```为8，```-16795```表示资金费率-0.00016795。\\n\\n资金费率数据（请求的```symbol```形如```BTC_USDT.funding```）：\\n\\n```json\\n{\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Futures_Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT.funding\\\",\\n \\\"alias\\\": \\\"BTC_USDT.funding\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"\\\",\\n \\\"basePrecision\\\": 8,\\n \\\"quotePrecision\\\": 8,\\n \\\"minQty\\\": 1,\\n \\\"maxQty\\\": 10000,\\n \\\"minNotional\\\": 1,\\n \\\"maxNotional\\\": 100000000,\\n \\\"priceTick\\\": 1e-8,\\n \\\"volumeTick\\\": 1e-8,\\n \\\"marginLevel\\\": 10\\n },\\n \\\"schema\\\": [\\\"time\\\", \\\"open\\\", \\\"high\\\", \\\"low\\\", \\\"close\\\", \\\"vol\\\"],\\n \\\"data\\\": [\\n [1584921600000, -16795, -16795, -16795, -16795, 0],\\n [1584950400000, -16294, -16294, -16294, -16294, 0]\\n ]\\n}\\n```\\n\\n回测系统发出的资金费率数据请求示例：\\n\\n```url\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Futures_Binance&from=1351641600&period=86400000&round=true&symbol=BTC_USDT.funding&to=1611244800&trades=0\\n```\\n\\n价格指数数据（请求的```symbol```形如```BTC_USDT.index```）：\\n\\n```json\\n{\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Futures_Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT.index\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"contractType\\\": \\\"index\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 3,\\n \\\"quotePrecision\\\": 1,\\n \\\"minQty\\\": 0.001,\\n \\\"maxQty\\\": 1000,\\n \\\"minNotional\\\": 0,\\n \\\"maxNotional\\\": 1.7976931348623157e+308,\\n \\\"priceTick\\\": 0.1,\\n \\\"volumeTick\\\": 0.001,\\n \\\"marginLevel\\\": 10,\\n \\\"volumeMultiple\\\": 1\\n },\\n \\\"schema\\\": [\\\"time\\\", \\\"open\\\", \\\"high\\\", \\\"low\\\", \\\"close\\\", \\\"vol\\\"],\\n \\\"data\\\": [\\n [1584921600000, 58172, 59167, 56902, 58962, 0],\\n [1584922500000, 58975, 59428, 58581, 59154, 0]\\n ]\\n}\\n```\\n\\n回测系统发出的价格指数数据请求示例：\\n\\n```url\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Futures_Binance&from=1351641600&period=86400000&round=true&symbol=BTC_USDT.index&to=1611244800&trades=0\\n```\", \"title\": \"数据格式\"}, {\"_src_hash\": \"d9e6c5d0ba915dd1ad151384da5ed15a3a625f39311b9f8ee7c8008ec86bfc10\", \"desc\": \"本页给出一个用Go编写的最简自定义数据源服务，以及验证它的测试策略。使用步骤：\\n\\n1. 把下面的服务程序部署在能从公网访问的服务器上，数据源地址即为```http://<服务器地址>:9090/data```（```<服务器地址>```替换为该服务器的公网IP或域名）。\\n2. 在回测配置中把交易所的数据源（```feeder```）设为这个地址，用后面的测试策略回测。\\n\\n服务程序：\\n\\n```go\\npackage main\\n\\nimport (\\n \\\"fmt\\\"\\n \\\"net/http\\\"\\n \\\"encoding/json\\\"\\n)\\n\\nfunc Handle (w http.ResponseWriter, r *http.Request) {\\n // e.g. set on backtest DataSource: http://xxx.xx.x.xx:9090/data\\n\\n // request: GET http://xxx.xx.x.xx:9090/data?custom=0&depth=20&detail=true&eid=OKX\\n // &from=1584921600&period=86400000&round=true&symbol=BTC_USDT&to=1611244800&trades=1\\n // request: GET http://xxx.xx.x.xx:9090/data?custom=0&depth=20&detail=true&eid=Futures_Binance\\n // &from=1599958800&period=3600000&round=true&symbol=BTC_USDT.swap&to=1611244800&trades=0\\n fmt.Println(\\\"request:\\\", r)\\n\\n // response\\n defer func() {\\n // response data\\n /* e.g. data\\n {\\n \\\"detail\\\": {\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 5,\\n \\\"quotePrecision\\\": 2,\\n \\\"minQty\\\": 0.00001,\\n \\\"maxQty\\\": 9000,\\n \\\"minNotional\\\": 5,\\n \\\"maxNotional\\\": 9000000,\\n \\\"priceTick\\\": 0.01,\\n \\\"volumeTick\\\": 0.00001,\\n \\\"marginLevel\\\": 10\\n },\\n \\\"schema\\\": [\\n \\\"time\\\",\\n \\\"open\\\",\\n \\\"high\\\",\\n \\\"low\\\",\\n \\\"close\\\",\\n \\\"vol\\\"\\n ],\\n \\\"data\\\": [\\n [1610755200000, 3673743, 3795000, 3535780, 3599498, 8634843151],\\n [1610841600000, 3599498, 3685250, 3385000, 3582861, 8015772738],\\n [1610928000000, 3582499, 3746983, 3480000, 3663127, 7069811875],\\n [1611014400000, 3662246, 3785000, 3584406, 3589149, 7961130777],\\n [1611100800000, 3590194, 3641531, 3340000, 3546823, 8936842292],\\n [1611187200000, 3546823, 3560000, 3007100, 3085013, 13500407666],\\n [1611273600000, 3085199, 3382653, 2885000, 3294517, 14297168405],\\n [1611360000000, 3295000, 3345600, 3139016, 3207800, 6459528768],\\n [1611446400000, 3207800, 3307100, 3090000, 3225990, 5797803797],\\n [1611532800000, 3225945, 3487500, 3191000, 3225420, 8849922692]\\n ]\\n }\\n */\\n\\n // /* 模拟级Tick\\n ret := map[string]interface{}{\\n \\\"detail\\\": map[string]interface{}{\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 5,\\n \\\"quotePrecision\\\": 2,\\n \\\"minQty\\\": 0.00001,\\n \\\"maxQty\\\": 9000,\\n \\\"minNotional\\\": 5,\\n \\\"maxNotional\\\": 9000000,\\n \\\"priceTick\\\": 0.01,\\n \\\"volumeTick\\\": 0.00001,\\n \\\"marginLevel\\\": 10,\\n },\\n \\\"schema\\\": []string{\\\"time\\\",\\\"open\\\",\\\"high\\\",\\\"low\\\",\\\"close\\\",\\\"vol\\\"},\\n \\\"data\\\": []interface{}{\\n // 1610755200000: 2021-01-16 08:00:00\\n []int64{1610755200000, 3673743, 3795000, 3535780, 3599498, 8634843151},\\n // 1610841600000: 2021-01-17 08:00:00\\n []int64{1610841600000, 3599498, 3685250, 3385000, 3582861, 8015772738},\\n []int64{1610928000000, 3582499, 3746983, 3480000, 3663127, 7069811875},\\n []int64{1611014400000, 3662246, 3785000, 3584406, 3589149, 7961130777},\\n []int64{1611100800000, 3590194, 3641531, 3340000, 3546823, 8936842292},\\n []int64{1611187200000, 3546823, 3560000, 3007100, 3085013, 13500407666},\\n []int64{1611273600000, 3085199, 3382653, 2885000, 3294517, 14297168405},\\n []int64{1611360000000, 3295000, 3345600, 3139016, 3207800, 6459528768},\\n []int64{1611446400000, 3207800, 3307100, 3090000, 3225990, 5797803797},\\n []int64{1611532800000, 3225945, 3487500, 3191000, 3225420, 8849922692},\\n },\\n }\\n // */\\n\\n /* 实盘级Tick\\n ret := map[string]interface{}{\\n \\\"detail\\\": map[string]interface{}{\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"alias\\\": \\\"BTCUSDT\\\",\\n \\\"baseCurrency\\\": \\\"BTC\\\",\\n \\\"quoteCurrency\\\": \\\"USDT\\\",\\n \\\"marginCurrency\\\": \\\"USDT\\\",\\n \\\"basePrecision\\\": 5,\\n \\\"quotePrecision\\\": 2,\\n \\\"minQty\\\": 0.00001,\\n \\\"maxQty\\\": 9000,\\n \\\"minNotional\\\": 5,\\n \\\"maxNotional\\\": 9000000,\\n \\\"priceTick\\\": 0.01,\\n \\\"volumeTick\\\": 0.00001,\\n \\\"marginLevel\\\": 10,\\n },\\n \\\"schema\\\": []string{\\\"time\\\", \\\"asks\\\", \\\"bids\\\", \\\"trades\\\", \\\"close\\\", \\\"vol\\\"},\\n \\\"data\\\": []interface{}{\\n []interface{}{1610755200000,\\n []interface{}{[]int64{9531300, 10}},\\n []interface{}{[]int64{9531300, 10}},\\n []interface{}{[]int64{1610755200000, 0, 9531300, 10}},\\n 9497060, 787},\\n []interface{}{1610841600000,\\n []interface{}{[]int64{9531300, 15}},\\n []interface{}{[]int64{9531300, 15}},\\n []interface{}{[]int64{1610841600000, 0, 9531300, 11}},\\n 9497061, 789},\\n },\\n }\\n */\\n\\n b, _ := json.Marshal(ret)\\n w.Write(b)\\n }()\\n}\\n\\nfunc main () {\\n fmt.Println(\\\"listen http://localhost:9090\\\")\\n http.HandleFunc(\\\"/data\\\", Handle)\\n http.ListenAndServe(\\\":9090\\\", nil)\\n}\\n```\\n\\n测试策略（```JavaScript```）：\\n\\n```javascript\\n/*backtest\\nstart: 2021-01-16 08:00:00\\nend: 2021-01-22 00:00:00\\nperiod: 1d\\nbasePeriod: 1d\\nexchanges: [{\\\"eid\\\":\\\"OKX\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"feeder\\\":\\\"http://<服务器地址>:9090/data\\\"}]\\nargs: [[\\\"number\\\",2]]\\n*/\\n\\nfunction main() {\\n var ticker = exchange.GetTicker()\\n var records = exchange.GetRecords()\\n Log(exchange.GetName(), exchange.GetCurrency())\\n Log(ticker)\\n Log(records)\\n}\\n```\", \"title\": \"自定义数据源范例\"}], \"desc\": \"回测系统可以使用自定义数据源代替平台的历史数据：在回测配置中把交易所的数据源设为自定义数据源（feeder）的地址，回测时由平台的数据服务器用```GET```方法请求这个URL获取数据，因此该URL必须能从公网访问。请求附加的参数如下：\\n\\n| 参数 | 意义 | 说明 |\\n| - | - | - |\\n| symbol | 品种名 | 现货如```BTC_USDT```，期货如```BTC_USDT.swap```；资金费率、价格指数见下方说明 |\\n| eid | 交易所 | 例如：OKX、Futures_OKX |\\n| round | 数据精度 | 固定为```round=true```，数值按精度放大为整数，见{@回测系统/自定义数据源/数据格式数据格式} |\\n| period | K线数据的周期（毫秒） | 例如：```60000```为1分钟周期 |\\n| depth | 深度档数 | 1-20 |\\n| trades | 是否需要逐笔成交数据 | 是（1）/否（0）；模拟级Tick回测时固定为0 |\\n| from | 开始时间 | Unix时间戳，单位为秒 |\\n| to | 结束时间 | Unix时间戳，单位为秒 |\\n| detail | 品种详细信息 | 固定为```detail=true```，要求返回数据中带有品种详细信息 |\\n| event | 请求类型 | ```feed```：回测开始时请求行情数据；```fill```：K线不足时补取更早的K线 |\\n| custom | -- | 可以忽略该参数 |\\n\\n- 永续合约回测时还会请求资金费率数据（```symbol```形如```BTC_USDT.funding```）和价格指数数据（```symbol```形如```BTC_USDT.index```），见{@回测系统/自定义数据源/数据格式数据格式}。\\n- ```event=fill```的请求固定为```depth=2&trades=0&custom=0```，```period```为```900000```或```86400000```。\\n\\n回测系统向自定义数据源发送的请求示例（现货、期货交易所对象各一条）：\\n\\n```url\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Bitget&event=feed&from=1351641600&period=86400000&round=true&symbol=BTC_USDT&to=1611244800&trades=0\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Futures_OKX&event=feed&from=1351641600&period=86400000&round=true&symbol=BTC_USDT.swap&to=1611244800&trades=0\\n```\", \"title\": \"自定义数据源\"}, {\"_src_hash\": \"cce13655bfb201a27a4ff2f463b2673745b8e55167aa8974644941c51e821266\", \"desc\": \"平台开源了JavaScript和Python的本地回测引擎，与云端回测使用相同的引擎核心和历史数据（从平台的数据服务器下载），可以在自己的电脑上快速回测JavaScript、Python策略。源码：\\n\\n- [Python回测引擎](https://github.com/fmzquant/backtest_python)\\n- [JavaScript回测引擎](https://github.com/fmzquant/backtest_javascript)\\n\\n### Python\\n\\n安装（需要Python 3和pip）：\\n\\n```bash\\npip install https://github.com/fmzquant/backtest_python/archive/master.zip\\npip install pandas matplotlib # 仅在使用 Join(True)、Show() 时需要\\n```\\n\\n第一次使用时会从数据服务器下载对应系统的引擎文件，之后除了历史数据不再联网。策略文件就是普通的FMZ策略，加上开头的```backtest```配置注释（格式见{@回测系统/回测配置与保存回测配置与保存}，本地引擎只读取其中一部分键，见下文「与云端回测的区别」）和几行引擎调用代码：\\n\\n```python\\n'''backtest\\nstart: 2026-09-01 00:00:00\\nend: 2026-09-15 00:00:00\\nperiod: 1h\\nbasePeriod: 15m\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"balance\\\":10000,\\\"stocks\\\":0}]\\n'''\\nimport json\\nfrom fmz import *\\n# 按上方注释中的配置初始化回测引擎，exchange、Log、TA 等成为全局对象\\ntask = VCtx(__doc__)\\n\\n# 以下为待测试的策略代码，可以从平台直接复制\\ndef main():\\n Log(exchange.GetAccount())\\n while True:\\n r = exchange.GetRecords()\\n if r:\\n LogStatus(_D(), r[-1][\\\"Close\\\"])\\n Sleep(60 * 60 * 1000)\\n\\ntry:\\n main()\\nexcept EOFError: # 虚拟时钟到达结束时间时，引擎抛出 EOFError\\n pass\\nresult = json.loads(task.Join(False)) # 原始回测结果（JSON）\\nprint(result[\\\"LogsCount\\\"], result[\\\"Elapsed\\\"] / 1e6)\\n# task.Show() # 或者显示收益图表（需要 matplotlib）\\n```\\n\\n用```python strategy.py```运行。```task.Join(False)```返回原始回测结果的JSON，```task.Join(True)```返回第一个交易所账户在各快照时刻的盈亏（PnL）和资金占用率（Utilization）组成的pandas表格，```task.Show()```根据账户快照画出权益、盈亏和资金占用图表；两者都不依赖```LogProfit()```。\\n\\n### JavaScript\\n\\n```bash\\nnpm install git+https://github.com/fmzquant/backtest_javascript.git\\n```\\n\\n```javascript\\nvar fmz = require(\\\"fmz\\\")\\nvar task = fmz.VCtx({\\n start: \\\"2026-09-01 00:00:00\\\", end: \\\"2026-09-15 00:00:00\\\", period: \\\"1h\\\", basePeriod: \\\"15m\\\",\\n exchanges: [{eid: \\\"Binance\\\", currency: \\\"BTC_USDT\\\", balance: 10000, stocks: 0}]\\n})\\n// 从这里开始 exchange、Log、TA 等成为全局对象，粘贴策略代码后调用 main()\\n\\nfunction main() {\\n Log(exchange.GetAccount())\\n while (true) {\\n var r = exchange.GetRecords()\\n if (r) {\\n LogStatus(_D(), r[r.length - 1].Close)\\n }\\n Sleep(60 * 60 * 1000)\\n }\\n}\\n\\ntry {\\n main()\\n} catch (e) {\\n // 虚拟时钟到达结束时间时，引擎抛出 \\\"EOF\\\"\\n}\\nvar result = JSON.parse(task.Join()) // 与 Python 引擎 Join(False) 的结果相同\\nconsole.log(result.LogsCount)\\n```\\n\\n### 与云端回测的区别\\n\\n- 只支持JavaScript和Python策略，不会自动加载模板：策略引用的模板代码需要粘贴到文件中，因此依赖交易类库的PINE、My语言策略不能在本地回测。\\n- 策略参数不会自动注入，需要在代码中定义为全局变量。\\n- 注释中的```start```、```end```按本机时区解析；网络延迟固定为200毫秒，不支持滑点和实盘级Tick模式。\\n- 只读取注释中的```start```、```end```、```period```、```basePeriod```和```exchanges```（其中的```eid```、```currency```、```balance```、```stocks```、```fee```、```feeMin```），忽略```mode```、```args```以及```depthDeep```、```tradesMode```、```feeder```等。没有写```basePeriod```时按```period```推导（1d→1h、1h→30m、30m→15m、15m→5m、5m→1m），没有写```stocks```时默认为3，没有写```fee```时使用引擎内置的费率表，建议都显式写出。\\n\\n### AI回测\\n\\n在AI助手中可以直接让它回测：AI助手通过MCP工具```run_backtest```发起云端回测，用```get_backtest```读取收益、回撤、错误日志等结果，见{@扩展API接口/AI接入 AI接入}。也可以让AI助手在本机安装本地回测引擎，快速修改、回测，再用云端回测确认一次。\", \"title\": \"本地回测引擎\"}, {\"_src_hash\": \"9bd67b2520c70019294927f4a1f14930f9db5c9047bda94c765ee56adeb4a418\", \"desc\": \"在策略编辑页面和回测页面，可以用下表中的快捷键切换页面、保存策略和开始回测。\\n\\n| 快捷键 | 作用 |\\n| - | - |\\n| ```Ctrl + ,``` | 在策略编辑页面和回测页面之间切换（按住```Ctrl```再按```,```） |\\n| ```Ctrl + s``` | 保存策略 |\\n| ```Ctrl + b``` | 开始回测 |\", \"title\": \"回测页面快捷键\"}], \"desc\": \"用历史数据检验策略：回测系统用历史行情驱动策略代码，模拟撮合与账户，给出收益、回撤等结果。回测只反映策略在历史行情下的表现，不代表未来收益。\", \"title\": \"回测系统\"}, {\"_src_hash\": \"c5d1b86d6acc7222d2adc53864bc5e0170c4cdef250a65baf3c461a6d412fe7b\", \"children\": [{\"_src_hash\": \"90a936be8868ffe5af8cbb515dd4b6d6195e2c0fe02db164843f0e4c5394ae7d\", \"desc\": \"JavaScript策略可以用```threading```对象创建真正并行执行的线程，并用消息、共享字典、锁等对象在线程之间通信。本页说明怎么选用、怎么组织线程代码；各函数的参数和返回值见语法手册{@fun/Threads Threads}。\\n\\n### 先选对工具\\n\\n| 需求 | 推荐 | 适用语言 |\\n| - | - | - |\\n| 同时发出几个API请求（如同时取多个交易所的行情），等结果回来 | {@fun/Threads/exchange.Go exchange.Go}，配合{@fun/Threads/EventLoop EventLoop}等待完成事件 | 所有语言 |\\n| 长时间在后台运行的任务：独立的行情采集、风控巡检、耗时计算 | {@fun/Threads/threading/Thread threading.Thread} | 仅JavaScript |\\n| 在策略内提供HTTP、WebSocket或TCP服务 | {@fun/Threads/threading/Serve threading.Serve} | 仅JavaScript |\\n\\n只是并发几个请求时，```exchange.Go()```更简单，也不需要处理线程间的数据传递。本页的```threading```对象只适用于JavaScript策略，Python、Rust策略请使用```exchange.Go()```。\\n\\n回测系统中可以调用这些函数，但线程实际是按顺序执行的，只用于保证代码在回测中能运行。\\n\\n### 线程运行在隔离的环境中\\n\\n传给```threading.Thread()```的函数在一个独立的JavaScript环境中执行，这是写线程代码时最需要注意的一点：\\n\\n- 线程函数**不能引用外部的变量和闭包**，也不能调用策略里自定义的其它函数。需要的数据通过```threading.Thread(func, arg1, arg2, ...)```的参数传入。\\n- 普通对象、数组作为参数时是**深拷贝**：线程里修改它不影响其它线程。需要多个线程看到同一份数据时，使用```threading.Dict()```创建的字典。\\n- 函数也可以作为参数传入；```threading.Thread()```还支持传入函数源码字符串，用于在线程中加载外部库。\\n- 线程里可以直接调用平台的API函数，如```exchange.GetTicker()```、```Log()```。\\n- 线程函数的返回值通过```join()```取回：```t.join().ret```。\\n\\n### 线程之间怎样交换数据\\n\\n| 方式 | 用法 | 说明 |\\n| - | - | - |\\n| 消息 | ```postMessage(msg)```发送，```peekMessage(timeout)```读取，见表后说明 | 每个线程有自己的收件箱，按顺序读取 |\\n| 共享字典 | ```var d = threading.Dict()```，作为参数传入线程后各线程```d.get(key)```、```d.set(key, value)``` | 适合保存「最新状态」，例如最新行情、运行标志 |\\n| 线程数据 | ```t.setData(key, value)```、```t.getData(key)``` | 挂在某个线程对象上的键值，线程结束（```join()```、```terminate()```）后失效 |\\n| 同步对象 | ```threading.Lock()```、```threading.Event()```、```threading.Condition()``` | 作为参数传入线程，用于互斥访问和等待通知 |\\n\\n消息的收发：```t.postMessage(msg)```发给线程```t```；线程内用```threading.currentThread().peekMessage(timeout)```读取自己收到的消息，```peekMessage(-1)```不阻塞，没有消息时返回空值；子线程用```threading.mainThread().postMessage(msg)```发回主线程。\\n\\n线程收到消息时也会产生事件，可以用线程对象的{@fun/Threads/Thread/eventLoop eventLoop}统一等待消息和其它事件。\\n\\n### 线程的生命周期\\n\\n- ```t.join()```等待线程结束并取回返回值，可以设置超时；```t.terminate()```强制结束线程。\\n- 线程结束且不再被引用时，资源会自动回收，不必为了释放资源调用```join()```。线程数量没有固定上限（2000个的上限只针对```exchange.Go()```、```HttpQuery_Go()```尚未取走结果的并发任务）。\\n- ```threading.pending()```返回正在运行的线程数（包括主线程）。\\n- 实盘停止时所有线程一起结束。```peekMessage()```、```join()```、锁和事件的等待都会被停止打断。\\n\\n### 在策略内提供服务\\n\\n```threading.Serve(地址, 处理函数, ...参数)```在策略进程内启动HTTP（含WebSocket）或TCP服务，每个请求或连接在独立的线程中调用处理函数，返回{@fun/Threads/Server Server}对象（```addr()```取实际监听地址，```close()```关闭）。处理函数与线程函数一样运行在隔离环境中，需要的数据通过参数传入，常用```threading.Dict()```与主线程共享状态。地址写法、```ctx```对象的方法见{@fun/Threads/threading/Serve Serve}。\\n\\n旧的全局函数```__Serve()```仍可使用，它只返回监听地址字符串，新代码请使用```threading.Serve()```。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var symbols = [\\\"BTC_USDT\\\", \\\"ETH_USDT\\\", \\\"SOL_USDT\\\"]\\n var threads = []\\n for (var i = 0; i < symbols.length; i++) {\\n threads.push(threading.Thread(function(symbol, period) {\\n // 在线程中运行：只能使用参数和平台API\\n var records = exchange.GetRecords(symbol, period)\\n if (!records || records.length < 20) {\\n return null\\n }\\n var ma = TA.MA(records, 20)\\n var close = records[records.length - 1].Close\\n return {symbol: symbol, close: close, ma20: ma[ma.length - 1]}\\n }, symbols[i], PERIOD_H1))\\n }\\n for (var i = 0; i < threads.length; i++) {\\n var r = threads[i].join().ret\\n if (r) {\\n Log(r.symbol, \\\"收盘价:\\\", r.close, \\\"MA20:\\\", r.ma20)\\n }\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"多个线程并行计算，主线程汇总结果；交易对通过参数传入，线程函数不引用外部变量。\"}, {\"examples\": [{\"code\": \"function main() {\\n var shared = threading.Dict()\\n var worker = threading.Thread(function(dict, symbol) {\\n while (true) {\\n // 读取主线程发来的指令，-1 表示不阻塞\\n var cmd = threading.currentThread().peekMessage(-1)\\n if (cmd == \\\"stop\\\") {\\n break\\n }\\n var ticker = exchange.GetTicker(symbol)\\n if (ticker) {\\n dict.set(\\\"last\\\", ticker.Last)\\n dict.set(\\\"time\\\", ticker.Time)\\n } else {\\n threading.mainThread().postMessage(\\\"行情获取失败: \\\" + GetLastError())\\n }\\n Sleep(1000)\\n }\\n return \\\"worker exited\\\"\\n }, shared, \\\"BTC_USDT\\\")\\n\\n for (var i = 0; i < 10; i++) {\\n // 最多等 1 秒后台线程的消息\\n var msg = threading.currentThread().peekMessage(1000)\\n if (msg) {\\n Log(\\\"后台线程报告:\\\", msg)\\n }\\n LogStatus(\\\"最新价:\\\", shared.get(\\\"last\\\"), \\\"时间:\\\", _D(shared.get(\\\"time\\\")))\\n }\\n worker.postMessage(\\\"stop\\\")\\n Log(worker.join().ret)\\n}\", \"lang\": \"javascript\"}], \"value\": \"后台线程把最新价写进共享字典、用消息报告异常，主线程用消息通知它退出。\"}, {\"examples\": [{\"code\": \"function main() {\\n var state = threading.Dict()\\n var server = threading.Serve(\\\"http://127.0.0.1:8088\\\", function(ctx, st) {\\n if (ctx.path() == \\\"/status\\\") {\\n ctx.setHeader(\\\"Content-Type\\\", \\\"application/json\\\")\\n ctx.write(JSON.stringify({last: st.get(\\\"last\\\"), updated: st.get(\\\"updated\\\")}))\\n } else {\\n ctx.setStatus(404)\\n }\\n }, state)\\n Log(\\\"服务地址:\\\", server.addr())\\n\\n while (true) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (ticker) {\\n state.set(\\\"last\\\", ticker.Last)\\n state.set(\\\"updated\\\", _D())\\n }\\n Sleep(3000)\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"用```threading.Serve```提供状态查询接口：HTTP处理函数从参数取到共享字典，返回JSON。\"}], \"seeAlso\": [\"{@fun/Threads Threads}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/Serve Serve}, {@fun/Threads/exchange.Go exchange.Go}, {@fun/Threads/EventLoop EventLoop}\"], \"title\": \"JavaScript多线程\"}, {\"_src_hash\": \"bec02afd52b25673a2faaea4588ba32f049c46956aa8009d866d93c7abb4799c\", \"desc\": \"每个实盘都有一个频道，频道ID就是实盘ID。实盘用```SetChannelData()```在自己的频道上发布数据，其它实盘用```GetChannelData(实盘ID)```读取。数据经平台服务端转发，可以跨托管者、跨服务器传递。\\n\\n频道保存的是**最新状态**，不是消息队列：每次发布都覆盖上一次的数据，订阅端每次读到的都是当前最新的一份。需要历史记录时由订阅端自己保存。\\n\\n常见用途：\\n\\n- **主从协同**：主策略分析行情并发布信号，多个从策略读取信号在各自账户上执行。\\n- **状态监控**：各策略发布运行状态，监控实盘汇总展示或告警。\\n- **数据共享**：一个实盘计算指标、发布结果，其它实盘直接使用，避免重复计算。\\n\\n### 使用要点\\n\\n- **首次读取即订阅**：对某个频道第一次调用```GetChannelData()```时完成订阅并返回空值（```null```/```None```），之后服务端把该频道的更新推送到本实盘，再调用就能读到最新数据。订阅端应在启动时就开始读取，并处理空值。\\n- **订阅上限**：每个实盘最多订阅10个不同的频道（包括下面的UUID频道）。超出时该次调用返回空值（```null```/```None```），并记录一条错误日志```channel subscriber exceed limit```，策略不会因此中止。\\n- **数据格式**：JavaScript、Python的```SetChannelData()```可以传入任何可以JSON序列化的数据，订阅端读到的是解析后的对象。数据不变时不会重复发送。数据大小限制见{@fun/Storage/SetChannelData SetChannelData}。\\n- **Rust**：```SetChannelData(string)```只接受字符串，需要自己拼好JSON文本；```GetChannelData()```不带参数，读取的是本实盘自己的频道；读取其它实盘或UUID频道用```GetChannelDataOf(频道ID)```，返回```JsonValue```（首次调用为```Null```，数据是JSON时为解析后的值，否则为字符串）。\\n- **跨平台推送**：外部系统（如TradingView告警、自建程序）可以通过扩展API的```method=pub```向指定实盘推送一个以32位UUID标识的频道数据，实盘用```GetChannelData(UUID)```读取，请求格式与投递规则见{@扩展API接口/扩展API接口详解/pub pub}，另见{@fun/Storage/GetChannelData GetChannelData}。\\n- **实盘功能**：频道通信用于实盘之间，回测时不要依赖它。当前实盘ID可以用```_G()```获取。\\n- 不要在频道中传递密钥等敏感信息。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var robotId = _G() // 当前实盘ID，也就是本实盘的频道ID\\n var updateId = 0\\n\\n while (true) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (ticker) {\\n // 发布最新状态，覆盖上一次的数据\\n SetChannelData({\\n robotId: robotId,\\n updateId: ++updateId,\\n timestamp: Date.now(),\\n symbol: \\\"BTC_USDT\\\",\\n lastPrice: ticker.Last\\n })\\n LogStatus(\\\"频道\\\", robotId, \\\"第\\\", updateId, \\\"次发布，最新价:\\\", ticker.Last)\\n }\\n Sleep(60000) // 每分钟发布一次\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import time\\n\\ndef main():\\n robotId = _G() # 当前实盘ID，也就是本实盘的频道ID\\n updateId = 0\\n\\n while True:\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if ticker:\\n updateId += 1\\n # 发布最新状态，覆盖上一次的数据\\n SetChannelData({\\n \\\"robotId\\\": robotId,\\n \\\"updateId\\\": updateId,\\n \\\"timestamp\\\": int(time.time() * 1000),\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"lastPrice\\\": ticker[\\\"Last\\\"]\\n })\\n LogStatus(\\\"频道\\\", robotId, \\\"第\\\", updateId, \\\"次发布，最新价:\\\", ticker[\\\"Last\\\"])\\n Sleep(60000) # 每分钟发布一次\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n let robotId = _G!(); // 当前实盘ID，也就是本实盘的频道ID\\n let mut updateId = 0;\\n\\n loop {\\n if let Ok(ticker) = exchange.GetTicker(\\\"BTC_USDT\\\") {\\n updateId += 1;\\n // Rust 的 SetChannelData 只接受字符串，自己拼 JSON 文本\\n let state = format!(\\n r#\\\"{{\\\"robotId\\\": \\\"{}\\\", \\\"updateId\\\": {}, \\\"timestamp\\\": {},\\n \\\"symbol\\\": \\\"BTC_USDT\\\", \\\"lastPrice\\\": {}}}\\\"#,\\n robotId, updateId, Unix() * 1000, ticker.Last\\n );\\n SetChannelData(&state);\\n LogStatus!(\\\"频道\\\", robotId, \\\"第\\\", updateId, \\\"次发布，最新价:\\\", ticker.Last);\\n }\\n Sleep(60000); // 每分钟发布一次\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"广播端：发布行情摘要。\"}, {\"examples\": [{\"code\": \"function main() {\\n // 要订阅的实盘ID（按实际情况修改）\\n var channels = [\\\"632799\\\", \\\"632800\\\"]\\n\\n while (true) {\\n var msg = \\\"\\\"\\n for (var i = 0; i < channels.length; i++) {\\n // 第一次调用完成订阅并返回 null，之后返回最新数据\\n var state = GetChannelData(channels[i])\\n if (state) {\\n msg += \\\"频道 \\\" + channels[i] + \\\"：#\\\" + state.updateId + \\\" \\\" +\\n _D(state.timestamp) + \\\" 最新价 \\\" + state.lastPrice + \\\"\\\\n\\\"\\n } else {\\n msg += \\\"频道 \\\" + channels[i] + \\\"：等待数据\\\\n\\\"\\n }\\n }\\n LogStatus(msg)\\n Sleep(5000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 要订阅的实盘ID（按实际情况修改）\\n channels = [\\\"632799\\\", \\\"632800\\\"]\\n\\n while True:\\n msg = \\\"\\\"\\n for ch in channels:\\n # 第一次调用完成订阅并返回 None，之后返回最新数据\\n state = GetChannelData(ch)\\n if state:\\n msg += \\\"频道 {}：#{} {} 最新价 {}\\\\n\\\".format(\\n ch, state[\\\"updateId\\\"], _D(state[\\\"timestamp\\\"]), state[\\\"lastPrice\\\"])\\n else:\\n msg += \\\"频道 {}：等待数据\\\\n\\\".format(ch)\\n LogStatus(msg)\\n Sleep(5000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n // 要订阅的实盘ID（按实际情况修改）\\n let channels = [\\\"632799\\\", \\\"632800\\\"];\\n\\n loop {\\n let mut msg = String::new();\\n for ch in channels.iter() {\\n // 第一次调用完成订阅并返回 Null，之后返回最新数据\\n let state = GetChannelDataOf(*ch);\\n if !state.is_null() {\\n msg += &format!(\\\"频道 {}：#{} {} 最新价 {}\\\\n\\\", ch,\\n state[\\\"updateId\\\"].as_i64().unwrap_or(0),\\n _D(state[\\\"timestamp\\\"].as_i64().unwrap_or(0)),\\n state[\\\"lastPrice\\\"].as_f64().unwrap_or(0.0));\\n } else {\\n msg += &format!(\\\"频道 {}：等待数据\\\\n\\\", ch);\\n }\\n }\\n LogStatus!(msg);\\n Sleep(5000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"订阅端：读取两个频道。\"}, {\"examples\": [{\"code\": \"function main() {\\n while (true) {\\n var records = exchange.GetRecords(\\\"BTC_USDT\\\")\\n if (records && records.length >= 21) {\\n var ma5 = TA.MA(records, 5)\\n var ma20 = TA.MA(records, 20)\\n var n = records.length\\n var signal = \\\"HOLD\\\"\\n if (ma5[n - 1] > ma20[n - 1] && ma5[n - 2] <= ma20[n - 2]) {\\n signal = \\\"BUY\\\"\\n } else if (ma5[n - 1] < ma20[n - 1] && ma5[n - 2] >= ma20[n - 2]) {\\n signal = \\\"SELL\\\"\\n }\\n SetChannelData({\\n timestamp: Date.now(),\\n symbol: \\\"BTC_USDT\\\",\\n signal: signal,\\n price: records[n - 1].Close\\n })\\n LogStatus(\\\"当前信号:\\\", signal, \\\"价格:\\\", records[n - 1].Close)\\n }\\n Sleep(60000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import time\\n\\ndef main():\\n while True:\\n records = exchange.GetRecords(\\\"BTC_USDT\\\")\\n if records and len(records) >= 21:\\n ma5 = TA.MA(records, 5)\\n ma20 = TA.MA(records, 20)\\n signal = \\\"HOLD\\\"\\n if ma5[-1] > ma20[-1] and ma5[-2] <= ma20[-2]:\\n signal = \\\"BUY\\\"\\n elif ma5[-1] < ma20[-1] and ma5[-2] >= ma20[-2]:\\n signal = \\\"SELL\\\"\\n SetChannelData({\\n \\\"timestamp\\\": int(time.time() * 1000),\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"signal\\\": signal,\\n \\\"price\\\": records[-1][\\\"Close\\\"]\\n })\\n LogStatus(\\\"当前信号:\\\", signal, \\\"价格:\\\", records[-1][\\\"Close\\\"])\\n Sleep(60000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n loop {\\n if let Ok(records) = exchange.GetRecords(\\\"BTC_USDT\\\", None, None) {\\n let n = records.len();\\n if n >= 21 {\\n let ma5 = TA.MA(&records, 5);\\n let ma20 = TA.MA(&records, 20);\\n let mut signal = \\\"HOLD\\\";\\n if ma5[n - 1] > ma20[n - 1] && ma5[n - 2] <= ma20[n - 2] {\\n signal = \\\"BUY\\\";\\n } else if ma5[n - 1] < ma20[n - 1] && ma5[n - 2] >= ma20[n - 2] {\\n signal = \\\"SELL\\\";\\n }\\n let price = records[n - 1].Close;\\n // Rust 的 SetChannelData 只接受字符串，自己拼 JSON 文本\\n let data = format!(\\n r#\\\"{{\\\"timestamp\\\": {}, \\\"symbol\\\": \\\"BTC_USDT\\\", \\\"signal\\\": \\\"{}\\\", \\\"price\\\": {}}}\\\"#,\\n Unix() * 1000, signal, price\\n );\\n SetChannelData(&data);\\n LogStatus!(\\\"当前信号:\\\", signal, \\\"价格:\\\", price);\\n }\\n }\\n Sleep(60000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"场景一，主从策略协同：主策略计算均线交叉信号并发布。\"}, {\"examples\": [{\"code\": \"function main() {\\n var masterId = \\\"632799\\\" // 主策略的实盘ID\\n var lastSignal = null\\n\\n while (true) {\\n var data = GetChannelData(masterId)\\n if (!data) {\\n LogStatus(\\\"等待主策略信号...\\\")\\n } else {\\n if (data.signal !== lastSignal) {\\n Log(\\\"收到新信号:\\\", data.signal, \\\"信号价格:\\\", data.price)\\n var ticker = exchange.GetTicker(data.symbol)\\n if (ticker && data.signal === \\\"BUY\\\") {\\n exchange.CreateOrder(data.symbol, \\\"buy\\\", ticker.Last, 0.01)\\n } else if (ticker && data.signal === \\\"SELL\\\") {\\n exchange.CreateOrder(data.symbol, \\\"sell\\\", ticker.Last, 0.01)\\n }\\n lastSignal = data.signal\\n }\\n LogStatus(\\\"当前信号:\\\", data.signal, \\\"信号时间:\\\", _D(data.timestamp))\\n }\\n Sleep(5000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n masterId = \\\"632799\\\" # 主策略的实盘ID\\n lastSignal = None\\n\\n while True:\\n data = GetChannelData(masterId)\\n if not data:\\n LogStatus(\\\"等待主策略信号...\\\")\\n else:\\n if data[\\\"signal\\\"] != lastSignal:\\n Log(\\\"收到新信号:\\\", data[\\\"signal\\\"], \\\"信号价格:\\\", data[\\\"price\\\"])\\n ticker = exchange.GetTicker(data[\\\"symbol\\\"])\\n if ticker and data[\\\"signal\\\"] == \\\"BUY\\\":\\n exchange.CreateOrder(data[\\\"symbol\\\"], \\\"buy\\\", ticker[\\\"Last\\\"], 0.01)\\n elif ticker and data[\\\"signal\\\"] == \\\"SELL\\\":\\n exchange.CreateOrder(data[\\\"symbol\\\"], \\\"sell\\\", ticker[\\\"Last\\\"], 0.01)\\n lastSignal = data[\\\"signal\\\"]\\n LogStatus(\\\"当前信号:\\\", data[\\\"signal\\\"], \\\"信号时间:\\\", _D(data[\\\"timestamp\\\"]))\\n Sleep(5000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n let masterId = \\\"632799\\\"; // 主策略的实盘ID\\n let mut lastSignal = String::new();\\n\\n loop {\\n let data = GetChannelDataOf(masterId);\\n if data.is_null() {\\n LogStatus!(\\\"等待主策略信号...\\\");\\n } else {\\n let signal = data[\\\"signal\\\"].as_str().unwrap_or(\\\"\\\").to_string();\\n let symbol = data[\\\"symbol\\\"].as_str().unwrap_or(\\\"BTC_USDT\\\");\\n if signal != lastSignal {\\n Log!(\\\"收到新信号:\\\", signal.as_str(), \\\"信号价格:\\\", data[\\\"price\\\"].as_f64().unwrap_or(0.0));\\n if let Ok(ticker) = exchange.GetTicker(symbol) {\\n if signal == \\\"BUY\\\" {\\n let _ = exchange.CreateOrder(symbol, \\\"buy\\\", ticker.Last, 0.01);\\n } else if signal == \\\"SELL\\\" {\\n let _ = exchange.CreateOrder(symbol, \\\"sell\\\", ticker.Last, 0.01);\\n }\\n }\\n lastSignal = signal.clone();\\n }\\n let ts = data[\\\"timestamp\\\"].as_i64().unwrap_or(0);\\n LogStatus!(\\\"当前信号:\\\", signal.as_str(), \\\"信号时间:\\\", _D(ts));\\n }\\n Sleep(5000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"场景一，主从策略协同：从策略读取信号，在信号变化时下单。\"}, {\"examples\": [{\"code\": \"function main() {\\n var monitorList = [\\\"632799\\\", \\\"632800\\\", \\\"632801\\\"] // 最多10个\\n\\n while (true) {\\n var table = {\\n type: \\\"table\\\", title: \\\"策略运行状态\\\",\\n cols: [\\\"实盘ID\\\", \\\"状态\\\", \\\"最后更新\\\", \\\"交易对\\\", \\\"最新价\\\"], rows: []\\n }\\n for (var i = 0; i < monitorList.length; i++) {\\n var data = GetChannelData(monitorList[i])\\n if (data) {\\n var status = Date.now() - data.timestamp < 120000 ? \\\"运行中\\\" : \\\"异常\\\"\\n table.rows.push([monitorList[i], status, _D(data.timestamp),\\n data.symbol || \\\"-\\\", data.lastPrice || \\\"-\\\"])\\n } else {\\n table.rows.push([monitorList[i], \\\"等待数据\\\", \\\"-\\\", \\\"-\\\", \\\"-\\\"])\\n }\\n }\\n LogStatus(\\\"`\\\" + JSON.stringify(table) + \\\"`\\\")\\n Sleep(10000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import json\\nimport time\\n\\ndef main():\\n monitorList = [\\\"632799\\\", \\\"632800\\\", \\\"632801\\\"] # 最多10个\\n\\n while True:\\n table = {\\n \\\"type\\\": \\\"table\\\", \\\"title\\\": \\\"策略运行状态\\\",\\n \\\"cols\\\": [\\\"实盘ID\\\", \\\"状态\\\", \\\"最后更新\\\", \\\"交易对\\\", \\\"最新价\\\"], \\\"rows\\\": []\\n }\\n for robotId in monitorList:\\n data = GetChannelData(robotId)\\n if data:\\n status = \\\"运行中\\\" if time.time() * 1000 - data[\\\"timestamp\\\"] < 120000 else \\\"异常\\\"\\n table[\\\"rows\\\"].append([robotId, status, _D(data[\\\"timestamp\\\"]),\\n data.get(\\\"symbol\\\", \\\"-\\\"), data.get(\\\"lastPrice\\\", \\\"-\\\")])\\n else:\\n table[\\\"rows\\\"].append([robotId, \\\"等待数据\\\", \\\"-\\\", \\\"-\\\", \\\"-\\\"])\\n LogStatus(\\\"`\\\" + json.dumps(table) + \\\"`\\\")\\n Sleep(10000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n let monitorList = [\\\"632799\\\", \\\"632800\\\", \\\"632801\\\"]; // 最多10个\\n\\n loop {\\n let mut rows = Vec::new();\\n for robotId in monitorList.iter() {\\n let data = GetChannelDataOf(*robotId);\\n if !data.is_null() {\\n let ts = data[\\\"timestamp\\\"].as_i64().unwrap_or(0);\\n let status = if Unix() * 1000 - ts < 120000 { \\\"运行中\\\" } else { \\\"异常\\\" };\\n let price = data[\\\"lastPrice\\\"].as_f64()\\n .map(|p| p.to_string()).unwrap_or(\\\"-\\\".to_string());\\n rows.push(format!(r#\\\"[\\\"{}\\\", \\\"{}\\\", \\\"{}\\\", \\\"{}\\\", \\\"{}\\\"]\\\"#, robotId, status, _D(ts),\\n data[\\\"symbol\\\"].as_str().unwrap_or(\\\"-\\\"), price));\\n } else {\\n rows.push(format!(r#\\\"[\\\"{}\\\", \\\"等待数据\\\", \\\"-\\\", \\\"-\\\", \\\"-\\\"]\\\"#, robotId));\\n }\\n }\\n let table = format!(\\n r#\\\"{{\\\"type\\\": \\\"table\\\", \\\"title\\\": \\\"策略运行状态\\\",\\n \\\"cols\\\": [\\\"实盘ID\\\", \\\"状态\\\", \\\"最后更新\\\", \\\"交易对\\\", \\\"最新价\\\"], \\\"rows\\\": [{}]}}\\\"#,\\n rows.join(\\\", \\\"));\\n LogStatus!(format!(\\\"`{}`\\\", table));\\n Sleep(10000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"场景二，多策略状态监控：各策略按广播端的方式发布状态，监控实盘读取所有频道并用表格展示，超过2分钟没有更新的标记为异常。\"}], \"seeAlso\": [\"{@fun/Storage/SetChannelData SetChannelData}, {@fun/Storage/GetChannelData GetChannelData}, {@fun/Storage/_G _G}\"], \"title\": \"策略实盘间通信\"}, {\"_src_hash\": \"0304535c7f5aa4a5d05cf0815562a1e6152be9d3d83d40ab2f139bf1e65ec029\", \"desc\": \"交易所对API调用频率有限制，超限轻则请求被拒，重则账号被临时封禁。用```exchange.IO(\\\"rate\\\", ...)```或```exchange.IO(\\\"quota\\\", ...)```可以在托管者本地给标准函数设置调用频率上限：超限的调用不会发出请求。\\n\\n```javascript\\nexchange.IO(\\\"rate\\\" | \\\"quota\\\", 名字, 次数, 窗口[, \\\"delay\\\"])\\n```\\n\\n### 两种模式\\n\\n- **rate（令牌桶）**：桶容量默认等于```次数```，开始时是满的，之后按「次数/窗口」的速度匀速补充，每次调用消耗一个。允许短时间连续调用，长期平均不超过「次数/窗口」。```次数```写成```\\\"10/5\\\"```时表示每个窗口补充10次、桶容量为5，用来限制突发。\\n- **quota（固定窗口）**：每个窗口内最多调用```次数```次，进入下一个窗口时清零。窗口按时间纪元对齐：```1s```对齐整秒，```1m```对齐整分钟，```1h```对齐整点，```1d```对齐UTC零点（即北京时间08:00）。例如12:00:00.900开始计数，到12:00:01.000就进入了新窗口。\\n\\n需要严格保证「任意一个交易所计数周期内不超过N次」时用```quota```并让窗口与交易所的计数周期一致；只需要控制平均频率时用```rate```。\\n\\n### 参数\\n\\n参数写法（多个函数名用逗号分隔、```*```兜底规则、```rate```模式的```\\\"次数/突发\\\"```、窗口时长与```@HHMM```每日定时清零、```delay```动作、删除规则）见语法手册{@fun/IO/exchange.IO exchange.IO}分类中的```exchange.IO(\\\"rate\\\", ...)```。\\n\\n### 可以限制的函数名\\n\\n| 类别 | 名字 |\\n| - | - |\\n| 行情 | ```GetTicker```、```GetTickers```、```GetDepth```、```GetTrades```、```GetRecords```、```GetMarkets```、```GetFundings``` |\\n| 账户 | ```GetAccount```、```GetAssets```、```GetPositions```、```SetMarginLevel``` |\\n| 交易 | ```CreateOrder```（```Buy```、```Sell```也计入）、```CancelOrder```、```ModifyOrder``` |\\n| 订单查询 | ```GetOrder```、```GetOrders```、```GetHistoryOrders``` |\\n| 条件单 | ```CreateConditionOrder```、```ModifyConditionOrder```、```CancelConditionOrder``` |\\n| 条件单查询 | ```GetConditionOrder```、```GetConditionOrders```、```GetHistoryConditionOrders``` |\\n| 自定义请求 | ```IO/api```：只限制```exchange.IO(\\\"api\\\", ...)```，不影响其它```exchange.IO()```指令 |\\n\\n- ```GetAccount```和```GetAssets```是同一个底层请求，写其中任何一个名字的规则对两个函数都生效。\\n- 通过```exchange.Go()```并发调用时，按实际调用的函数计数。\\n\\n### 规则的作用范围\\n\\n- 规则按交易所对象分别设置：```exchanges[0]```上的规则不影响```exchanges[1]```。\\n- 规则只在本次运行中有效，实盘重启后需要重新设置，通常写在```main()```开头。\\n- 同一个名字再次设置时覆盖原规则；名字传空字符串（```exchange.IO(\\\"rate\\\", \\\"\\\")```）清空该交易所对象上的全部规则。\\n- 一次调用只按一条规则计数：有专属规则的函数不再计入```*```，所以```*```不能当作「所有调用的总配额」叠加在专属规则之上。\\n\\n### 超限时的表现\\n\\n默认动作下，超限的调用不发请求，按调用失败处理（JavaScript返回```null```，Python返回```None```，Rust返回```Err```），错误信息形如：\\n\\n```text\\nrate limit exceeded: GetTicker 10/1s\\nquota limit exceeded: GetTicker 10/1m\\nquota limit exceeded: GetRecords 2000/day (resets at 0800)\\n```\\n\\n使用```delay```动作时调用会阻塞到有可用次数，日志中记录的调用时间是等待结束之后的时间。对每天清零的规则使用```delay```，最长可能等待到第二天，请谨慎使用。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n // GetTicker 平均每秒最多 5 次（令牌桶，容量 5）\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\")\\n\\n for (var i = 0; i < 10; i++) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (ticker) {\\n Log(\\\"第\\\", i + 1, \\\"次成功:\\\", ticker.Last)\\n } else {\\n // 超限的调用不发请求，返回 null\\n Log(\\\"第\\\", i + 1, \\\"次被限流:\\\", GetLastError())\\n }\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # GetTicker 平均每秒最多 5 次（令牌桶，容量 5）\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\")\\n\\n for i in range(10):\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if ticker:\\n Log(\\\"第\\\", i + 1, \\\"次成功:\\\", ticker[\\\"Last\\\"])\\n else:\\n # 超限的调用不发请求，返回 None\\n Log(\\\"第\\\", i + 1, \\\"次被限流:\\\", GetLastError())\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n // GetTicker 平均每秒最多 5 次（令牌桶，容量 5）\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\"));\\n\\n for i in 0..10 {\\n match exchange.GetTicker(\\\"BTC_USDT\\\") {\\n Ok(ticker) => Log!(\\\"第\\\", i + 1, \\\"次成功:\\\", ticker.Last),\\n // 超限的调用不发请求，返回 Err\\n Err(e) => Log!(\\\"第\\\", i + 1, \\\"次被限流:\\\", e),\\n }\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"默认动作：超限的调用直接失败。\"}, {\"examples\": [{\"code\": \"function main() {\\n // 行情：GetTicker、GetDepth 合计平均每秒 20 次\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\")\\n // 交易：下单（含 Buy/Sell）、撤单合计每秒 5 次，超限时等待\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\")\\n // 兜底：其它函数（如 GetAccount、GetPositions）合计每分钟 60 次，窗口对齐整分钟\\n exchange.IO(\\\"quota\\\", \\\"*\\\", 60, \\\"1m\\\")\\n\\n while (true) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n var depth = exchange.GetDepth(\\\"BTC_USDT\\\")\\n if (ticker && depth) {\\n Log(\\\"最新价:\\\", ticker.Last, \\\"买一:\\\", depth.Bids[0].Price)\\n }\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 行情：GetTicker、GetDepth 合计平均每秒 20 次\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\")\\n # 交易：下单（含 Buy/Sell）、撤单合计每秒 5 次，超限时等待\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\")\\n # 兜底：其它函数（如 GetAccount、GetPositions）合计每分钟 60 次，窗口对齐整分钟\\n exchange.IO(\\\"quota\\\", \\\"*\\\", 60, \\\"1m\\\")\\n\\n while True:\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n depth = exchange.GetDepth(\\\"BTC_USDT\\\")\\n if ticker and depth:\\n Log(\\\"最新价:\\\", ticker[\\\"Last\\\"], \\\"买一:\\\", depth[\\\"Bids\\\"][0][\\\"Price\\\"])\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n // 行情：GetTicker、GetDepth 合计平均每秒 20 次\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\"));\\n // 交易：下单（含 Buy/Sell）、撤单合计每秒 5 次，超限时等待\\n let _ = exchange.IO((\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\"));\\n // 兜底：其它函数（如 GetAccount、GetPositions）合计每分钟 60 次，窗口对齐整分钟\\n let _ = exchange.IO((\\\"quota\\\", \\\"*\\\", 60, \\\"1m\\\"));\\n\\n loop {\\n let (t, d) = (exchange.GetTicker(\\\"BTC_USDT\\\"), exchange.GetDepth(\\\"BTC_USDT\\\"));\\n if let (Ok(ticker), Ok(depth)) = (t, d) {\\n Log!(\\\"最新价:\\\", ticker.Last, \\\"买一:\\\", depth.Bids[0].Price);\\n }\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"按交易所的限频规则分组设置：行情和交易各共用一条规则，交易类超限时等待而不是失败，其余函数用```*```兜底。\"}, {\"examples\": [{\"code\": \"function main() {\\n // 平均每秒 10 次，但最多连续突发 2 次\\n exchange.IO(\\\"rate\\\", \\\"GetDepth\\\", \\\"10/2\\\", \\\"1s\\\")\\n // 每天北京时间 08:00 清零，每天最多 2000 次\\n exchange.IO(\\\"quota\\\", \\\"GetRecords\\\", 2000, \\\"@0800\\\")\\n // 窗口可以组合单位：每 1 小时 30 分钟最多 100 次\\n exchange.IO(\\\"rate\\\", \\\"GetOrders\\\", 100, \\\"1h30m\\\")\\n\\n // 次数传 0：删除 GetOrders 的规则\\n exchange.IO(\\\"rate\\\", \\\"GetOrders\\\", 0)\\n // 名字传空字符串：清空本交易所对象上的全部规则\\n exchange.IO(\\\"rate\\\", \\\"\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 平均每秒 10 次，但最多连续突发 2 次\\n exchange.IO(\\\"rate\\\", \\\"GetDepth\\\", \\\"10/2\\\", \\\"1s\\\")\\n # 每天北京时间 08:00 清零，每天最多 2000 次\\n exchange.IO(\\\"quota\\\", \\\"GetRecords\\\", 2000, \\\"@0800\\\")\\n # 窗口可以组合单位：每 1 小时 30 分钟最多 100 次\\n exchange.IO(\\\"rate\\\", \\\"GetOrders\\\", 100, \\\"1h30m\\\")\\n\\n # 次数传 0：删除 GetOrders 的规则\\n exchange.IO(\\\"rate\\\", \\\"GetOrders\\\", 0)\\n # 名字传空字符串：清空本交易所对象上的全部规则\\n exchange.IO(\\\"rate\\\", \\\"\\\")\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n // 平均每秒 10 次，但最多连续突发 2 次\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetDepth\\\", \\\"10/2\\\", \\\"1s\\\"));\\n // 每天北京时间 08:00 清零，每天最多 2000 次\\n let _ = exchange.IO((\\\"quota\\\", \\\"GetRecords\\\", 2000, \\\"@0800\\\"));\\n // 窗口可以组合单位：每 1 小时 30 分钟最多 100 次\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetOrders\\\", 100, \\\"1h30m\\\"));\\n\\n // 次数传 0：删除 GetOrders 的规则\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetOrders\\\", 0));\\n // 名字传空字符串：清空本交易所对象上的全部规则\\n let _ = exchange.IO((\\\"rate\\\", \\\"\\\"));\\n}\", \"lang\": \"rust\"}], \"value\": \"突发容量、每日配额，以及删除规则。\"}], \"seeAlso\": [\"{@fun/IO/exchange.IO exchange.IO}, {@fun/Threads/exchange.Go exchange.Go}, {@fun/Global/GetLastError GetLastError}\"], \"title\": \"API限流控制\"}, {\"_src_hash\": \"60319bd6f5d16aa06a0b4ad709b63a5c3a88a48fa1f2ef182cc7d1a1c98e7c6e\", \"desc\": \"发明者量化交易平台支持在下表的加密货币期货交易所交易期权。期权的用法与期货合约相同：用```exchange.SetContractType()```把合约设为期权代码（期权代码就是交易所的原生代码，各交易所写法不同），之后```GetTicker()```、```GetDepth()```等行情函数，```Buy()```、```Sell()```（下单前用```exchange.SetDirection()```设置交易方向）、```CancelOrder()```、```GetPositions()```等交易函数都作用于该期权合约。也可以用完整的交易品种代码直接下单，形如```交易对.期权代码```，例如```BTC_USDT.BTC-261225-100000-C```。\\n\\n期权合约的盘口通常较薄：买一、卖一没有挂单时```Ticker```的```Buy```、```Sell```为0，从未成交的合约```Last```也可能为0，各交易所的处理见交易所页。```exchange.GetMarkets()```是否列出期权合约因交易所而异；不列出时，期权代码需要从交易所的接口或网页获取。\\n\\n| 交易所对象 | 交易对示例 | 期权代码示例 | GetMarkets列出期权 |\\n| - | - | - | - |\\n| {@exchanges/cex/deribit Futures_Deribit} | ```BTC_USD``` | ```BTC-25DEC26-100000-C``` | 是 |\\n| {@exchanges/cex/okx Futures_OKCoin}（OKX 期货） | ```BTC_USD``` | ```BTC-USD-261225-100000-C``` | 否 |\\n| {@exchanges/cex/binance Futures_Binance} | ```BTC_USDT``` | ```BTC-261225-100000-C``` | 否 |\\n| {@exchanges/cex/bybit Futures_Bybit} | ```ETH_USDT``` | ```ETH-25JUN27-2800-C-USDT``` | 是 |\\n| {@exchanges/dex/aevo Futures_Aevo} | ```ETH_USDC``` | ```ETH-25DEC26-3000-C``` | 是 |\\n| {@exchanges/cex/gate Futures_GateIO} | ```BTC_USDT``` | ```BTC_USDT-20261225-100000-C``` | 是 |\\n| {@exchanges/cex/kraken Futures_Kraken} | ```ETH_USD``` | ```OF_ETHUSD_261225_4000_C``` | 否 |\\n\\n以上代码中的到期日、行权价只是示例，实际可交易的合约以交易所当前挂牌为准。\\n\\n期权的具体规则因交易所而异，写在各交易所页的「期权」一节：期权代码的写法（例如Deribit的组合期权、Kraken代码中BTC写作```XBT```）、```exchange.GetMarkets()```不列出期权时从哪里获取期权代码、下单限制（有的交易所只支持限价单，不支持改单、条件单或```exchange.SetMarginLevel()```），以及```Ticker```的```Last```在没有成交时是否取标记价格。点击上表中的交易所名称查看。\", \"seeAlso\": [\"{@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Futures/exchange.GetPositions exchange.GetPositions}\"], \"title\": \"期权交易\"}, {\"_src_hash\": \"998ed7c7f4a2db3c34679e0e2be54a0fb73fa440940216df6ff9dc9d62c51791\", \"children\": [{\"_src_hash\": \"22902f621bc9d1486cbf6337296ea3d580aa3de384c0f28ebe598c8d63d44541\", \"desc\": \"Uniswap交易所对象（```exchange.GetName()```返回```Uniswap```）在一条EVM链上连接Uniswap、PancakeSwap或Aerodrome的池子，把链上兑换映射为现货交易函数：用```exchange.GetTicker()```看价格、用```exchange.CreateOrder()```下单，不需要自己注册ABI、编码合约调用。选路、询价、代币授权、价格保护、发送交易都由交易所对象完成。同一套实现还有两个聚合器版本：```KyberSwap```与```OneInch```（1inch），报价和交易数据来自聚合器，在众多DEX和做市商之间拆单选路。\\n\\n### 选哪个交易所对象\\n\\n| 需求 | 交易所对象 |\\n| - | - |\\n| 在指定DEX的池子上兑换，能控制路径（V2/V3/V4、直连或两跳） | ```Uniswap```，配置DEX为Uniswap、PancakeSwap或Aerodrome |\\n| 由聚合器在全网DEX中找最优价，不需要API Key | ```KyberSwap``` |\\n| 由1inch聚合器找最优价（需要1inch API Key） | ```OneInch``` |\\n| 调用其它合约、提供流动性、管理V3头寸、自定义交易 | ```Web3```，见{@进阶专题/Web3/以太坊（EVM）以太坊（EVM）} |\\n| Solana链上兑换 | ```Jupiter```，见{@进阶专题/Web3/Solana兑换（Jupiter） Solana兑换（Jupiter）} |\\n\\n一个策略可以同时添加多个交易所对象，使用同一个钱包，例如用```Uniswap```和```KyberSwap```比价，用```Web3```做其它链上操作。\\n\\n### 配置交易所对象\\n\\n- ```DEX```：只有```Uniswap```交易所对象有：```Uniswap```、```PancakeSwap```、```Aerodrome```（只在Base上）\\n- ```Chain```：一个交易所对象只对应一条链，可选的链见下表\\n- ```Private Key```：钱包私钥（十六进制字符串）。可以把私钥本地化部署在托管者上，见{@平台基础/交易所/本地凭据文件本地凭据文件}\\n- ```Rpc Address```：该链的节点地址，选择Chain时自动填入默认节点（```主节点,备用节点```）。多个节点用逗号分隔，某个节点出错或缺少数据时自动换下一个\\n- ```Rpc Api Key```：节点鉴权，可以留空。写成```名称: 值```时作为该名称的请求头发送，否则作为```Authorization: Basic <值>```发送。```OneInch```没有这一项\\n- ```1inch Api Key```：只有```OneInch```有，必填：在1inch开发者门户申请\\n\\n各链可用的DEX与聚合器：\\n\\n| 链 | Uniswap | PancakeSwap | Aerodrome | KyberSwap | OneInch |\\n| - | - | - | - | - | - |\\n| Ethereum | V2、V3、V4 | V2、V3 | — | ✓ | ✓ |\\n| Arbitrum | V3、V4 | V2、V3 | — | ✓ | ✓ |\\n| Base | V3、V4 | V2、V3、Infinity | Slipstream、基础池子 | ✓ | ✓ |\\n| BNB Chain | V3、V4 | V2、V3、Infinity | — | ✓ | ✓ |\\n| Unichain | V2、V3、V4 | — | — | ✓ | ✓ |\\n| Polygon | V3、V4 | — | — | ✓ | ✓ |\\n| OP Mainnet | V3、V4 | — | — | ✓ | ✓ |\\n| Robinhood | V2、V3、V4 | — | — | ✓ | — |\\n| Arc | V2、V3、V4 | — | — | — | — |\\n\\n- V4（Uniswap）和Infinity（PancakeSwap Infinity CL）只使用不带hook的池子；原生币直接参与兑换，不经包装币。\\n- 钱包里需要有该链的原生币支付gas：ETH、BNB；Polygon为POL（包装币WPOL）；Arc用USDC支付gas。\\n- 第一次请求时会核对节点所在的链与Chain是否一致，不一致时报错，不会把交易发到别的链上。\\n- 节点要能查询已上链交易的回执，否则查不到订单状态。publicnode的Base、BNB Chain、Arbitrum公共节点查不到回执，不要单独使用；自己配置节点时先确认这一点。\\n\\n### 交易对\\n\\n- 交易对写作```ETH_USDC```、```UNI_USDT```这样的```基础币_计价币```。\\n- 代币名先查代币表（内置的原生币、包装币、USDC、USDT等常用代币，以及用```exchange.IO(\\\"token\\\", 名字, 合约地址)```登记的代币），再查内置的官方代币列表。同一条链上有同名代币时请改用合约地址，例如```0x1f9840a85d5af5bf1d1762f925bdaddc4201f984_USDC```；直接写合约地址时会从链上读取精度并自动登记。\\n- **原生币与包装币是两种资产**：```ETH```与```WETH```、```BNB```与```WBNB```是不同的币。两者之间不能下单，用```exchange.IO(\\\"wrap\\\", 数量)```、```exchange.IO(\\\"unwrap\\\", 数量)```1:1互换，只花gas。\\n- 链上的特殊写法：Unichain、Polygon上的USDT写作```USDT0```；Robinhood链上没有USDC、USDT，稳定币为USDG（```ETH_USDG```）；Arc上原生余额就是USDC，交易对写作```WETH_USDC```、```EURC_USDC```。\\n- ```exchange.GetMarkets()```只列出常用的交易对，没有列出的交易对同样可以交易。\\n\\n### 下单\\n\\nDEX没有挂单簿，每笔订单都是一次立即执行的链上兑换：要么整笔成交，要么整笔回滚（只损失gas），不会部分成交、也不会挂着等价格。\\n\\n- **限价单**：限价是**最差成交价**。下单时先询价，按当前价格达不到限价时直接报错，不发交易；达得到时把「最少得到/最多支付」写进交易，上链前价格变动导致达不到时整笔回滚。\\n- **市价单**：按询价结果扣除滑点保护，滑点默认0.5%，用```exchange.IO(\\\"slippage\\\", 比例)```修改。\\n- **数量**：卖出时是卖出的基础币数量；限价买入时是要买到的基础币数量；**市价买入时是要花费的计价币数量**。\\n- **聚合器只支持精确输入**：```KyberSwap```、```OneInch```的限价买入按“最多花费数量×价格、至少买到数量”执行，实际买到的可能略多。Aerodrome的基础池子同样只支持精确输入，限价买入只走Slipstream池子。\\n- **单笔设置**：方向参数后可以附加JSON，例如```exchange.CreateOrder(\\\"ETH_USDC\\\", 'sell;{\\\"slippage\\\":0.01,\\\"route\\\":\\\"v3\\\"}', -1, 0.1)```：```slippage```为本单滑点；```route```限定路径类型：```v2```、```v3```、```v4```、```hop```（两跳）、```direct```（直连）。Aerodrome上```v2```指基础池子，```v3```指Slipstream。\\n- **授权**：卖出ERC20代币前会检查授权额度，不够时先发授权交易并等待上链。V2、V3池子授权给路由合约；V4与Infinity经各自的Permit2合约；聚合器直接授权给聚合器的路由合约。默认只授权本次需要的数量，```exchange.IO(\\\"approve\\\", \\\"max\\\")```改为无限授权。\\n- **截止时间**：交易超过截止时间（默认120秒，```exchange.IO(\\\"deadline\\\", 秒数)```修改）仍未上链时会回滚，避免价格大幅变化后才成交。\\n\\n下单前可以用```exchange.IO(\\\"route\\\", ...)```只询价（列出各候选路径的报价），用```exchange.IO(\\\"simulate\\\", ...)```按下单逻辑构造交易并在链上模拟执行，不花gas。\\n\\n### 订单与撤单\\n\\n- 订单ID形如```ETH_USDC,0x…```：交易对、逗号、交易哈希。```exchange.GetOrder()```的状态来自交易回执；订单```Info```中有```chainId```和链名```chain```，跨链汇总或保存订单时用它找回所属的链。用```exchange.IO(\\\"receipt\\\", ...)```查回执时传逗号后面的交易哈希。\\n- ```exchange.GetOrders()```返回本次运行发出、还没有上链的订单。\\n- ```exchange.CancelOrder()```用原订单的nonce发送一笔替换交易，并等待结果（默认最多30秒，```exchange.IO(\\\"cancelWait\\\", 秒数)```修改）：替换交易先上链返回```true```；原订单先上链（或撤单前已经上链）返回```false```；等待超时返回```true```，表示撤单已提交。最终状态以```exchange.GetOrder()```为准：原交易的nonce被替换交易占用时显示为已撤销。\\n\\n### 与中心化交易所的差异\\n\\n- ```exchange.GetTicker()```的买一、卖一是约1000美元规模的实际可成交价，链上没有24小时统计；```exchange.GetDepth()```由逐档递增规模的询价推算，不是真实挂单簿。\\n- ```exchange.GetTrades()```返回该交易对各池子最近的链上成交；聚合器（```KyberSwap```、```OneInch```）不支持。\\n- 不支持```exchange.GetRecords()```、```exchange.GetTickers()```、```exchange.GetHistoryOrders()```。\\n- 1inch免费档每秒1次请求，连接器自动排队，```exchange.GetDepth()```耗时相应较长。\\n\\n各函数的详细行为、```exchange.IO()```指令（```route```、```simulate```、```token```、```transfer```、```receipt```、```wrap```、```unwrap```、```approve```、```slippage```、```deadline```、```cancelWait```、```gasMultiplier```、```contracts```、```base```、```sendBase```、```address```）的参数与返回值见语法手册的{@exchanges/dex/uniswap Uniswap}交易所页。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var symbol = \\\"ETH_USDC\\\"\\n exchange.IO(\\\"slippage\\\", 0.003) // 市价单滑点 0.3%\\n\\n var t = exchange.GetTicker(symbol)\\n Log(\\\"买一:\\\", t.Buy, \\\"卖一:\\\", t.Sell)\\n\\n // 只询价：卖出 0.1 ETH 的最优路径\\n var r = exchange.IO(\\\"route\\\", symbol, \\\"sell\\\", 0.1)\\n if (!r || r.best === null) {\\n Log(\\\"没有可用路径:\\\", GetLastError())\\n return\\n }\\n Log(\\\"最优路径:\\\", r.best, \\\"均价:\\\", r.price)\\n\\n // 链上模拟一遍，不花 gas\\n if (!exchange.IO(\\\"simulate\\\", symbol, \\\"sell\\\", 0.1)) {\\n Log(\\\"模拟失败:\\\", GetLastError())\\n return\\n }\\n\\n // 市价卖出 0.1 ETH，订单 ID 形如 ETH_USDC,0x…\\n var id = exchange.CreateOrder(symbol, \\\"sell\\\", -1, 0.1)\\n if (!id) {\\n Log(\\\"下单失败:\\\", GetLastError())\\n return\\n }\\n while (true) {\\n var o = exchange.GetOrder(id)\\n if (o && o.Status != ORDER_STATE_PENDING) {\\n Log(\\\"状态:\\\", o.Status, \\\"成交数量:\\\", o.DealAmount, \\\"成交均价:\\\", o.AvgPrice)\\n break\\n }\\n Sleep(3000)\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"询价、模拟，然后市价卖出（以太坊上的```ETH_USDC```，同样适用于```KyberSwap```、```OneInch```）；```CreateOrder```会发出真实交易。\"}], \"seeAlso\": [\"{@exchanges/dex/uniswap Uniswap}, {@fun/Trade/exchange.CreateOrder exchange.CreateOrder}, {@fun/Trade/exchange.CancelOrder exchange.CancelOrder}\"], \"title\": \"EVM链上兑换（Uniswap、KyberSwap、1inch）\"}, {\"_src_hash\": \"b421c5f9d3a3d0ddfee475a44e9d483cd9cf1d2b543ce8f3225e746578a68a63\", \"desc\": \"Jupiter交易所对象（```exchange.GetName()```返回```Jupiter```）连接Solana链上的Jupiter聚合器，把兑换映射为现货交易函数。一个交易所对象对应一个Solana钱包：报价和兑换交易由Jupiter生成（它在Solana上的众多DEX和做市商之间拆单选路），托管者用配置的私钥签名后经Solana节点广播。EVM链上的兑换见{@进阶专题/Web3/EVM链上兑换（Uniswap、KyberSwap、1inch） EVM链上兑换（Uniswap、KyberSwap、1inch）}。\\n\\n### 配置交易所对象\\n\\n- ```Private Key```：Solana钱包私钥：Phantom、Solflare导出的base58字符串，或solana-keygen生成的JSON字节数组。可以把私钥本地化部署在托管者上，见{@平台基础/交易所/本地凭据文件本地凭据文件}\\n- ```Rpc Address```：Solana RPC节点，多个用逗号分隔，某个节点出错时自动换下一个；默认为官方公共节点和publicnode\\n- ```Jupiter Api Key```：可选。不填时使用免费的```lite-api.jup.ag```；填写后使用```api.jup.ag```，可以按套餐调高请求速率\\n- ```Liquidity Sources```：可选，限定兑换经过的流动性来源，逗号分隔：```pump```（pump.fun的bonding curve与PumpSwap）、```meteora```、```raydium```、```orca```，或Jupiter的来源名（如```Meteora DLMM```）；不填表示全部来源\\n\\n钱包里需要有SOL支付手续费：每笔交易的基础费与优先费从SOL余额中扣除（优先费上限默认0.001 SOL，可用```exchange.IO(\\\"priorityFee\\\", ...)```修改）。第一次买入某个代币时，钱包要新建该代币的账户，押金约0.002 SOL，押金仍归钱包所有。\\n\\n### 交易对\\n\\n- 交易对写作```SOL_USDC```、```JUP_USDC```、```BONK_SOL```。SOL是原生币，兑换时自动包装、解包。\\n- 内置的常用代币可以直接写名字。其它代币可以写Jupiter代币列表中经过认证、名称完全一致的代币名，或直接写mint地址，或先用```exchange.IO(\\\"token\\\", 名字, mint地址)```登记。\\n- 交易对**不转大写**：mint地址和```mSOL```这类币名区分大小写，按原样书写，例如```DB5QKorV9KHY54y73h5xWQqYyuD8P3jC1p5Ea8DBpump_SOL```。\\n- ```exchange.GetMarkets()```列出代币表中的币与USDC、USDT、SOL组成的交易对；```exchange.GetAssets()```只列出SOL和代币表中代币的余额。\\n\\n### 下单与订单\\n\\n- 每笔订单都是一次立即执行的兑换。限价为最差成交价，由链上程序按滑点强制执行，当前报价已经达不到限价时直接报错、不发交易；市价单按滑点保护（默认0.5%，```exchange.IO(\\\"slippage\\\", 比例)```修改）。市价买入时数量为要花费的计价币。\\n- Jupiter生成交易时会先模拟一遍，余额不足等问题会在下单时直接报错。\\n- 订单ID形如```SOL_USDC,5VERv8…```（交易对、逗号、交易签名）。交易确认后为已成交，成交数量按交易前后的钱包余额计算；链上执行失败为已撤销（手续费照扣）；约1分钟内没有上链的交易过期，显示为已撤销。\\n- ```exchange.GetOrders()```返回本程序发出、尚未确认也未过期的兑换。\\n- **不能撤单**：Solana交易发出后无法撤回，```exchange.CancelOrder()```报错并返回失败，等交易过期即可。\\n- 不支持```exchange.GetTrades()```、```exchange.GetRecords()```、```exchange.GetTickers()```、```exchange.GetHistoryOrders()```。\\n\\n### 请求速率\\n\\nJupiter按每秒请求数限流，超过后返回429。连接器按```exchange.IO(\\\"rps\\\", ...)```设置的速率（默认每秒1次）给请求排队，同一个托管者进程中的多个Jupiter交易所对象共用这个节奏。一次```exchange.GetTicker()```需要两次询价（约2秒），5档```exchange.GetDepth()```约10秒。需要更快时申请Jupiter API Key，并按套餐调高```rps```。\\n\\n### 常用指令\\n\\n```route```（只询价）、```token```（登记代币）、```transfer```（转出SOL）、```receipt```（查询交易状态）、```slippage```、```priorityFee```、```dexes```（运行中修改流动性来源）、```rps```，以及```base```（切换节点）、```address```（钱包地址）。各指令的参数与返回值、各函数的详细行为见语法手册的{@exchanges/dex/jupiter Jupiter}交易所页。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n exchange.IO(\\\"slippage\\\", 0.01) // 市价单滑点 1%\\n\\n var t = exchange.GetTicker(\\\"SOL_USDC\\\")\\n Log(\\\"买一:\\\", t.Buy, \\\"卖一:\\\", t.Sell)\\n\\n // 只询价：卖出 0.1 SOL 能得到多少 USDC\\n var r = exchange.IO(\\\"route\\\", \\\"SOL_USDC\\\", \\\"sell\\\", 0.1)\\n if (!r || r.route === null) {\\n Log(\\\"没有路由:\\\", GetLastError())\\n return\\n }\\n Log(\\\"可得:\\\", r.quote, \\\"USDC\\\", \\\"均价:\\\", r.price, \\\"路由:\\\", r.route.join(\\\" + \\\"))\\n\\n // 市价卖出 0.1 SOL，订单 ID 形如 SOL_USDC,5VERv8…\\n var id = exchange.CreateOrder(\\\"SOL_USDC\\\", \\\"sell\\\", -1, 0.1)\\n if (!id) {\\n Log(\\\"下单失败:\\\", GetLastError())\\n return\\n }\\n while (true) {\\n var o = exchange.GetOrder(id)\\n if (o && o.Status != ORDER_STATE_PENDING) {\\n Log(\\\"状态:\\\", o.Status, \\\"成交数量:\\\", o.DealAmount, \\\"成交均价:\\\", o.AvgPrice)\\n break\\n }\\n Sleep(2000)\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"询价，然后市价卖出；```CreateOrder```会发出真实交易。\"}], \"seeAlso\": [\"{@exchanges/dex/jupiter Jupiter}, {@fun/Trade/exchange.CreateOrder exchange.CreateOrder}\"], \"title\": \"Solana兑换（Jupiter）\"}, {\"_src_hash\": \"bea9dfb6eb7b49d544f90b87579faebe520279e015fa2a4409b94fd53df41a45\", \"desc\": \"Web3交易所对象选择```ChainType```为```ETH```时，可以连接以太坊以及所有EVM兼容链（BSC、Base、Arbitrum、Optimism、Polygon等）的节点，用```exchange.IO()```的各个指令查询余额、调用合约、发送交易。本页按一笔链上操作的流程介绍常用指令，每个指令的完整参数见语法手册的{@exchanges/custom/web3 Web3}交易所页中对应的```exchange.IO(\\\"指令\\\", ...)```。\\n\\n只是想在DEX上兑换代币时，请使用```Uniswap```、```KyberSwap```、```OneInch```交易所对象（见{@进阶专题/Web3/EVM链上兑换（Uniswap、KyberSwap、1inch） EVM链上兑换（Uniswap、KyberSwap、1inch）}）：它直接支持```exchange.GetTicker()```、```exchange.CreateOrder()```等标准函数，不需要自己编码合约调用。\\n\\n### 1. 配置交易所对象\\n\\n在「交易所」页面（```/m/add-platform```）添加交易所，协议选择「加密货币」，交易所选择```Web3```：\\n\\n- ```ChainType```：```ETH```：以太坊及所有EVM兼容链；```TRON```：波场，见{@进阶专题/Web3/波场（TRON）波场（TRON）}\\n- ```Private Key```：钱包私钥（十六进制字符串，可以带```0x```前缀）。支持把私钥本地化部署在托管者上，参看{@入门/密钥安全性密钥安全性}\\n- ```Rpc Address```：节点地址，默认```https://ethereum-rpc.publicnode.com```（以太坊主网公共节点）。连接其它链时填写该链的节点，例如BSC：```https://bsc-dataseed.binance.org```。支持```http(s)://```和```ws(s)://```。可以写多个节点，用逗号分隔，互为备用\\n- ```Rpc Api Key```：节点鉴权，可以留空。写成```名称: 值```（如```x-api-key: xxx```）时作为该名称的请求头发送；否则作为```Authorization: Basic <值>```发送\\n\\n多个节点时，从上次成功的节点开始依次尝试：只有节点不可用（连接失败、超时、限流）时才换下一个，合约执行失败之类的错误直接返回；链ID与第一个节点不同的节点会被跳过，避免把交易发到另一条链。\\n\\n运行中可以用```exchange.IO(\\\"base\\\", 节点地址)```切换节点（多个节点可以传数组或逗号分隔的字符串），用```exchange.IO(\\\"key\\\", 私钥)```切换钱包私钥；获取当前钱包地址用{@exchanges/custom/web3/IO_address exchange.IO(\\\"address\\\")}。\\n\\n标准函数中只有```exchange.GetAccount()```、```exchange.GetAssets()```可用，返回钱包的原生币余额（币种按链ID识别，如BSC为```BNB```）。\\n\\n### 2. 查询余额与读取合约\\n\\n调用合约的只读方法（```view```/```pure```）不消耗gas，直接返回解码后的结果：\\n\\n```javascript\\nexchange.IO(\\\"api\\\", \\\"eth\\\", \\\"eth_getBalance\\\", wallet, \\\"latest\\\") // 原生币余额，链上整数（十六进制字符串）\\nexchange.IO(\\\"api\\\", tokenAddress, \\\"balanceOf\\\", wallet) // ERC20余额，链上整数\\nexchange.IO(\\\"api\\\", tokenAddress, \\\"decimals\\\") // 代币精度\\n```\\n\\n- ```exchange.IO(\\\"api\\\", \\\"eth\\\", 方法, ...参数)```直接调用节点的JSON-RPC方法，如```eth_gasPrice```、```eth_blockNumber```、```eth_getTransactionReceipt```。\\n- ```exchange.IO(\\\"api\\\", 合约地址, 方法, ...参数)```调用合约方法。方法可以写方法名、完整签名（如```\\\"approve(address,uint256)\\\"```，用于区分重载）或方法选择器（如```\\\"0x095ea7b3\\\"```）。\\n- 链上数量都是整数。用```exchange.IO(\\\"fromUnits\\\", 链上整数, 精度)```换算成可读数量，用```exchange.IO(\\\"toUnits\\\", \\\"1.5\\\", 精度)```换算回链上整数；精度也可以直接传代币合约地址。两者都按字符串精确计算。\\n- 批量读取多个合约时用```exchange.IO(\\\"multicall\\\", ...)```一次请求完成；查询事件日志用```exchange.IO(\\\"logs\\\", ...)```。\\n\\n### 3. 注册ABI\\n\\n标准ERC20方法（```balanceOf```、```decimals```、```allowance```、```approve```、```transfer```等）已内置，不需要注册。调用其它合约的方法前，需要用```exchange.IO(\\\"abi\\\", 合约地址, ABI)```注册该合约的ABI。\\n\\n常用合约可以直接使用内置模板，第三个参数传模板名：```weth```、```uniswapV3Pool```、```uniswapV3Factory```、```uniswapV3QuoterV2```、```uniswapV3SwapRouter02```、```uniswapV3PositionManager```、```permit2```（PancakeSwap V3使用相同的模板，也可以写```pancakeV3Pool```等别名）。常用合约的地址可以用```exchange.IO(\\\"contracts\\\")```查询。\\n\\n```javascript\\nexchange.IO(\\\"abi\\\", poolAddress, \\\"uniswapV3Pool\\\")\\nvar slot0 = exchange.IO(\\\"api\\\", poolAddress, \\\"slot0\\\")\\n```\\n\\n其它合约的ABI可以从区块浏览器获取，例如Etherscan的V2接口（需要Etherscan的API Key，```chainid```为链ID，取返回结果中的```result```字段）：\\n\\n```url\\nhttps://api.etherscan.io/v2/api?chainid=1&module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45&apikey=YourApiKey\\n```\\n\\n### 4. 发送交易\\n\\n调用合约的写方法时，交易所对象用配置的私钥签名并广播交易，返回交易哈希。发送前可以把```api```换成```call```，用```exchange.IO(\\\"call\\\", ...)```预演同一笔调用：在节点上模拟执行，不签名、不消耗gas，执行失败时返回空值，```GetLastError()```中有合约给出的失败原因。\\n\\n以授权（approve）为例：\\n\\n```javascript\\nvar amount = exchange.IO(\\\"toUnits\\\", \\\"100\\\", tokenAddress) // 100个代币换算成链上整数\\nvar txHash = exchange.IO(\\\"api\\\", tokenAddress, \\\"approve\\\", spender, amount)\\n```\\n\\n方法的```stateMutability```为```payable```时，方法参数之前要多传一个参数：附带的原生币数量（链上整数）。最后一个参数可以传选项对象：\\n\\n- ```gasLimit```：gas上限。不传时由节点估算（```eth_estimateGas```）。合约调用不要写```21000```，那只够普通转账\\n- ```gasPrice```：固定gas价格，传入时发送传统（legacy）交易。不传时，支持EIP-1559的链发送EIP-1559交易：小费取节点建议值与最近区块实际小费的较大者，最高费用为```2 × baseFee + 小费```\\n- ```nonce```：指定nonce。不传时自动分配，并与链上待处理计数同步，连续发送不会重复使用nonce\\n- ```dryRun```：设为```true```时只签名不广播，返回```hash```、```raw```（签名后的交易）、```nonce```、```gasLimit```等字段，可用于检查交易或交给其它渠道发送\\n\\n转出原生币使用```exchange.IO(\\\"api\\\", \\\"eth\\\", \\\"send\\\", 收款地址, 数量)```，数量是链上整数（wei）。它的选项还支持```data```（十六进制调用数据），用于原样发送聚合器等API返回的交易```{to, data, value}```，此时gas按合约调用估算。注意：普通转账不传```gasPrice```时按固定的100 Gwei出价、gas上限为21000，在以太坊主网上通常偏高，建议先用```eth_gasPrice```查询后传入。\\n\\n需要把交易发到私有交易通道（如Flashbots Protect、MEV Blocker）避免被抢跑时，用```exchange.IO(\\\"sendBase\\\", 节点地址)```设置只用于广播交易的节点。\\n\\n### 5. 等待交易上链\\n\\n```exchange.IO(\\\"waitReceipt\\\", 交易哈希, {timeout, confirmations})```等待交易上链并达到确认数，返回交易回执：```status```为```1```表示成功、```0```表示失败（```revertReason```为失败原因），```events```为按已注册ABI解码的事件。超时未上链时返回空值。\\n\\n### 6. nonce管理、加速与取消\\n\\n- ```exchange.IO(\\\"nonce\\\")```查看链上与本地的nonce计数；```exchange.IO(\\\"nonce\\\", \\\"sync\\\")```按链上重新同步（在别处用同一个钱包发过交易后使用）。\\n- 交易长时间未上链时，用```exchange.IO(\\\"speedUp\\\", 交易哈希)```以同一个nonce、更高的手续费重发；用```exchange.IO(\\\"cancelTx\\\", 交易哈希)```发送一笔同nonce、转给自己的0金额交易顶替原交易。两者都在原交易上链前才有效。\\n- 本地nonce记录只在当前实盘内有效：多个实盘共用一个钱包时彼此看不到对方的记录，仍可能冲突，建议每个实盘使用独立的钱包。\\n\\n### 其它指令\\n\\n- 编码与解码：```exchange.IO(\\\"encode\\\", ...)```编码合约调用数据或按类型编码（同Solidity的```abi.encode```），```exchange.IO(\\\"encodePacked\\\", ...)```紧凑编码（如Uniswap V3的兑换路径），```exchange.IO(\\\"decode\\\", ...)```按类型解码。\\n- 签名：```exchange.IO(\\\"sign\\\", ...)```对32字节哈希签名，```exchange.IO(\\\"signTypedData\\\", ...)```对EIP-712结构化数据签名（如ERC-20 Permit），```exchange.IO(\\\"signMessage\\\", ...)```对消息做EIP-191签名。\\n- Uniswap V3数学：```exchange.IO(\\\"uniswapV3\\\", ...)```在tick、价格、sqrtPrice之间换算，在流动性与代币数量之间换算。\\n- 哈希：```exchange.IO(\\\"hash\\\", \\\"keccak256\\\", \\\"raw\\\", \\\"hex\\\", 文本)```计算keccak256等摘要，可用于计算方法选择器、EIP-712摘要，参数与```Encode()```函数相同。\\n- 完整范例：通过聚合器兑换（询价、生成交易、用```exchange.IO(\\\"call\\\", ...)```预演、带```data```发送）见手册中```exchange.IO(\\\"call\\\", ...)```的范例；ERC-20 Permit签名并由合约验签见```exchange.IO(\\\"sign\\\", ...)```、```exchange.IO(\\\"signTypedData\\\", ...)```的范例。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var usdc = \\\"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48\\\" // 以太坊主网 USDC\\n // 被授权的合约，这里以 Uniswap SwapRouter02 为例\\n var spender = \\\"0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45\\\"\\n var wallet = exchange.IO(\\\"address\\\")\\n\\n // 查余额：标准 ERC20 方法不需要注册 ABI\\n var wei = exchange.IO(\\\"api\\\", \\\"eth\\\", \\\"eth_getBalance\\\", wallet, \\\"latest\\\")\\n var eth = exchange.IO(\\\"fromUnits\\\", wei, 18)\\n var usdcBalance = exchange.IO(\\\"fromUnits\\\", exchange.IO(\\\"api\\\", usdc, \\\"balanceOf\\\", wallet), usdc)\\n Log(\\\"ETH:\\\", eth, \\\"USDC:\\\", usdcBalance)\\n\\n // 读合约：当前授权额度\\n var allowance = exchange.IO(\\\"api\\\", usdc, \\\"allowance\\\", wallet, spender)\\n Log(\\\"当前授权:\\\", exchange.IO(\\\"fromUnits\\\", allowance, usdc))\\n\\n // 授权 100 USDC：先预演，再发送\\n var amount = exchange.IO(\\\"toUnits\\\", \\\"100\\\", usdc)\\n if (!exchange.IO(\\\"call\\\", usdc, \\\"approve\\\", spender, amount)) {\\n Log(\\\"预演失败:\\\", GetLastError())\\n return\\n }\\n var txHash = exchange.IO(\\\"api\\\", usdc, \\\"approve\\\", spender, amount)\\n Log(\\\"交易哈希:\\\", txHash)\\n\\n // 等待上链，最多 3 分钟\\n var receipt = exchange.IO(\\\"waitReceipt\\\", txHash, {timeout: 180000})\\n if (receipt && receipt.status == 1) {\\n Log(\\\"授权成功，区块:\\\", receipt.blockNumber)\\n } else if (receipt) {\\n Log(\\\"交易失败:\\\", receipt.revertReason)\\n } else {\\n // 未上链：可以用 speedUp 加价重发，或 cancelTx 取消\\n Log(\\\"超时未上链:\\\", GetLastError())\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"查余额、授权并等待上链（以太坊主网USDC）；这段代码会发出真实交易、消耗gas。\"}], \"seeAlso\": [\"{@exchanges/custom/web3 Web3}, {@fun/IO/exchange.IO exchange.IO}\"], \"title\": \"以太坊（EVM）\"}, {\"_src_hash\": \"d514a68d9468a1e7c4d86f29034f47346e3a00bd7f4d2976c0b738617134fea3\", \"desc\": \"Web3交易所对象选择```ChainType```为```TRON```时连接波场节点。用法与{@进阶专题/Web3/以太坊（EVM）以太坊（EVM）}基本一致：注册ABI、调用合约、编码解码、签名、切换私钥等```exchange.IO()```指令相同，地址使用波场格式（```T```开头），TRX数量的单位是sun（1 TRX = 1000000 sun）。本页说明配置和波场特有的部分。\\n\\n### 配置交易所对象\\n\\n- ```ChainType```：选择```TRON```\\n- ```Private Key```：钱包私钥（十六进制字符串）。支持把私钥本地化部署在托管者上，参看{@入门/密钥安全性密钥安全性}\\n- ```Rpc Address```：波场全节点的HTTP地址，例如官方节点```https://api.trongrid.io```（测试网：```https://nile.trongrid.io```、```https://api.shasta.trongrid.io```）\\n- ```Rpc Api Key```：TronGrid的API Key，只填Key本身，会作为```TRON-PRO-API-KEY```请求头发送。不填也能使用，但TronGrid对没有Key的请求限频更严格\\n\\n托管者通过全节点的HTTP接口（```/wallet/...```）访问波场，不再使用gRPC。选择TRON时表单默认填入的旧gRPC地址```grpc.trongrid.io:50051```会自动换成```https://api.trongrid.io```（```grpc.nile.trongrid.io:50051```、```grpc.shasta.trongrid.io:50051```同样换成对应测试网的HTTP地址）；其它gRPC地址会报错，请改填节点的HTTP地址。\\n\\n运行中可以用```exchange.IO(\\\"base\\\", 节点地址)```切换节点，用```exchange.IO(\\\"key\\\", 私钥)```切换钱包，用```exchange.IO(\\\"address\\\")```获取当前钱包地址（```T```开头）。标准函数```exchange.GetAccount()```、```exchange.GetAssets()```返回钱包的TRX余额。账户还未激活（链上没有记录）时余额为0。\\n\\n### 调用智能合约\\n\\n与以太坊相同，使用```exchange.IO(\\\"api\\\", 合约地址, 方法, ...参数)```：只读方法直接返回结果，写方法签名并广播交易，返回交易ID。TRC20标准方法已内置；其它合约没有注册ABI时，会自动从链上读取该合约的ABI，读取不到时再用```exchange.IO(\\\"abi\\\", 合约地址, ABI)```手动注册。写方法的最后一个参数可以传```{gasLimit: 数量}```设置手续费上限（feeLimit，单位sun）。\\n\\n```javascript\\n// USDT（TRC20）合约\\nvar usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\nLog(exchange.IO(\\\"api\\\", usdt, \\\"balanceOf\\\", exchange.IO(\\\"address\\\"))) // 链上整数，USDT精度为6\\n```\\n\\n编码解码与以太坊一致，地址参数可以直接写```T```开头的地址：\\n\\n```javascript\\nexchange.IO(\\\"encode\\\", \\\"address\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\")\\n// 000000000000000000000000a614f803b6fd780986a42c78ec9c7f77e6ded13c\\nexchange.IO(\\\"encodePacked\\\", \\\"address\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\")\\n// a614f803b6fd780986a42c78ec9c7f77e6ded13c\\nexchange.IO(\\\"decode\\\", \\\"string\\\",\\n \\\"0000000000000000000000000000000000000000000000000000000000000020\\\" +\\n \\\"000000000000000000000000000000000000000000000000000000000000000a\\\" +\\n \\\"5465746865722055534400000000000000000000000000000000000000000000\\\")\\n// Tether USD\\n```\\n\\n### 调用波场节点的方法\\n\\n```exchange.IO(\\\"api\\\", \\\"tron\\\", 方法, ...参数)```调用波场节点的方法，方法名不区分大小写（```send```除外，必须写成小写）。需要签名的方法（转账、触发合约等）会自动签名并广播。常用方法：\\n\\n| 方法 | 参数 | 说明 |\\n| - | - | - |\\n| ```send``` | 收款地址，数量（sun） | 从当前钱包转出TRX |\\n| ```Transfer``` | 付款地址，收款地址，数量（sun） | 转出TRX，付款地址必须是当前钱包 |\\n| ```GetAccount``` | 地址 | 账户信息 |\\n| ```GetAccountResource``` | 地址 | 账户的能量、带宽资源 |\\n| ```GetContractABI``` | 合约地址 | 合约在链上的ABI |\\n| ```GetAssetIssueByName``` | 名称 | TRC10资产信息 |\\n| ```GetNowBlock``` | 无 | 当前区块 |\\n| ```GetBlockByNum``` | 区块高度 | 指定区块 |\\n| ```GetTransactionByID``` | 交易ID | 交易内容 |\\n| ```GetTransactionInfoByID``` | 交易ID | 交易执行结果（手续费、能量消耗、日志等） |\\n| ```GetChainParameters``` | 无 | 链参数 |\\n| ```TriggerConstantContract``` | 调用者地址（可为空），合约地址，方法签名，参数值（见表后说明） | 只读调用合约，结果在```constant_result```中 |\\n| ```TRC20ContractBalance``` | 地址，合约地址 | TRC20余额（链上整数） |\\n| ```TRC20GetName```、```TRC20GetSymbol```、```TRC20GetDecimals``` | 合约地址 | TRC20的名称、符号、精度 |\\n| ```TRC20Send```、```TRC20Approve``` | 付款地址，收款或被授权地址，合约地址，数量，feeLimit | TRC20转账、授权 |\\n| ```TRC20Call``` | 调用者地址（可为空），合约地址，调用数据，是否只读，feeLimit | 用原始调用数据调用合约 |\\n| ```ParseTRC20NumericProperty```、```ParseTRC20StringProperty``` | 十六进制数据 | 解析TRC20返回的数值、字符串 |\\n\\n```TriggerConstantContract```的方法签名要带参数类型（如```\\\"balanceOf(address)\\\"```），参数值写成JSON数组字符串（如```'[\\\"T...\\\"]'```，没有参数时传空串）；返回的```constant_result```是十六进制字符串，可以用```exchange.IO(\\\"decode\\\", ...)```解码。\\n\\n表中没有的节点接口，可以直接传路径和请求体：```exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"/wallet/接口名\\\", {请求体})```。\\n\\n### 与以太坊的差异\\n\\n以下指令只支持以太坊（EVM），在波场上调用会报错：```call```、```multicall```、```logs```、```waitReceipt```、```nonce```、```speedUp```、```cancelTx```、```contracts```、```sendBase```。多个节点互为备用也只对以太坊有效，波场的节点地址只能填一个，用逗号分隔填写多个会报错。在波场上模拟执行合约调用可以用节点方法```TriggerConstantContract```，查询交易的执行结果用```GetTransactionInfoByID```。\\n\\n```toUnits```、```fromUnits```、```uniswapV3```、编码解码和签名指令在波场上同样可用，精度参数可以直接传TRC20合约地址：\\n\\n```javascript\\nvar usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\nvar raw = exchange.IO(\\\"api\\\", usdt, \\\"balanceOf\\\", exchange.IO(\\\"address\\\"))\\nLog(exchange.IO(\\\"fromUnits\\\", raw, usdt)) // 按合约的 decimals() 换算为可读数量\\n```\\n\\n合约调用在节点校验阶段被拒绝时（例如合约不存在），错误信息中是节点给出的原因，例如```tron contract call rejected (CONTRACT_VALIDATE_ERROR): Smart contract is not exist.```；合约执行失败（revert）时报```tron contract execution failed```及失败原因。\\n\\n### 签名\\n\\n```exchange.IO(\\\"hash\\\", \\\"sign\\\", \\\"hex\\\", \\\"hex\\\", 交易哈希)```用当前私钥对32字节哈希签名，返回65字节签名```r‖s‖v```（v为0或1）；```hash```的其它算法（如```sha256```）用于计算摘要，功能与```Encode()```函数相同。需要分别取得r、s、v（v为27或28）用于合约校验时，使用```exchange.IO(\\\"sign\\\", ...)```，见语法手册的{@exchanges/custom/web3 Web3}交易所页。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\n var wallet = exchange.IO(\\\"address\\\")\\n\\n // TRX 余额（标准函数，单位 TRX）\\n Log(\\\"账户:\\\", exchange.GetAccount())\\n\\n // USDT 余额：链上整数，按精度换算\\n var raw = exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"TRC20ContractBalance\\\", wallet, usdt)\\n var decimals = exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"TRC20GetDecimals\\\", usdt)\\n Log(\\\"USDT:\\\", raw / Math.pow(10, decimals))\\n\\n // 用 TRC20Call 只读调用 name()（选择器 0x06fdde03），再解析返回的字符串\\n var ret = exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"TRC20Call\\\", \\\"\\\", usdt, \\\"0x06fdde03\\\", true, 0)\\n // constant_result 中是十六进制字符串，直接解析\\n Log(\\\"名称:\\\", exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"ParseTRC20StringProperty\\\", ret.constant_result[0]))\\n}\", \"lang\": \"javascript\"}], \"value\": \"查询TRX与USDT余额，读取代币信息。\"}, {\"examples\": [{\"code\": \"function main() {\\n var usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\n var multicall = \\\"TGXuuKAb4bnrn137u39EKbYzKNXvdCes98\\\"\\n var wallet = exchange.IO(\\\"address\\\")\\n\\n var calls = [\\n [usdt, exchange.IO(\\\"encode\\\", usdt, \\\"name\\\")],\\n [usdt, exchange.IO(\\\"encode\\\", usdt, \\\"decimals\\\")],\\n [usdt, exchange.IO(\\\"encode\\\", usdt, \\\"balanceOf\\\", wallet)]\\n ]\\n // 注册 Multicall 合约的 aggregate 方法\\n exchange.IO(\\\"abi\\\", multicall, `[{\\n \\\"inputs\\\": [{\\n \\\"components\\\": [\\n {\\\"internalType\\\": \\\"address\\\", \\\"name\\\": \\\"target\\\", \\\"type\\\": \\\"address\\\"},\\n {\\\"internalType\\\": \\\"bytes\\\", \\\"name\\\": \\\"callData\\\", \\\"type\\\": \\\"bytes\\\"}\\n ],\\n \\\"internalType\\\": \\\"struct TronMulticall.Call[]\\\", \\\"name\\\": \\\"calls\\\", \\\"type\\\": \\\"tuple[]\\\"\\n }],\\n \\\"name\\\": \\\"aggregate\\\",\\n \\\"outputs\\\": [\\n {\\\"internalType\\\": \\\"uint256\\\", \\\"name\\\": \\\"blockNumber\\\", \\\"type\\\": \\\"uint256\\\"},\\n {\\\"internalType\\\": \\\"bytes[]\\\", \\\"name\\\": \\\"returnData\\\", \\\"type\\\": \\\"bytes[]\\\"}\\n ],\\n \\\"stateMutability\\\": \\\"view\\\", \\\"type\\\": \\\"function\\\"\\n }]`)\\n var ret = exchange.IO(\\\"api\\\", multicall, \\\"aggregate\\\", calls)\\n Log(\\\"name:\\\", exchange.IO(\\\"decode\\\", \\\"string\\\", ret.returnData[0]))\\n Log(\\\"decimals:\\\", exchange.IO(\\\"decode\\\", \\\"uint8\\\", ret.returnData[1]))\\n Log(\\\"balanceOf:\\\", exchange.IO(\\\"decode\\\", \\\"uint256\\\", ret.returnData[2]))\\n}\", \"lang\": \"javascript\"}], \"value\": \"用Multicall合约一次读取多个合约方法。\"}], \"seeAlso\": [\"{@exchanges/custom/web3 Web3}, {@fun/IO/exchange.IO exchange.IO}\"], \"title\": \"波场（TRON）\"}], \"desc\": \"链上交易：选哪个交易所对象。\\n\\n| 需求 | 交易所对象 | 说明 |\\n| - | - | - |\\n| 在EVM链的DEX上兑换代币 | ```Uniswap```（Uniswap、PancakeSwap、Aerodrome）、```KyberSwap```、```OneInch```（1inch） | 用现货交易函数下单，见{@进阶专题/Web3/EVM链上兑换（Uniswap、KyberSwap、1inch） EVM链上兑换（Uniswap、KyberSwap、1inch）} |\\n| 在Solana上兑换代币 | ```Jupiter``` | 见{@进阶专题/Web3/Solana兑换（Jupiter） Solana兑换（Jupiter）} |\\n| 通过OKX DEX聚合器在多条链上兑换 | ```OKX_DEX``` | 用助记词配置；交易对写作```{链编号}:{代币}_USD```，代币名区分大小写，见{@exchanges/dex/okx-dex OKX_DEX}交易所页 |\\n| 查询链上数据、调用智能合约、发送自定义交易 | ```Web3``` | 支持以太坊等EVM兼容链（见{@进阶专题/Web3/以太坊（EVM）以太坊（EVM）}）和波场（见{@进阶专题/Web3/波场（TRON）波场（TRON）}） |\\n\\nHyperliquid、Lighter、EdgeX、Aster、Polymarket等链上交易所与中心化交易所一样，用标准交易函数操作，配置见语法手册{@exchanges/dex 去中心化交易所}、{@exchanges/prediction 预测市场}中的交易所页。\", \"title\": \"Web3\"}], \"desc\": \"进阶用法：JavaScript多线程、实盘之间通信、API限流、期权交易、Web3链上交易。\", \"title\": \"进阶专题\"}, {\"_src_hash\": \"1301895a5369c6fe483e8877e0db074cb786721aa4d6a1cace6f2474b0484a85\", \"children\": [{\"_src_hash\": \"88d3a2f4534fb85bb8d1530d77b6eb0b7e67c8123ff1df0ce89e1fbb64ef875a\", \"children\": [], \"desc\": \"发明者量化自研的**datadata**是一个量化金融数据平台，发明者量化交易平台的[数据探索](https://www.fmz.com/m/database)模块集成了它的服务和功能，发明者量化用户无需另外注册**datadata**账号即可使用。可以用SQL查询分析海量数据，通过可视化界面生成多种图表，并与团队分享。使用例子可以参考[数据探索模块专题文章](https://www.fmz.com/digest-topic/10370)。\\n\\n- 数据源：datadata提供的数据源实时、持续更新，涵盖多种类型的数据；也可以上传CSV文件作为私有数据源，并在「数据探索」页面预览。\\n- 数据查询：用SQL语句查询数据，支持查询参数；查询结果可以下载为CSV或JSON文件。\\n- 保存研究：点击右上角的「保存」，把当前SQL查询保存到账号「数据探索」的资源列表中（资源列表按钮在「保存」按钮左侧）。\\n- 数据图形化：查询结果除了以表格展示，还可以用多种可视化组件展示。\\n- 分享研究：支持公开链接、嵌入代码（例如嵌入平台社区帖子）、嵌入网页、数据链接、预览图链接等形式。用「数据链接」还可以把数据直接提供给策略使用，回测和实盘都支持。\", \"title\": \"数据探索\"}, {\"_src_hash\": \"1224f4c59c0614d4497b525f531569ec49313acdfa1f5a5ece1a7b098d8a03ae\", \"children\": [{\"_src_hash\": \"29f4ceb925fc7c3bc4bc9bf621087a58b098ad1d271885f327eb3dc337c05b8b\", \"desc\": \"Alpha因子分析工具的公式中可以使用的函数和操作符。表达式不区分大小写；下文中```x```、```y```代表时间序列，```d```代表周期数，```{}```代表占位符。\\n\\n### 操作符\\n\\n```+```、```-```、```*```、```/```、```>```、```<```按标准含义计算；```==```判断是否相等，```||```为逻辑或，```x ? y : z```为三元条件运算符。\\n\\n### 函数\\n\\n| 函数 | 说明 |\\n| - | - |\\n| ```abs(x)```、```log(x)```、```sign(x)``` | 绝对值、对数、符号函数 |\\n| ```rank(x)``` | 横截面排序，返回所在的百分位；需要由多个标的组成的候选池，只有单个行情时无法排序，直接返回原值 |\\n| ```delay(x, d)``` | x在d个周期前的值 |\\n| ```sma(x, d)``` | x在d个周期内的简单移动平均值 |\\n| ```correlation(x, y, d)``` | x和y在过去d个周期内的相关系数 |\\n| ```covariance(x, y, d)``` | x和y在过去d个周期内的协方差 |\\n| ```scale(x, a)``` | 归一化，使```sum(abs(x)) = a```（a默认为1） |\\n| ```delta(x, d)``` | x的当前值减去d个周期前的值 |\\n| ```signedpower(x, a)``` | ```x^a``` |\\n| ```decay_linear(x, d)``` | x的d周期加权移动平均，权重为d, d-1, …, 1（经过归一化） |\\n| ```indneutralize(x, g)``` | 按行业分类g做中性化处理，目前不支持 |\\n| ```ts_{O}(x, d)``` | 对x的过去d个周期执行O操作（O为min、max等，见下面几行），d会转换为整数 |\\n| ```ts_min(x, d)```、```min(x, d)``` | 过去d个周期的最小值 |\\n| ```ts_max(x, d)```、```max(x, d)``` | 过去d个周期的最大值 |\\n| ```ts_argmin(x, d)``` | ```ts_min(x, d)```的位置 |\\n| ```ts_argmax(x, d)``` | ```ts_max(x, d)```的位置 |\\n| ```ts_rank(x, d)``` | x在过去d个周期内的排序（百分位） |\\n| ```sum(x, d)``` | 过去d个周期的累计和 |\\n| ```product(x, d)``` | 过去d个周期的累计积 |\\n| ```stddev(x, d)``` | 过去d个周期的标准差 |\", \"title\": \"函数和操作符\"}, {\"_src_hash\": \"4a88db6f4428de6c065d5828235841866db21444d1d8695c67c3425aa5dfbb75\", \"desc\": \"公式中可以引用的行情数据。输入数据不区分大小写，默认为网页上选择的品种，也可以直接指定品种，例如```binance.ada_bnb```。\\n\\n| 数据 | 说明 |\\n| - | - |\\n| ```returns``` | 收盘价收益率 |\\n| ```open```、```close```、```high```、```low```、```volume``` | 周期内的开盘价、收盘价、最高价、最低价、成交量 |\\n| ```vwap``` | 成交量加权平均价，暂未实现，当前为收盘价 |\\n| ```cap``` | 总市值，暂未实现 |\\n| ```IndClass``` | 行业分类，暂未实现 |\", \"title\": \"输入数据\"}], \"desc\": \"[Alpha因子分析工具](https://www.fmz.com/m/alpha)用公式对行情时间序列快速运算，用来验证交易想法。公式参考了```worldquant```公开的[```alpha101```](https://github.com/yli188/WorldQuant_alpha101_code/blob/master/101%20Formulaic%20Alphas.pdf)中行情计算的方法，基本兼容其语法（未实现的有说明），并做了增强。\\n\\n一个公式可以一次输出多个结果，写成列表即可，例如```[sma(close, 10), sma(high, 30)]```会在图中画两条线。不引用时间序列数据时，也可以当作简单的计算器使用。函数、操作符与可用的输入数据见下面两节。\", \"title\": \"Alpha因子分析工具\"}], \"desc\": \"研究行情数据的两个工具：用SQL查询、可视化金融数据的数据探索，以及用公式快速计算、验证因子的Alpha因子分析工具。\", \"title\": \"数据与研究\"}, {\"_src_hash\": \"c0951478a97a49a90041465ae83daf220c1bc78254d3b21603e1e3722e6f66a0\", \"children\": [{\"_src_hash\": \"92a8753ea3f69ec0826e043cfaf7b4cf7054619d7e817da600e21506654c429f\", \"desc\": [\"把发明者量化接入Claude Code、Codex、Cursor等AI编程助手（AI agent）后，可以直接用对话完成写策略、回测、创建和管理实盘、查看日志与收益。AI助手通过平台提供的MCP（Model Context Protocol）服务调用这些功能，用的是一把专门为它创建的API KEY，权限由你在授权时决定，随时可以修改或吊销。\\n\\n### 一句话接入\\n\\n在AI助手里输入：\\n\\n```text\\n读 https://www.fmz.com/agent/setup.zh-CN.md 然后接入发明者量化\\n```\\n\\nAI助手会按这份说明完成以下步骤，你只需要在浏览器里点一次同意：\\n\\n1. AI助手向平台申请授权，然后给出一个授权链接（形如```https://www.fmz.com/agent/authorize?code=XXXX-XXXX```），链接10分钟内有效。\\n2. 在已登录发明者量化的浏览器中打开链接，确认申请者名称和权限后点击同意。可以在页面上取消勾选不想给的权限。\\n3. AI助手取得API KEY，写入自己的MCP配置并连接。之后就可以直接对它说「列出我的实盘」「给这个策略跑一次回测」。\\n\\n申请时AI助手会用「名字 @ 机器名」（例如```Claude Code @ MacBook```）作为这把API KEY的名称。同一个名称再次申请并同意时，旧的API KEY会被吊销、换成新的，重复接入不会累积多余的API KEY。\\n\\n### 权限\\n\\n| 权限 | 允许的操作 | 默认 |\\n| - | - | - |\\n| read | 查看策略、实盘、托管者、交易所账户列表与详情，读取日志、消息、账户概览（不含任何密钥） | 是 |\\n| backtest | 发起、查询、停止回测 | 是 |\\n| write | 保存策略与版本、分组、告警开关，修改已停止实盘的配置 | 是 |\\n| trade | 创建、启动、停止实盘，给实盘发送交互命令（会扣费并真实下单） | 是 |\\n| danger | 删除策略、实盘、托管者，公开策略 | 否 |\\n\\n```danger```权限默认不授予，只有AI助手明确申请、并在授权页面勾选时才会获得。AI助手调用```[trade]```或```[danger]```类工具前，应当先向你确认。\\n\\n### 手动配置\\n\\n不能执行命令的客户端（例如Cherry Studio）可以手动配置：\\n\\n1. 在「账号设置 → API KEY」（```https://www.fmz.com/m/account#apikey```）创建API KEY，记下Access Key和Secret Key。\\n2. 在客户端添加一个MCP服务，类型选Streamable HTTP：\\n - URL：```https://www.fmz.com/api/mcp/```\\n - 请求头：```Authorization: Bearer ```\\n\\nSecret Key只能放在请求头里，不能写进URL。各客户端的配置示例：\\n\\n```bash\\n# Claude Code\\nclaude mcp add --transport http fmz \\\"https://www.fmz.com/api/mcp/\\\" \\\\\\n --header \\\"Authorization: Bearer \\\"\\n```\\n\\n```json\\n{\\n \\\"mcpServers\\\": {\\n \\\"fmz\\\": {\\n \\\"url\\\": \\\"https://www.fmz.com/api/mcp/\\\",\\n \\\"headers\\\": {\\\"Authorization\\\": \\\"Bearer \\\"}\\n }\\n }\\n}\\n```\\n\\n上面的JSON用于Cursor（```~/.cursor/mcp.json```）等支持Streamable HTTP的客户端；Claude Desktop需要通过```npx mcp-remote```转接，见接入说明原文。\\n\\n### 安装skills（推荐）\\n\\nskills是给AI助手阅读的平台知识包：平台操作流程、完整的API文档、各编程语言的策略写法、回测和指标。装上之后AI助手写出的策略更准确。在终端执行：\\n\\n```bash\\nnpx skills add fmzquant/skills --global --yes -a claude-code\\n```\\n\\n```-a```后面填你使用的AI助手名称（claude-code、codex、cursor、gemini-cli等）。也可以直接在GitHub阅读：```https://github.com/fmzquant/skills```。\\n\\n### 可用的工具\\n\\n连接后AI助手可以使用以下工具，完整说明以AI助手看到的工具列表为准：\\n\\n- ```read```：```ping```、```get_account_summary```、```list_exchanges```、```list_platforms```、```list_nodes```、```list_strategies```、```get_strategy```、```list_strategy_versions```、```get_strategy_version```、```list_robots```、```get_robot```、```get_robot_logs```、```get_robot_profit```、```get_robot_output```、```list_messages```、```list_groups```、```revoke_my_key```\\n- ```backtest```：```run_backtest```、```get_backtest```、```list_backtests```、```stop_backtest```\\n- ```write```：```check_strategy```、```save_strategy```、```save_strategy_version```、```delete_strategy_version```、```update_robot```、```save_group```、```move_to_group```、```delete_group```、```set_robot_alert```、```set_node_alert```、```delete_messages```\\n- ```trade```：```create_robot```、```start_robot```、```stop_robot```、```restart_robot```、```send_robot_command```，以及交易终端插件工具```plugin_*```（查询行情、下单等）\\n- ```danger```：```delete_strategy```、```delete_robot```、```delete_node```、```publish_strategy```\\n\\n一个典型的流程：```list_platforms```和```list_nodes```了解账户里有哪些交易所账户和托管者；```save_strategy```保存策略并用```check_strategy```检查语法；```run_backtest```和```get_backtest```回测；确认后```create_robot```创建实盘，再用```get_robot```、```get_robot_logs```观察运行情况。\\n\\n### 安全与管理\\n\\n- 交易所的API KEY不经过AI助手：在网页的「交易所」页面添加，AI助手按编号选择。所有工具的返回结果里都不包含任何密钥。\\n- 在```https://www.fmz.com/m/account#apikey```可以查看AI助手使用的API KEY，修改权限或锁定。权限除了填写上表的权限名，还可以填工具名，用```!工具名```排除某个工具。\\n- 不再使用时，让AI助手调用```revoke_my_key```吊销它自己的API KEY，或在上面的页面中删除。\\n- ```stop_robot```只停止实盘，不会平仓。\\n- 第一次让AI助手创建实盘时，建议先回测，再用模拟盘或小额资金运行。\\n\\n### 常见问题\\n\\n- 提示没有在线托管者：创建实盘需要至少一个在线的托管者，见「平台基础 → 托管者」。\\n- 提示回测任务过多：同时运行的回测数量有上限，让AI助手先用```stop_backtest```停止不再需要的回测。\\n- AI助手说没有某个工具，或者调用被拒绝：这把API KEY没有对应的权限，在API KEY页面修改权限后重新连接。\\n\\n同一把API KEY也可以用于{@扩展API接口/扩展API接口详解扩展API接口}，供脚本和定时任务调用；能用MCP的场景优先使用MCP。\"], \"title\": \"AI接入\"}, {\"_src_hash\": \"a275a8345dd820a92b88605d8cc451480d195c003aec84aa16891f9787636683\", \"desc\": \"在[账号设置 → API KEY](https://www.fmz.com/m/account#apikey)页面（```/m/account#apikey```）点击「创建新的ApiKey」，得到一对```AccessKey```和```SecretKey```。```SecretKey```代表这把API KEY的全部权限，不要泄露。在该页面也可以修改已有API KEY的权限，或者禁用、删除API KEY。\\n\\n### 权限\\n\\n创建或修改时，在「API权限」输入框中填写逗号分隔的列表：\\n\\n- ```*```：允许全部扩展API接口。\\n- 方法名：只允许列出的方法，例如```GetRobotList,GetRobotDetail,CommandRobot```。\\n- ```!方法名```：排除某个方法，通常与```*```搭配，例如```*,!DeleteRobot,!DeleteNode```。\\n\\n同一把API KEY也可以用于{@扩展API接口/AI接入 AI接入}（MCP服务）。除了按方法名（MCP为工具名）授权，还可以按权限类别授权：```read```、```backtest```、```write```、```trade```、```danger```（含义见AI接入页面），同样支持用```!名称```排除。权限类别对MCP工具和扩展API接口同样生效，扩展API接口各方法所属的类别：\\n\\n- ```read```：```GetAccount```、```GetExchangeList```、```GetNodeList```、```GetPlatformList```、```GetRobotGroupList```、```GetRobotList```、```GetRobotDetail```、```GetRobotLogs```、```GetStrategyList```；\\n- ```trade```：```NewRobot```、```RestartRobot```、```StopRobot```、```CommandRobot```、```PluginRun```；\\n- ```danger```：```DeleteRobot```、```DeleteNode```。\\n\\n判定顺序：明写的方法名（含```!方法名```排除）优先，其次是权限类别，最后是```*```。例如只填```read```的API KEY可以调用```GetRobotList```，不能调用```NewRobot```；```*,!trade```允许除```trade```类别以外的全部方法。\\n\\n权限留空时，扩展API接口不限制方法（MCP开放```danger```以外的全部工具）。建议按用途只授予需要的方法，例如只用于TradingView警报的API KEY只授予```CommandRobot```。\", \"title\": \"创建ApiKey\"}, {\"_src_hash\": \"fde6b5663bfb1eb4d5c366de215fda4c51b4a23eeb6ca0bb0ea01a6d90305ebb\", \"children\": [{\"_src_hash\": \"96d0bc6fd9cc1d6ce861d136b00ad7d63aafe7389db46b840a745fdf7c758be9\", \"desc\": \"签名验证用```SecretKey```对请求参数计算MD5签名，```SecretKey```本身不在网络上传输；程序调用扩展API接口应使用这种方式。\\n\\n### 请求格式\\n\\n向```https://www.fmz.com/api/v1```发送```POST```请求，参数以表单（```application/x-www-form-urlencoded```）提交。服务端也接受把同样的参数放在URL查询串中的```GET```请求，但参数会留在各处的访问日志里，推荐使用```POST```。\\n\\n| 参数 | 说明 |\\n| - | - |\\n| version | 版本号，固定为```1.0```。 |\\n| access_key | API KEY的```AccessKey```。 |\\n| method | 调用的方法名，例如```GetNodeList```。 |\\n| args | 方法参数组成的JSON字符串（数组或对象，见表后说明）；不传时按```[]```处理。 |\\n| nonce | 毫秒时间戳。与服务器时间相差不能超过1小时，并且必须大于这把API KEY上一次请求使用的```nonce```。 |\\n| sign | 签名，计算方法见下文。 |\\n\\n```args```可以是按顺序排列的数组（如```[]```、```[123, \\\"ok\\\"]```），也可以是按参数名传值的对象（如```{\\\"robotId\\\": 123}```），见{@扩展API接口/扩展API接口详解扩展API接口详解}。请求中不包含```SecretKey```。\\n\\n### 签名方式\\n\\n按下面的格式拼接字符串，其中```args```是实际提交的JSON字符串原文：\\n\\n```plaintext\\nversion + \\\"|\\\" + method + \\\"|\\\" + args + \\\"|\\\" + nonce + \\\"|\\\" + secretKey\\n```\\n\\n对拼接结果计算MD5，转换为32位小写十六进制字符串，作为```sign```的值。\\n\\n### Python示例\\n\\n```python\\nimport hashlib\\nimport json\\nimport time\\nimport urllib.parse\\nimport urllib.request\\n\\nACCESS_KEY = '' # API KEY 的 AccessKey\\nSECRET_KEY = '' # API KEY 的 SecretKey\\n\\ndef api(method, *args, **kwargs):\\n d = {\\n 'version': '1.0',\\n 'access_key': ACCESS_KEY,\\n 'method': method,\\n # 位置参数传数组，关键字参数传对象（按参数名传值）\\n 'args': json.dumps(kwargs if kwargs else list(args)),\\n 'nonce': int(time.time() * 1000),\\n }\\n s = '%s|%s|%s|%d|%s' % (d['version'], d['method'], d['args'], d['nonce'], SECRET_KEY)\\n d['sign'] = hashlib.md5(s.encode('utf-8')).hexdigest()\\n body = urllib.parse.urlencode(d).encode('utf-8')\\n with urllib.request.urlopen('https://www.fmz.com/api/v1', body, timeout=10) as resp:\\n return json.loads(resp.read().decode('utf-8'))\\n\\nprint(api('GetNodeList')) # 托管者列表\\nprint(api('GetRobotList', appId='member2')) # 按参数名传值：标签为 member2 的实盘\\nprint(api('CommandRobot', 123, 'ok')) # 向实盘 123 发送交互命令\\nprint(api('GetRobotDetail', 123)) # 实盘 123 的详细信息\\n```\\n\\n### Go示例\\n\\n```go\\npackage main\\n\\nimport (\\n \\\"crypto/md5\\\"\\n \\\"encoding/hex\\\"\\n \\\"encoding/json\\\"\\n \\\"fmt\\\"\\n \\\"io\\\"\\n \\\"net/http\\\"\\n \\\"net/url\\\"\\n \\\"strconv\\\"\\n \\\"time\\\"\\n)\\n\\nconst (\\n accessKey = \\\"\\\" // API KEY 的 AccessKey\\n secretKey = \\\"\\\" // API KEY 的 SecretKey\\n baseAPI = \\\"https://www.fmz.com/api/v1\\\"\\n)\\n\\nvar client = &http.Client{Timeout: 10 * time.Second}\\n\\nfunc api(method string, args ...interface{}) (string, error) {\\n if args == nil {\\n args = []interface{}{}\\n }\\n b, err := json.Marshal(args)\\n if err != nil {\\n return \\\"\\\", err\\n }\\n nonce := strconv.FormatInt(time.Now().UnixMilli(), 10)\\n sum := md5.Sum([]byte(\\\"1.0|\\\" + method + \\\"|\\\" + string(b) + \\\"|\\\" + nonce + \\\"|\\\" + secretKey))\\n form := url.Values{\\n \\\"version\\\": {\\\"1.0\\\"},\\n \\\"access_key\\\": {accessKey},\\n \\\"method\\\": {method},\\n \\\"args\\\": {string(b)},\\n \\\"nonce\\\": {nonce},\\n \\\"sign\\\": {hex.EncodeToString(sum[:])},\\n }\\n resp, err := client.PostForm(baseAPI, form)\\n if err != nil {\\n return \\\"\\\", err\\n }\\n defer resp.Body.Close()\\n body, err := io.ReadAll(resp.Body)\\n return string(body), err\\n}\\n\\nfunc main() {\\n ret, err := api(\\\"GetNodeList\\\")\\n fmt.Println(ret, err)\\n\\n // 用新的配置重启实盘 123；settings 字段见「扩展API接口详解」的实盘配置\\n settings := map[string]interface{}{\\n \\\"name\\\": \\\"hedge test\\\",\\n \\\"strategy\\\": 456,\\n \\\"period\\\": 60,\\n \\\"node\\\": 789,\\n \\\"exchanges\\\": []interface{}{\\n map[string]interface{}{\\\"pid\\\": 1001, \\\"pair\\\": \\\"BTC_USDT\\\"},\\n },\\n }\\n ret, err = api(\\\"RestartRobot\\\", 123, settings)\\n fmt.Println(ret, err)\\n}\\n```\", \"title\": \"token验证\"}, {\"_src_hash\": \"31ae9150f6b3a19fcfd926139a8891a4e708a491bd12e022fbf3954595529293\", \"desc\": \"不计算签名，而是把```secret_key```直接放在请求参数中，因此可以生成一个固定的URL，填到TradingView等只能设置一个URL的Webhook回调里。\\n\\n> **安全提示**：```secret_key```写在URL中，会留在浏览器历史、代理和服务器的访问日志、Webhook服务方的配置里，任何拿到这个URL的人都能以这把API KEY的权限调用接口。建议只在```CommandRobot```的Webhook中使用直接验证，并为它单独创建一把只授权```CommandRobot```的API KEY（见{@扩展API接口/创建ApiKey 创建ApiKey}）；一旦泄露，立即删除这把API KEY。\\n\\n请求参数为```access_key```、```secret_key```、```method```、```args```（JSON数组，需要URL编码），不需要```version```、```nonce```、```sign```。```CommandRobot```不做```nonce```校验；其他方法仍会校验：不传```nonce```时服务器以当前时间（精确到秒）代替，同一秒内的第二次调用会返回Nonce错误（```code```为3）。\\n\\n例如API KEY的```AccessKey```为```xxx```、```SecretKey```为```yyy```，访问下面的URL即可向Id为```186515```的实盘发送交互命令```ok12345```：\\n\\n```plaintext\\nhttps://www.fmz.com/api/v1?access_key=xxx&secret_key=yyy&method=CommandRobot&args=%5B186515%2C%22ok12345%22%5D\\n```\\n\\n### 接收Webhook请求体\\n\\n```CommandRobot```的命令参数为空字符串、请求为```POST```时，服务器把请求体（Body）作为交互命令发给实盘。请求体须为JSON或纯文本，不能是表单编码（```Content-Type: application/x-www-form-urlencoded```的请求体会先被当作表单解析掉，命令变为空字符串）。例如在TradingView的Webhook URL中设置：\\n\\n```plaintext\\nhttps://www.fmz.com/api/v1?access_key=xxx&secret_key=yyy&method=CommandRobot&args=%5B186515%2C+%22%22%5D\\n```\\n\\n其中```args```的值```%5B186515%2C+%22%22%5D```解码后为```[186515, \\\"\\\"]```（```+```是URL编码中的空格），```186515```是实盘Id，命令为空字符串。\\n\\n模拟TradingView发送Webhook警报：\\n\\n```javascript\\nfunction main() {\\n var options = {\\n method: \\\"POST\\\",\\n body: `{\\\"test\\\": 123}`,\\n headers: {\\\"Content-Type\\\": \\\"application/json\\\"}\\n }\\n\\n // Webhook 警报会自动发送 POST 请求，并带上需要的 headers\\n var url = \\\"https://www.fmz.com/api/v1?access_key=xxx&secret_key=yyy\\\" +\\n \\\"&method=CommandRobot&args=%5B186515%2C+%22%22%5D\\\"\\n return HttpQuery(url, options)\\n}\\n```\\n\\nTradingView警报消息框中的内容就是请求体：\\n\\n- JSON格式：\\n\\n ![TradingView警报消息（JSON格式）](/upload/asset/16d8a37ef80d9ccd0079.png)\\n\\n ```plaintext\\n {\\\"close\\\": {{close}}, \\\"name\\\": \\\"aaa\\\"}\\n ```\\n\\n Id为```186515```的实盘收到交互命令：```{\\\"close\\\": 39773.75, \\\"name\\\": \\\"aaa\\\"}```。\\n\\n- 文本格式：\\n\\n ![TradingView警报消息（文本格式）](/upload/asset/16d8a506dfbb6c60a077.png)\\n\\n ```plaintext\\n BTCUSDTPERP 穿过(Crossing) 39700.00 close: {{close}}\\n ```\\n\\n Id为```186515```的实盘收到交互命令：```BTCUSDTPERP 穿过(Crossing) 39700.00 close: 39739.4```。\\n\\n### Python、Go示例\\n\\n```python\\nimport json\\nimport urllib.parse\\nimport urllib.request\\n\\nACCESS_KEY = '' # 只授权了 CommandRobot 的 API KEY 的 AccessKey\\nSECRET_KEY = '' # SecretKey\\n\\ndef api(method, *args):\\n query = urllib.parse.urlencode({\\n 'access_key': ACCESS_KEY,\\n 'secret_key': SECRET_KEY,\\n 'method': method,\\n 'args': json.dumps(list(args)),\\n })\\n with urllib.request.urlopen('https://www.fmz.com/api/v1?' + query, timeout=10) as resp:\\n return json.loads(resp.read().decode('utf-8'))\\n\\n# API KEY 没有该方法的权限时返回 {'code': 4, 'data': None}\\nprint(api('CommandRobot', 186515, 'ok12345'))\\n```\\n\\n```go\\npackage main\\n\\nimport (\\n \\\"encoding/json\\\"\\n \\\"fmt\\\"\\n \\\"io\\\"\\n \\\"net/http\\\"\\n \\\"net/url\\\"\\n \\\"time\\\"\\n)\\n\\nconst (\\n accessKey = \\\"\\\" // 只授权了 CommandRobot 的 API KEY 的 AccessKey\\n secretKey = \\\"\\\" // SecretKey\\n baseAPI = \\\"https://www.fmz.com/api/v1\\\"\\n)\\n\\nvar client = &http.Client{Timeout: 10 * time.Second}\\n\\nfunc api(method string, args ...interface{}) (string, error) {\\n if args == nil {\\n args = []interface{}{}\\n }\\n b, err := json.Marshal(args)\\n if err != nil {\\n return \\\"\\\", err\\n }\\n q := url.Values{\\n \\\"access_key\\\": {accessKey},\\n \\\"secret_key\\\": {secretKey},\\n \\\"method\\\": {method},\\n \\\"args\\\": {string(b)},\\n }\\n resp, err := client.Get(baseAPI + \\\"?\\\" + q.Encode())\\n if err != nil {\\n return \\\"\\\", err\\n }\\n defer resp.Body.Close()\\n body, err := io.ReadAll(resp.Body)\\n return string(body), err\\n}\\n\\nfunc main() {\\n ret, err := api(\\\"CommandRobot\\\", 186515, \\\"ok12345\\\")\\n fmt.Println(ret, err)\\n}\\n```\\n\\n参考：\\n\\n- [使用发明者量化交易平台扩展API实现TradingView报警信号交易](https://www.fmz.com/digest-topic/5533)\\n- [使用发明者量化交易平台扩展API实现TradingView报警信号交易（B站视频）](https://www.bilibili.com/video/BV1Wk4y1k7zz/)\", \"title\": \"直接验证\"}], \"desc\": \"调用扩展API接口有两种验证方式：签名验证和直接验证。\\n\\n- {@扩展API接口/验证方式/token验证签名验证}：用```SecretKey```对请求参数签名，```SecretKey```本身不在网络上传输。程序调用应使用这种方式。\\n- {@扩展API接口/验证方式/直接验证直接验证}：把```SecretKey```直接放进请求URL，主要用于TradingView等只能填写一个URL的Webhook场景。\", \"title\": \"验证方式\"}, {\"_src_hash\": \"6a2d58daf6dc6c8763f756b98d1957f82a86d053bf7228b8891d392196c1eb16\", \"children\": [{\"_src_hash\": \"e4a4f1a5802b3e0227a5f5943605f259aacf426046eb4b71410ec67a86b079c9\", \"attrs\": [{\"info\": \"账户余额，单位为USD，按1e8放大为整数，除以1e8得到实际数值；示例中为229.44702436。\", \"name\": \"balance\", \"type\": \"number\"}, {\"info\": \"累计消费金额，单位与换算方式同```balance```。\", \"name\": \"consumed\", \"type\": \"number\"}, {\"info\": \"用户名。\", \"name\": \"username\", \"type\": \"string\"}, {\"info\": \"账号邮箱。\", \"name\": \"email\", \"type\": \"string\"}, {\"info\": \"账号UID。\", \"name\": \"uid\", \"type\": \"string\"}], \"desc\": [\"获取当前API KEY所属账号的账户信息，包括余额和累计消费金额。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('GetAccount')\\nprint(r['data']['result']['balance'] / 1e8) # 输出：229.44702436（USD）\", \"lang\": \"python\"}], \"value\": \"查询账户余额。\"}], \"isChildren\": true, \"remarks\": [\"### 返回示例\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"balance\\\": 22944702436,\\n \\\"concurrent\\\": 0,\\n \\\"consumed\\\": 211092719653,\\n \\\"email\\\": \\\"123@qq.com\\\",\\n \\\"openai\\\": false,\\n \\\"settings\\\": {},\\n \\\"sns\\\": {\\\"wechat\\\": true},\\n \\\"uid\\\": \\\"105ea6e51bcc177926a10fdbb7e2a1d6\\\",\\n \\\"username\\\": \\\"abc\\\"\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"成功时```data.result```为账户信息，字段见下方属性表。\", \"type\": \"object\"}], \"title\": \"GetAccount\"}, {\"_src_hash\": \"234ebad828f5478dcc8e2627c7faaeaf6ed15a0a0707632f80b04e6c97f22ff2\", \"args\": [{\"info\": \"分页偏移，默认为0。\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"每页数量；不传或小于等于0时返回全部。\", \"name\": \"limit\", \"required\": false, \"type\": \"number\"}], \"attrs\": [{\"info\": \"托管者总数（包括公共托管者）。\", \"name\": \"all\", \"type\": \"number\"}, {\"info\": \"托管者数组，每个元素的字段见下面几行（字面意思明显的字段不再列出）。\", \"name\": \"nodes\", \"type\": \"array\"}, {\"info\": \"托管者Id，即实盘配置中的```node```。\", \"name\": \"nodes[].id\", \"type\": \"number\"}, {\"info\": \"版本号。\", \"name\": \"nodes[].build\", \"type\": \"string\"}, {\"info\": \"托管者详细版本信息。\", \"name\": \"nodes[].version\", \"type\": \"string\"}, {\"info\": \"是否在线。\", \"name\": \"nodes[].online\", \"type\": \"bool\"}, {\"info\": \"```true```为私有托管者，```false```为公共托管者。\", \"name\": \"nodes[].is_owner\", \"type\": \"bool\"}, {\"info\": \"```0```为私有托管者，```1```为公共托管者。\", \"name\": \"nodes[].public\", \"type\": \"number\"}, {\"info\": \"负载，即运行在该托管者上的策略实例个数。\", \"name\": \"nodes[].loaded\", \"type\": \"number\"}, {\"info\": \"所在城市。\", \"name\": \"nodes[].city\", \"type\": \"string\"}, {\"info\": \"地理位置。\", \"name\": \"nodes[].region\", \"type\": \"string\"}, {\"info\": \"是否开启离线报警，```0```表示未开启。\", \"name\": \"nodes[].wd\", \"type\": \"number\"}], \"desc\": [\"获取当前账号可以使用的托管者列表，包括自己的托管者和平台的公共托管者。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('GetNodeList')\\nfor node in r['data']['result']['nodes']:\\n print(node['id'], node['name'], node['online'])\", \"lang\": \"python\"}], \"value\": \"列出全部托管者及其在线状态。\"}], \"isChildren\": true, \"remarks\": [\"一键租用的托管者还有以```ecs_```、```unit_```开头的字段，记录服务器的运营商、配置、状态以及计费周期、价格等信息。\", \"### 返回示例\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 1,\\n \\\"nodes\\\": [{\\n \\\"build\\\": \\\"3.7\\\",\\n \\\"city\\\": \\\"...\\\",\\n \\\"created\\\": \\\"2024-11-08 09:21:08\\\",\\n \\\"date\\\": \\\"2024-11-08 16:37:16\\\",\\n \\\"forward\\\": \\\"...\\\",\\n \\\"guid\\\": \\\"...\\\",\\n \\\"host\\\": \\\"node.fmz.com:9902\\\",\\n \\\"id\\\": 123,\\n \\\"ip\\\": \\\"...\\\",\\n \\\"is_owner\\\": true,\\n \\\"loaded\\\": 0,\\n \\\"name\\\": \\\"MacBook-Pro-2.local\\\",\\n \\\"online\\\": true,\\n \\\"os\\\": \\\"darwin/amd64\\\",\\n \\\"peer\\\": \\\"...\\\",\\n \\\"public\\\": 0,\\n \\\"region\\\": \\\"...\\\",\\n \\\"tunnel\\\": false,\\n \\\"version\\\": \\\"...\\\",\\n \\\"wd\\\": 0\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"成功时```data.result```包含托管者总数```all```和托管者数组```nodes```，字段见下方属性表。\", \"type\": \"object\"}], \"title\": \"GetNodeList\"}, {\"_src_hash\": \"86b2c9626cc310581553413e6b19777c46c079e0f7c41d59e9a75aa22db1f8a0\", \"args\": [{\"info\": \"要删除的托管者Id，可以用```GetNodeList```查询。\", \"name\": \"nid\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"删除当前账号下的一个托管者；在线的托管者会被强制退出登录，其上的实盘全部变为「策略有错误」。删除后不可恢复。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('DeleteNode', 123)\\nprint(r) # 输出：{'code': 0, 'data': {'result': True, 'error': None}}\", \"lang\": \"python\"}], \"value\": \"删除Id为123的托管者。\"}], \"isChildren\": true, \"returns\": [{\"info\": \"```data.result```为```true```表示托管者记录已删除：平台让在线的该托管者强制退出登录，其上的实盘全部被置为「策略有错误」（状态码```5```）。托管者不存在、不属于该账号，或者无法让它退出登录时为```false```。\", \"type\": \"bool\"}], \"title\": \"DeleteNode\"}, {\"_src_hash\": \"7da6ce4b58766be97c8d56059c9240e023547934a519e9e31c989ef38dd2bcb3\", \"args\": [{\"info\": \"```true```只返回概要信息，不含```meta```、```stocks```；```false```返回完整信息。\", \"name\": \"isSummary\", \"required\": true, \"type\": \"bool\"}], \"attrs\": [{\"info\": \"交易所Id，例如```Futures_Binance```；实盘配置中直接传入交易所配置时用它。\", \"name\": \"exchanges[].eid\", \"type\": \"string\"}, {\"info\": \"显示名称，写作```中文|英文```。\", \"name\": \"exchanges[].name\", \"type\": \"string\"}, {\"info\": \"分类。\", \"name\": \"exchanges[].category\", \"type\": \"string\"}, {\"info\": \"交易所配置项的元数据（JSON文本），只在```isSummary```为```false```时返回；实盘配置中```meta```的字段名取自这里。\", \"name\": \"exchanges[].meta\", \"type\": \"string\"}, {\"info\": \"常用交易对，逗号分隔，只在```isSummary```为```false```时返回。\", \"name\": \"exchanges[].stocks\", \"type\": \"string\"}], \"desc\": [\"获取平台支持的交易所列表，以及每个交易所需要填写的配置项。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('GetExchangeList', True)\\nfor e in r['data']['result']['exchanges']:\\n print(e['eid'], e['name'])\", \"lang\": \"python\"}], \"value\": \"列出支持的交易所Id和名称（概要信息）。\"}], \"isChildren\": true, \"remarks\": [\"### 返回示例（isSummary为false）\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"exchanges\\\": [{\\n \\\"category\\\": \\\"加密货币||Crypto\\\",\\n \\\"eid\\\": \\\"Futures_Binance\\\",\\n \\\"id\\\": 74,\\n \\\"logo\\\": \\\"/upload/asset/d8d84b23e573e9326b99.svg\\\",\\n \\\"meta\\\": \\\"[...]\\\",\\n \\\"name\\\": \\\"币安期货|Futures_Binance\\\",\\n \\\"priority\\\": 200,\\n \\\"stocks\\\": \\\"BTC_USDT,ETH_USDT,ETH_USD\\\",\\n \\\"website\\\": \\\"https://accounts.binance.com/zh-TC/register?ref=45110270\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n其中```meta```是JSON文本，解析后为配置项数组：\\n\\n```json\\n[\\n {\\\"desc\\\": \\\"Access Key\\\", \\\"qr\\\": \\\"apiKey\\\", \\\"required\\\": true, \\\"type\\\": \\\"string\\\",\\n \\\"name\\\": \\\"AccessKey\\\", \\\"label\\\": \\\"Access Key\\\"},\\n {\\\"encrypt\\\": true, \\\"qr\\\": \\\"secretKey\\\", \\\"name\\\": \\\"SecretKey\\\", \\\"required\\\": true,\\n \\\"label\\\": \\\"Secret Key\\\", \\\"type\\\": \\\"password\\\", \\\"desc\\\": \\\"Secret Key\\\"}\\n]\\n```\", \"### 返回示例（isSummary为true）\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"exchanges\\\": [{\\n \\\"category\\\": \\\"加密货币||Crypto\\\",\\n \\\"eid\\\": \\\"Futures_Binance\\\",\\n \\\"id\\\": 74,\\n \\\"logo\\\": \\\"/upload/asset/d8d84b23e573e9326b99.svg\\\",\\n \\\"name\\\": \\\"币安期货|Futures_Binance\\\",\\n \\\"priority\\\": 200,\\n \\\"website\\\": \\\"https://accounts.binance.com/zh-TC/register?ref=45110270\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"成功时```data.result.exchanges```为交易所数组，字段见下方属性表。\", \"type\": \"object\"}], \"title\": \"GetExchangeList\"}, {\"_src_hash\": \"eda255751255f08de1b506a603385d15ec0fc106dd6d836e2c504bc719e12e03\", \"args\": [{\"info\": \"分页偏移，默认为0。\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"每页数量；不传或小于等于0时返回全部。\", \"name\": \"limit\", \"required\": false, \"type\": \"number\"}], \"attrs\": [{\"info\": \"已添加的交易所账户个数。\", \"name\": \"all\", \"type\": \"number\"}, {\"info\": \"交易所账户Id，即实盘配置```exchanges```中的```pid```。\", \"name\": \"platforms[].id\", \"type\": \"number\"}, {\"info\": \"交易所Id，一些配置、参数中会用到。\", \"name\": \"platforms[].eid\", \"type\": \"string\"}, {\"info\": \"添加时设置的标签。\", \"name\": \"platforms[].label\", \"type\": \"string\"}, {\"info\": \"常用交易对。\", \"name\": \"platforms[].stocks\", \"type\": \"array\"}], \"desc\": [\"获取当前账号已添加的交易所账户列表。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('GetPlatformList')\\nfor p in r['data']['result']['platforms']:\\n print(p['id'], p['eid'], p['label'])\", \"lang\": \"python\"}], \"value\": \"列出已添加的交易所账户，取得实盘配置要用的```pid```。\"}], \"isChildren\": true, \"remarks\": [\"### 返回示例\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 2,\\n \\\"platforms\\\": [{\\n \\\"category\\\": \\\"加密货币||Crypto\\\",\\n \\\"date\\\": \\\"2023-12-07 13:44:52\\\",\\n \\\"eid\\\": \\\"Binance\\\",\\n \\\"id\\\": 123,\\n \\\"label\\\": \\\"币安\\\",\\n \\\"logo\\\": \\\"...\\\",\\n \\\"name\\\": \\\"币安现货|Binance\\\",\\n \\\"stocks\\\": [\\\"BTC_USDT\\\", \\\"LTC_USDT\\\", \\\"ETH_USDT\\\", \\\"ETC_USDT\\\",\\n \\\"BTC_TUSD\\\", \\\"ETH_TUSD\\\", \\\"BNB_TUSD\\\"],\\n \\\"website\\\": \\\"...\\\"\\n }, {\\n \\\"category\\\": \\\"通用协议|Custom Protocol\\\",\\n \\\"date\\\": \\\"2020-11-09 11:23:48\\\",\\n \\\"eid\\\": \\\"Exchange\\\",\\n \\\"id\\\": 123,\\n \\\"label\\\": \\\"XX交易所REST协议\\\",\\n \\\"logo\\\": \\\"...\\\",\\n \\\"name\\\": \\\"通用协议|Custom Protocol\\\",\\n \\\"stocks\\\": [\\\"BTC_USDT\\\", \\\"ETH_USDT\\\"],\\n \\\"website\\\": \\\"\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"成功时```data.result```包含账户总数```all```和交易所账户数组```platforms```，字段见下方属性表。\", \"type\": \"object\"}], \"title\": \"GetPlatformList\"}, {\"_src_hash\": \"024bdcaaef36991d9f8b8cbd06970a2d53ecad82174497337c457b8b9434d9da\", \"args\": [{\"info\": \"分页偏移。\", \"name\": \"offset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"每页数量；小于等于0时返回全部。\", \"name\": \"length\", \"required\": true, \"type\": \"number\"}, {\"info\": \"查询范围，例如```-3```只查自己的策略；取值见备注。\", \"name\": \"strategyType\", \"required\": true, \"type\": \"number\"}, {\"info\": \"策略类型：```-1```全部，```0```普通策略，```20```模板类库，```21```交易插件。\", \"name\": \"category\", \"required\": true, \"type\": \"number\"}, {\"info\": \"策略的编程语言，```-1```为全部语言；取值见备注。\", \"name\": \"language\", \"required\": true, \"type\": \"number\"}, {\"info\": \"按策略名称模糊匹配的关键字，多个词用空格分隔；空字符串表示不筛选。以```id:```开头时按策略Id查询，例如```id:123,456```。\", \"name\": \"kw\", \"required\": true, \"type\": \"string\"}, {\"info\": \"策略分组：```-1```全部（默认），```0```未分组，大于0为指定分组。只对自己的策略生效。\", \"name\": \"groupId\", \"required\": false, \"type\": \"number\"}, {\"info\": \"排序字段：```name```、```last_modified```、```date```，后面加``` asc```为升序（默认降序）；空字符串为默认排序。\", \"name\": \"orderBy\", \"required\": false, \"type\": \"string\"}], \"attrs\": [{\"info\": \"符合条件的策略总数。\", \"name\": \"all\", \"type\": \"number\"}, {\"info\": \"策略数组。\", \"name\": \"strategies\", \"type\": \"array\"}, {\"info\": \"策略Id，即实盘配置中的```strategy```。\", \"name\": \"strategies[].id\", \"type\": \"number\"}, {\"info\": \"策略类型，取值同参数```category```。\", \"name\": \"strategies[].category\", \"type\": \"number\"}, {\"info\": \"编程语言，取值同参数```language```。\", \"name\": \"strategies[].language\", \"type\": \"number\"}], \"desc\": [\"按范围、类型、语言、关键字等条件查询策略列表。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('GetStrategyList', 0, 10, -3, -1, -1, '') # 自己的前10个策略\\nr = api('GetStrategyList', strategyType=-3, language=7) # 自己的全部Rust策略\\nfor s in r['data']['result']['strategies']:\\n print(s['id'], s['name'])\", \"lang\": \"python\"}], \"value\": \"按位置传参查询自己的前10个策略，或按参数名查询自己的全部Rust策略。\"}], \"isChildren\": true, \"remarks\": [\"参数中没有```needArgs```：按旧版文档在```category```之后多传一个参数，会使后面的参数错位，请按上面的顺序传参，或按参数名传值。\", \"按位置传参时只接受0、6、7、8个参数。不传任何参数（```args```为```[]```）时，服务端补上的是```(-1, -1, -1, -1, 1, \\\"\\\")```，即```language```为```1```，只返回Python策略；要查询全部语言，请传```language```为```-1```，或按参数名传值（按参数名传值时```language```缺省为```-1```）。\", \"### 参数取值\\n\\n```strategyType```（查询范围）：\\n\\n| 取值 | 含义 |\\n| - | - |\\n| ```-1``` | 自己的策略和租用的策略（含官方策略） |\\n| ```0``` | 自己的策略和租用的策略（不含官方策略） |\\n| ```-3``` | 只查自己的策略 |\\n| ```-6``` | 只查租用的策略（含已过期的） |\\n| ```-4``` | 官方策略 |\\n| ```-2``` | 策略广场中公开的策略和付费策略 |\\n| ```1``` | 已公开的策略 |\\n| ```2``` | 待审核的策略 |\\n\\n```category```（策略类型）：```-1```全部，```0```普通策略，```20```模板类库，```21```交易插件。\\n\\n```language```（编程语言）：\\n\\n| 取值 | 含义 |\\n| - | - |\\n| ```-1``` | 全部语言 |\\n| ```0``` | JavaScript |\\n| ```1``` | Python |\\n| ```3``` | 已停用的策略类型，只会出现在存量策略中 |\\n| ```4``` | My语言 |\\n| ```5``` | PINE语言 |\\n| ```6``` | Workflow工作流 |\\n| ```7``` | Rust |\", \"### 返回示例\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 123,\\n \\\"strategies\\\": [{\\n \\\"category\\\": 0,\\n \\\"date\\\": \\\"2024-11-10 20:40:04\\\",\\n \\\"description\\\": \\\"\\\",\\n \\\"forked\\\": 0,\\n \\\"hits\\\": 0,\\n \\\"id\\\": 123,\\n \\\"is_buy\\\": false,\\n \\\"is_owner\\\": false,\\n \\\"language\\\": 0,\\n \\\"last_modified\\\": \\\"2024-11-11 17:23:52\\\",\\n \\\"name\\\": \\\"HedgeGridStrategy\\\",\\n \\\"profile\\\": {\\n \\\"avatar\\\": \\\"...\\\",\\n \\\"nickname\\\": \\\"abc\\\",\\n \\\"uid\\\": \\\"4ed225440db1eda23fe05ed10184113e\\\"\\n },\\n \\\"public\\\": 0,\\n \\\"tags\\\": \\\"\\\",\\n \\\"uid\\\": \\\"4ed225440db1eda23fe05ed10184113e\\\",\\n \\\"username\\\": \\\"abc\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"成功时```data.result```包含策略总数```all```和策略数组```strategies```，字段见下方属性表。\", \"type\": \"object\"}], \"title\": \"GetStrategyList\"}, {\"_src_hash\": \"285e67aae5f09f50e7ee0b334ebd7bab82044238493e5a5c9c1596f312432366\", \"attrs\": [{\"info\": \"实盘分组Id，即实盘配置中的```group```。\", \"name\": \"items[].id\", \"type\": \"number\"}, {\"info\": \"实盘分组名称。\", \"name\": \"items[].name\", \"type\": \"string\"}], \"desc\": [\"获取当前账号的实盘分组列表；「默认」分组不在列表中。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('GetRobotGroupList')\\nfor g in r['data']['result']['items']:\\n print(g['id'], g['name'])\", \"lang\": \"python\"}], \"value\": \"列出实盘分组。\"}], \"isChildren\": true, \"remarks\": [\"### 返回示例\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"items\\\": [{\\n \\\"id\\\": 3417,\\n \\\"name\\\": \\\"测试\\\"\\n }, {\\n \\\"id\\\": 3608,\\n \\\"name\\\": \\\"实盘演示\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"成功时```data.result.items```为分组数组，只包含新建的分组，「默认」分组不在其中。\", \"type\": \"object\"}], \"title\": \"GetRobotGroupList\"}, {\"_src_hash\": \"62dc5f439ca7c9c9abf15167d40b1bc24acabb7d9a493f261b06b2d67636b216\", \"args\": [{\"info\": \"分页偏移，默认为0。\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"每页数量；小于等于0时返回全部（默认）。\", \"name\": \"length\", \"required\": false, \"type\": \"number\"}, {\"info\": \"按实盘状态码筛选，见{@扩展API接口/实盘状态码实盘状态码}；```-1```为全部实盘（默认），```-2```为全部实盘并按启动时间排序。\", \"name\": \"customStatus\", \"required\": false, \"type\": \"number\"}, {\"info\": \"按实盘的自定义标签（创建时```settings```中的```appid```）筛选，空字符串表示不筛选。\", \"name\": \"appId\", \"required\": false, \"type\": \"string\"}, {\"info\": \"按实盘名称模糊匹配的关键字，空字符串表示不筛选。\", \"name\": \"kw\", \"required\": false, \"type\": \"string\"}, {\"info\": \"实盘分组：```-1```全部（默认），```0```未分组，大于0为指定分组。\", \"name\": \"groupId\", \"required\": false, \"type\": \"number\"}, {\"info\": \"排序字段：```name```、```status```、```node```、```profit```、```date```、```refresh```、```start_time```、```strategy_name```，后面加``` asc```为升序（默认降序）；空字符串为默认排序。\", \"name\": \"orderBy\", \"required\": false, \"type\": \"string\"}, {\"info\": \"大于0时只返回该策略的实盘，默认为0（不筛选）。\", \"name\": \"strategyId\", \"required\": false, \"type\": \"number\"}], \"attrs\": [{\"info\": \"符合条件的实盘总数。\", \"name\": \"all\", \"type\": \"number\"}, {\"info\": \"实盘数组。\", \"name\": \"robots\", \"type\": \"array\"}, {\"info\": \"实盘Id。\", \"name\": \"robots[].id\", \"type\": \"number\"}, {\"info\": \"实盘状态码，见{@扩展API接口/实盘状态码实盘状态码}。\", \"name\": \"robots[].status\", \"type\": \"number\"}, {\"info\": \"实盘分组Id；在默认分组中的实盘没有这个字段。\", \"name\": \"robots[].group_id\", \"type\": \"number\"}], \"desc\": [\"获取当前账号的实盘列表，可以按状态、标签、名称、分组、策略筛选；参数都可以省略。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('GetRobotList') # 全部实盘\\nr = api('GetRobotList', 'member2') # 只传一个字符串时视为标签：标签为member2的全部实盘\\nr = api('GetRobotList', 0, 100, -1, 'member2', '') # 按位置传参：从第0条开始最多100个标签为member2的实盘\\nr = api('GetRobotList', appId='member2', length=100) # 按参数名传值，效果同上\\nfor robot in r['data']['result']['robots']:\\n print(robot['id'], robot['name'], robot['status'])\", \"lang\": \"python\"}], \"value\": \"获取全部实盘、按标签筛选，以及按位置或按参数名传参。\"}], \"isChildren\": true, \"remarks\": [\"### 返回示例\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 1,\\n \\\"concurrent\\\": 0,\\n \\\"robots\\\": [{\\n \\\"charge_time\\\": 1731654846,\\n \\\"date\\\": \\\"2024-11-12 14:05:29\\\",\\n \\\"end_time\\\": \\\"2024-11-15 14:56:32\\\",\\n \\\"fixed_id\\\": 4509153,\\n \\\"id\\\": 591026,\\n \\\"is_sandbox\\\": 0,\\n \\\"name\\\": \\\"测试\\\",\\n \\\"node_guid\\\": \\\"45891bcf3d57f99b08a43dff76ee1ea1\\\",\\n \\\"node_id\\\": 4519153,\\n \\\"node_public\\\": 0,\\n \\\"profit\\\": 0,\\n \\\"public\\\": 0,\\n \\\"refresh\\\": 1731651257000,\\n \\\"start_time\\\": \\\"2024-11-15 14:56:30\\\",\\n \\\"status\\\": 3,\\n \\\"strategy_id\\\": 411670,\\n \\\"strategy_isowner\\\": true,\\n \\\"strategy_language\\\": 0,\\n \\\"strategy_name\\\": \\\"测试\\\",\\n \\\"strategy_public\\\": 0,\\n \\\"uid\\\": \\\"105ed6e511cc977921610fdbb7e2a1d6\\\",\\n \\\"wd\\\": 0\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"成功时```data.result```包含实盘总数```all```和实盘数组```robots```，字段见下方属性表。\", \"type\": \"object\"}], \"title\": \"GetRobotList\"}, {\"_src_hash\": \"71ee9e21871925310db591952d3cb09025842f9cd181e25ace243e19e94b512c\", \"args\": [{\"info\": \"实盘Id，可以用```GetRobotList```查询。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}], \"attrs\": [{\"info\": \"实盘状态码，见{@扩展API接口/实盘状态码实盘状态码}。\", \"name\": \"robot.status\", \"type\": \"number\"}, {\"info\": \"实盘名称。\", \"name\": \"robot.name\", \"type\": \"string\"}, {\"info\": \"创建日期。\", \"name\": \"robot.date\", \"type\": \"string\"}, {\"info\": \"下次扣费时间（Unix时间戳，秒），即当前已付费时段的截止时间。\", \"name\": \"robot.charge_time\", \"type\": \"number\"}, {\"info\": \"累计计费时长，单位为秒。\", \"name\": \"robot.charged\", \"type\": \"number\"}, {\"info\": \"累计扣费金额，单位为USD，按1e8放大为整数；示例中5375000000即53.75 USD。\", \"name\": \"robot.consumed\", \"type\": \"number\"}, {\"info\": \"托管者Id。\", \"name\": \"robot.node_id\", \"type\": \"number\"}, {\"info\": \"实盘配置中指定的托管者Id；自动分配时为```-1```。\", \"name\": \"robot.fixed_id\", \"type\": \"number\"}, {\"info\": \"是否有权限管理该实盘。\", \"name\": \"robot.is_manager\", \"type\": \"bool\"}, {\"info\": \"是否是模拟盘。\", \"name\": \"robot.is_sandbox\", \"type\": \"number\"}, {\"info\": \"实盘配置的交易所对象：键为```pid```，值为交易所Id（```eid```），如```{\\\"123\\\": \\\"Futures_OKX\\\"}```。\", \"name\": \"robot.pexchanges\", \"type\": \"object\"}, {\"info\": \"实盘配置的交易所对象的标签，键为```pid```。\", \"name\": \"robot.plabels\", \"type\": \"object\"}, {\"info\": \"默认K线周期、交易所对象和交易对（JSON文本），格式见备注。\", \"name\": \"robot.strategy_exchange_pairs\", \"type\": \"string\"}, {\"info\": \"实盘收益。\", \"name\": \"robot.profit\", \"type\": \"number\"}, {\"info\": \"实盘是否公开。\", \"name\": \"robot.public\", \"type\": \"number\"}, {\"info\": \"最近活跃时间（毫秒时间戳）。\", \"name\": \"robot.refresh\", \"type\": \"number\"}, {\"info\": \"是否开启离线报警。\", \"name\": \"robot.wd\", \"type\": \"number\"}], \"desc\": [\"获取当前账号下一个实盘的详细信息，包括状态、计费、交易所配置和策略参数。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('GetRobotDetail', 123)\\nrobot = r['data']['result']['robot']\\nprint(robot['status'], robot['pexchanges'], robot['strategy_exchange_pairs'])\", \"lang\": \"python\"}], \"value\": \"查询实盘123的状态和交易所配置。\"}], \"isChildren\": true, \"remarks\": [\"```strategy_exchange_pairs```是一个JSON数组的文本，例如```\\\"[60,[44314,42960,15445,14703],[\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\"]]\\\"```：\\n\\n- ```60```：实盘设置的默认K线周期，单位为秒（这里为1分钟）。\\n- ```[44314,42960,15445,14703]```：实盘配置的交易所对象的```pid```，按添加顺序排列。\\n- ```[\\\"BTC_USDT\\\",\\\"BTC_USDT\\\",\\\"ETH_USDT\\\",\\\"ETH_USDT\\\"]```：各交易所对象设置的交易对，与```pid```按顺序一一对应。\", \"### 返回示例\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"robot\\\": {\\n \\\"charge_time\\\": 1732246539,\\n \\\"charged\\\": 5850000,\\n \\\"consumed\\\": 5375000000,\\n \\\"date\\\": \\\"2018-12-28 14:34:51\\\",\\n \\\"favorite\\\": {\\n \\\"added\\\": false,\\n \\\"type\\\": \\\"R\\\"\\n },\\n \\\"fixed_id\\\": 123,\\n \\\"hits\\\": 1,\\n \\\"id\\\": 123,\\n \\\"is_deleted\\\": 0,\\n \\\"is_manager\\\": true,\\n \\\"is_sandbox\\\": 0,\\n \\\"name\\\": \\\"测试\\\",\\n \\\"node_id\\\": 123,\\n \\\"pexchanges\\\": {\\n \\\"123\\\": \\\"Futures_OKX\\\"\\n },\\n \\\"phash\\\": {\\n \\\"123\\\": \\\"ca1aca74b9cf7d8624f2af2dac01e36d\\\"\\n },\\n \\\"plabels\\\": {\\n \\\"123\\\": \\\"OKX期货\\\"\\n },\\n \\\"priority\\\": 0,\\n \\\"profit\\\": 0,\\n \\\"public\\\": 0,\\n \\\"refresh\\\": 1732244453000,\\n \\\"robot_args\\\": \\\"[]\\\",\\n \\\"start_time\\\": \\\"2024-11-22 11:00:48\\\",\\n \\\"status\\\": 1,\\n \\\"strategy_args\\\": \\\"[]\\\",\\n \\\"strategy_exchange_pairs\\\": \\\"[60,[123],[\\\\\\\"ETH_USDT\\\\\\\"]]\\\",\\n \\\"strategy_id\\\": 123,\\n \\\"strategy_last_modified\\\": \\\"2024-11-21 16:49:25\\\",\\n \\\"strategy_name\\\": \\\"测试\\\",\\n \\\"strategy_public\\\": \\\"0\\\",\\n \\\"uid\\\": \\\"105ed6e51bcc17792a610fdbb7e2a1d6\\\",\\n \\\"username\\\": \\\"abc\\\",\\n \\\"wd\\\": 0\\n }\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"成功时```data.result.robot```为实盘信息，字段见下方属性表。\", \"type\": \"object\"}], \"title\": \"GetRobotDetail\"}, {\"_src_hash\": \"4eed8f7088652bbfb8158bee95dc8cdb3c89856a2794c3883da7ecb0ede25d27\", \"args\": [{\"info\": \"实盘Id，可以用```GetRobotList```查询。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"策略日志的最小Id。\", \"name\": \"logMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"策略日志的最大Id。\", \"name\": \"logMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"在```logMinId```、```logMaxId```确定的范围内跳过的记录条数。\", \"name\": \"logOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"从起始位置开始取的记录条数。\", \"name\": \"logLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"收益日志的最小Id。\", \"name\": \"profitMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"收益日志的最大Id。\", \"name\": \"profitMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"跳过的记录条数。\", \"name\": \"profitOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"取的记录条数。\", \"name\": \"profitLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"图表日志的最小Id。\", \"name\": \"chartMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"图表日志的最大Id。\", \"name\": \"chartMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"跳过的记录条数。\", \"name\": \"chartOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"取的记录条数。\", \"name\": \"chartLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"查询更新后的基础Id。\", \"name\": \"chartUpdateBaseId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"数据记录更新时间戳，只返回比它新的记录。\", \"name\": \"chartUpdateDate\", \"required\": true, \"type\": \"number\"}, {\"info\": \"是否返回状态栏数据：```0```不返回；大于0时返回，放在```summary```字段中（数值本身不起作用，最多返回2MB）。\", \"name\": \"summaryLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"只返回该交易所对象（按标签）的日志，空字符串表示不筛选。\", \"name\": \"logExchange\", \"required\": false, \"type\": \"string\"}, {\"info\": \"只返回内容包含该关键字的日志，空字符串表示不筛选。\", \"name\": \"logKeyword\", \"required\": false, \"type\": \"string\"}, {\"info\": \"只返回这些类型的日志，类型号用逗号分隔，例如```\\\"0,1,2\\\"```只看买单、卖单、撤单；空字符串表示全部类型。\", \"name\": \"logTypes\", \"required\": false, \"type\": \"string\"}], \"attrs\": [{\"info\": \"三个对象，依次是实盘数据库中策略日志表、收益日志表、图表日志表的查询结果；每个对象的```Arr```为日志记录，格式见备注。\", \"name\": \"logs\", \"type\": \"array\"}, {\"info\": \"实盘状态栏数据（```summaryLimit```大于0时返回）。\", \"name\": \"summary\", \"type\": \"string\"}, {\"info\": \"实盘状态码，见{@扩展API接口/实盘状态码实盘状态码}。\", \"name\": \"status\", \"type\": \"number\"}], \"desc\": [\"获取当前账号下一个实盘的策略日志、收益日志、图表数据和状态栏数据。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('GetRobotLogs', robotId=123, logLimit=10, summaryLimit=1)\\nresult = r['data']['result']\\nfor row in result['logs'][0]['Arr']:\\n print(row)\\nprint(result['summary']) # 状态栏数据\", \"lang\": \"python\"}], \"value\": \"按参数名查询实盘123最近的10条策略日志和状态栏数据。\"}], \"isChildren\": true, \"remarks\": [\"参数较多，建议按参数名传值，没有传的参数取默认值；按位置传参时要传15～19个（15个时不查询状态栏）。```logExchange```、```logKeyword```、```logTypes```三个筛选参数只在新版托管者上生效，旧版托管者会忽略它们，返回全部日志。\", \"### logs[0]：策略日志\\n\\n```logs[0].Arr```中的每条日志是一个数组，依次为：日志Id（```id```）、日志类型（```logType```）、交易所对象的标签（```platformId```）、订单Id（```orderId```）、价格（```price```）、数量（```amount```）、日志的附加消息（```extra```）、时间戳（```date```）、合约代码（```contractType```）、方向（```direction```）。例如：\\n\\n```plaintext\\n\\\"Arr\\\": [\\n [3977, 3, \\\"Futures_OKX\\\", \\\"\\\", 0, 0, \\\"Sell(688.9, 2): 20016\\\", 1526954372591, \\\"\\\", \\\"\\\"],\\n [3976, 5, \\\"\\\", \\\"\\\", 0, 0, \\\"this_week 仓位过多, 多: 2\\\", 1526954372410, \\\"\\\", \\\"\\\"]\\n]\\n```\\n\\n```logType```的取值：\\n\\n| logType | 名称 | 含义 |\\n| - | - | - |\\n| 0 | BUY | 买单 |\\n| 1 | SALE | 卖单 |\\n| 2 | RETRACT | 撤单 |\\n| 3 | ERROR | 错误 |\\n| 4 | PROFIT | 收益 |\\n| 5 | MESSAGE | 日志 |\\n| 6 | RESTART | 重启 |\", \"### logs[1]：收益日志\\n\\n与策略日志中的收益日志一致，每条依次为日志Id、收益数值、时间戳。例如```[202, 2515.44, 1575896700315]```中```202```为日志Id，```2515.44```为收益，```1575896700315```为时间戳：\\n\\n```plaintext\\n\\\"Arr\\\": [\\n [202, 2515.44, 1575896700315],\\n [201, 1415.44, 1575896341568]\\n]\\n```\", \"### logs[2]：图表日志\\n\\n每条依次为日志Id、图表数据系列索引、数据（JSON文本）。例如```[23637, 0, \\\"{\\\\\\\"close\\\\\\\":648, ...}\\\"]```中```23637```为日志Id，```0```为数据系列索引，最后的JSON文本是图表上的一根K线：\\n\\n```plaintext\\n\\\"Arr\\\": [\\n [23637, 0, \\\"{\\\\\\\"close\\\\\\\":648,\\\\\\\"high\\\\\\\":650.5,\\\\\\\"low\\\\\\\":647,\\\\\\\"open\\\\\\\":650,\\\\\\\"x\\\\\\\":1575960300000}\\\"],\\n [23636, 5, \\\"{\\\\\\\"x\\\\\\\":1575960300000,\\\\\\\"y\\\\\\\":3.0735}\\\"]\\n]\\n```\", \"### 返回示例\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"chart\\\": \\\"\\\",\\n \\\"chartTime\\\": 0,\\n \\\"logs\\\": [{\\n \\\"Total\\\": 20,\\n \\\"Max\\\": 20,\\n \\\"Min\\\": 1,\\n \\\"Arr\\\": []\\n }, {\\n \\\"Total\\\": 0,\\n \\\"Max\\\": 0,\\n \\\"Min\\\": 0,\\n \\\"Arr\\\": []\\n }, {\\n \\\"Total\\\": 0,\\n \\\"Max\\\": 0,\\n \\\"Min\\\": 0,\\n \\\"Arr\\\": []\\n }],\\n \\\"node_id\\\": 123,\\n \\\"online\\\": true,\\n \\\"refresh\\\": 1732201544000,\\n \\\"status\\\": 4,\\n \\\"summary\\\": \\\"...\\\",\\n \\\"updateTime\\\": 1732201532636,\\n \\\"wd\\\": 0\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\"], \"returns\": [{\"info\": \"成功时```data.result```包含日志```logs```和状态栏数据```summary```等，字段见下方属性表。\", \"type\": \"object\"}], \"title\": \"GetRobotLogs\"}, {\"_src_hash\": \"5e0633a576409daf6dfd139304f0ef6a13ac415133f80aadd045fcb508a5fa77\", \"args\": [{\"info\": \"实盘配置，字段见{@扩展API接口/扩展API接口详解扩展API接口详解}中的「实盘配置（settings）」。\", \"name\": \"settings\", \"required\": true, \"type\": \"object\"}], \"desc\": [\"在当前账号下创建一个实盘并启动运行；与在网页上创建实盘一样会扣费，实盘会真实交易。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nsettings = {\\n \\\"name\\\": \\\"test\\\",\\n \\\"strategy\\\": 123,\\n \\\"args\\\": [],\\n \\\"exchanges\\\": [\\n {\\\"pid\\\": 123, \\\"pair\\\": \\\"SOL_USDT\\\"}\\n ],\\n \\\"period\\\": 60,\\n \\\"node\\\": 123,\\n \\\"group\\\": 123,\\n \\\"appid\\\": \\\"test\\\"\\n}\\nr = api('NewRobot', settings)\\nprint(r['data']['result']) # 输出：591988（新实盘的Id）\", \"lang\": \"python\"}], \"value\": \"用已添加的交易所账户（```pid```）创建并启动实盘。\"}], \"isChildren\": true, \"remarks\": [\"通过扩展API接口创建时，平台等启动流程执行完再返回。启动失败（例如策略编译出错）时同样返回新实盘的Id，实盘处于「策略有错误」状态（状态码```5```），所以创建后要用```GetRobotDetail```确认实盘状态。\", \"返回负数时没有创建实盘，含义见{@扩展API接口/实盘状态码实盘状态码}中的「启动失败的返回值」，例如```-2```没有找到托管者，```-5```余额不足。账号可运行的实盘数量超限时，返回```code```为6的错误。\", \"用```eid```方式直接传入交易所配置时，平台不保存```meta```中的密钥，之后每次用```RestartRobot```重启这个实盘都必须传入```settings```。\"], \"returns\": [{\"info\": \"```data.result```：成功创建时为新实盘的Id；```0```表示```settings```中的```args```不是数组；负数表示没有创建实盘，见备注。\", \"type\": \"number\"}], \"title\": \"NewRobot\"}, {\"_src_hash\": \"451509ab27d4fa49046499465e423944585eedc8b6848fad76758a31a811c34e\", \"args\": [{\"info\": \"实盘Id，可以用```GetRobotList```查询。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"新的实盘配置，传入时整份覆盖原配置再启动，见备注；字段见{@扩展API接口/扩展API接口详解扩展API接口详解}中的「实盘配置（settings）」。\", \"name\": \"settings\", \"required\": false, \"type\": \"object\"}], \"desc\": [\"启动（重启）当前账号下的一个实盘，可以同时用新的配置替换原配置；启动会扣费。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('RestartRobot', 123)\\nprint(r['data']['result']) # 输出：0（准备中，启动流程已执行完）\", \"lang\": \"python\"}], \"value\": \"按实盘当前的配置启动实盘123。\"}], \"isChildren\": true, \"remarks\": [\"在平台页面创建、使用已添加交易所账户（```pid```）的实盘，可以只传```robotId```，按实盘当前的配置启动。用```eid```方式直接传入交易所配置的实盘（通常由扩展API接口创建），平台没有保存密钥，每次重启都必须传入```settings```。\", \"传入```settings```时，先用它**整份覆盖**实盘的配置（名称、参数、交易所、K线周期、托管者），再启动；不能更换策略。没有写的字段不会保留原值：```name```变为空字符串，```args```变为```[]```（参数全部恢复默认值），没写```exchanges```会删除实盘的全部交易所配置，```period```变为60秒，```node```变为自动分配；只有```group```不写或为```0```时保留原分组。所以传入```settings```时必须写出完整配置，建议先用```GetRobotDetail```取得当前配置再修改。\", \"实盘处于准备中、运行中或停止中时传入```settings```，返回```code```为6的错误（```robot is running```）；不传```settings```时不会重新启动，直接返回当前的状态码（```0```、```1```、```2```）。\", \"返回负数表示启动失败，含义见{@扩展API接口/实盘状态码实盘状态码}中的「启动失败的返回值」。启动后实盘是运行中，还是因编译出错等进入「策略有错误」，要用```GetRobotDetail```查询。\"], \"returns\": [{\"info\": \"```data.result```：正常情况下为```0```（准备中），表示启动流程已执行完；启动是否成功要用```GetRobotDetail```查询。其它返回值见备注。\", \"type\": \"number\"}], \"title\": \"RestartRobot\"}, {\"_src_hash\": \"e88e06b753f17f4965e94b891682ba65d1fdd7da79c1b728a329dc056c8bc060\", \"args\": [{\"info\": \"实盘Id，可以用```GetRobotList```查询。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"停止当前账号下的一个实盘；停止不会自动平仓。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('StopRobot', 123)\\nprint(r['data']['result']) # 输出：2（停止中）\", \"lang\": \"python\"}], \"value\": \"停止实盘123。\"}], \"isChildren\": true, \"remarks\": [\"实盘正在启动或停止的过程中（```robot is busy```）、托管者不在线（```docker not found```）时，返回```code```为6的错误。\"], \"returns\": [{\"info\": \"```data.result```为实盘状态码：```2```（停止中）表示已向托管者发出停止命令；```4```（被停止）表示实盘所在的托管者已被删除，实盘直接置为被停止；```3```、```4```、```5```也可能表示实盘本来就已经结束。\", \"type\": \"number\"}], \"title\": \"StopRobot\"}, {\"_src_hash\": \"73ec9c7670df4cc0594722ec8dbe687ffb79dfb95070f14f442db8031a1eb469\", \"args\": [{\"info\": \"接收命令的实盘Id，可以用```GetRobotList```查询。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"交互命令，策略中用```GetCommand()```获取。\", \"name\": \"cmd\", \"required\": true, \"type\": \"string\"}], \"desc\": [\"向当前账号下运行中的实盘发送一条交互命令，策略用{@fun/Global/GetCommand GetCommand}接收。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('CommandRobot', 123, 'test command')\\nprint(r['data']['result']) # 输出：True\", \"lang\": \"python\"}], \"value\": \"向运行中的实盘123发送命令```test command```，实盘的策略用```GetCommand()```收到后打印（策略代码见备注）。\"}], \"isChildren\": true, \"remarks\": [\"接收命令的策略示例：\\n\\n```javascript\\n// 实盘123运行的策略：收到交互命令后打印出来\\nfunction main() {\\n while (true) {\\n var cmd = GetCommand()\\n if (cmd) {\\n Log(cmd)\\n }\\n Sleep(2000)\\n }\\n}\\n```\", \"在TradingView等只能填写一个URL的Webhook中调用```CommandRobot```，见{@扩展API接口/验证方式/直接验证直接验证}。\"], \"returns\": [{\"info\": \"```data.result```表示交互命令是否发送成功；向没有运行的实盘发送命令时为```false```。\", \"type\": \"bool\"}], \"title\": \"CommandRobot\"}, {\"_src_hash\": \"f8ff583140899bbf39bad0db09180e8a77273cb24e6049807a528957cd6a1305\", \"args\": [{\"info\": \"实盘Id，可以用```GetRobotList```查询。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"是否同时删除托管者上的实盘日志数据。按参数名传值时默认为```true```；按位置只传```[robotId]```时为```false```。建议显式传入。\", \"name\": \"removeLog\", \"required\": false, \"type\": \"bool\"}], \"desc\": [\"删除当前账号下的一个实盘；运行中的实盘要先停止才能删除，删除后不可恢复。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nr = api('DeleteRobot', robotId=123, removeLog=True)\\nprint(r['data']['result']) # 输出：0（删除成功）\", \"lang\": \"python\"}], \"value\": \"删除已停止的实盘123，同时删除托管者上的日志数据。\"}], \"isChildren\": true, \"returns\": [{\"info\": \"```data.result```：```0```删除成功；```-1```没有删除（实盘不存在，或者仍在运行、启动中、停止中）；```-2```实盘已删除，但无法联系实盘所在的托管者，日志数据没有删除，需要到托管者目录```logs/storage/<实盘Id>/```下手动删除（例如```123.db3```）。\", \"type\": \"number\"}], \"title\": \"DeleteRobot\"}, {\"_src_hash\": \"69d02a257e6177631bcc1bffda50bcb26f7b6cf674dfa04f6868887a20669a72\", \"args\": [{\"info\": \"执行配置，字段见下方属性表。\", \"name\": \"settings\", \"required\": true, \"type\": \"object\"}], \"attrs\": [{\"info\": \"要执行的代码，入口为```main()```，返回值就是执行结果。\", \"name\": \"settings.source\", \"type\": \"string\"}, {\"info\": \"不传```source```时，执行账号中这个Id的策略（例如交易插件）。\", \"name\": \"settings.strategy\", \"type\": \"number\"}, {\"info\": \"执行代码的托管者Id；不写或为```-1```时自动选择。\", \"name\": \"settings.node\", \"type\": \"number\"}, {\"info\": \"交易所对象配置，写法同{@扩展API接口/扩展API接口详解扩展API接口详解}中的「实盘配置（settings）」。\", \"name\": \"settings.exchanges\", \"type\": \"array\"}], \"desc\": [\"在托管者上执行一段JavaScript代码并返回结果，不创建实盘、不计费，单次执行最长5分钟；代码可以真实下单。\"], \"examples\": [{\"examples\": [{\"code\": \"# api() 见「签名验证」页面的Python示例\\nimport json\\n\\nsettings = {\\n \\\"source\\\": \\\"function main() {Log(\\\\\\\"Hello FMZ\\\\\\\")}\\\",\\n \\\"node\\\": 123,\\n \\\"period\\\": 60,\\n \\\"exchanges\\\": [{\\\"pid\\\": 123, \\\"pair\\\": \\\"SOL_USDT\\\"}]\\n}\\nr = api('PluginRun', settings)\\nout = json.loads(r['data']['result'])\\nprint(out['logs'], out['result'])\", \"lang\": \"python\"}], \"value\": \"在托管者123上执行一段代码，取回日志和返回值。\"}], \"isChildren\": true, \"remarks\": [\"与开发工具中的「调试工具」、交易终端插件使用同一种执行机制，见{@平台基础/交易终端/插件原理与编写插件原理与编写}。\", \"```exchanges```也可以不引用平台上的交易所账户，直接传入交易所配置，例如```{\\\"eid\\\": \\\"Binance\\\", \\\"pair\\\": \\\"ETH_BTC\\\", \\\"meta\\\": {\\\"AccessKey\\\": \\\"...\\\", \\\"SecretKey\\\": \\\"...\\\"}}```，```meta```的字段名见```GetExchangeList```返回的```meta```。```exchanges```中通常只设置一个交易所对象（调试工具页面也只支持一个）；设置两个不会报错，但代码中访问第二个交易所对象时会报错。\", \"### 返回示例\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": \\\"{\\\\\\\"logs\\\\\\\": [...], \\\\\\\"result\\\\\\\": \\\\\\\"\\\\\\\"}\\\",\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n其中```result```解析后为：\\n\\n```json\\n{\\n \\\"logs\\\": [{\\n \\\"PlatformId\\\": \\\"\\\", \\\"OrderId\\\": \\\"0\\\", \\\"LogType\\\": 5, \\\"Price\\\": 0, \\\"Amount\\\": 0,\\n \\\"Extra\\\": \\\"Hello FMZ\\\", \\\"Currency\\\": \\\"\\\", \\\"Instrument\\\": \\\"\\\", \\\"Direction\\\": \\\"\\\",\\n \\\"Time\\\": 1732267473108\\n }],\\n \\\"result\\\": \\\"\\\"\\n}\\n```\"], \"returns\": [{\"info\": \"```data.result```是JSON文本：```logs```为代码中```Log()```输出的日志，```result```为```main()```返回值的JSON文本。\", \"type\": \"string\"}], \"title\": \"PluginRun\"}, {\"_src_hash\": \"962be2513d78ecb4c0cb2f476000ac0429f1f0cdc5b3c22bd9124e0db9264434\", \"args\": [{\"info\": \"接收消息的实盘Id（URL参数）。该实盘必须正在运行，并且已经订阅了```channel```频道。\", \"name\": \"robot\", \"required\": true, \"type\": \"number\"}, {\"info\": \"频道名（URL参数），建议用32位随机字符串（UUID去掉连字符）。不能是纯数字（纯数字会被当作实盘Id，即实盘自己的频道）；少于10个字符的频道名不会投递。\", \"name\": \"channel\", \"required\": true, \"type\": \"string\"}, {\"info\": \"消息内容。```POST```请求时取整个请求体，可以是JSON、普通文本等任意文本；不是```POST```时取URL参数```message```。\", \"name\": \"message\", \"required\": false, \"type\": \"string\"}], \"attrs\": [{\"info\": \"推送成功时为```ok```。\", \"name\": \"data.status\", \"type\": \"string\"}, {\"info\": \"本次请求的```robot```参数。\", \"name\": \"data.robot\", \"type\": \"number\"}, {\"info\": \"本次请求的```channel```参数。\", \"name\": \"data.channel\", \"type\": \"string\"}, {\"info\": \"本次推送的消息。\", \"name\": \"data.message\", \"type\": \"string\"}, {\"info\": \"收到消息的托管者数量。\", \"name\": \"data.affected\", \"type\": \"number\"}], \"desc\": [\"把一条消息推送到运行中实盘订阅的频道，供平台外部的系统（TradingView 的 Webhook 告警、自建交易系统、监控脚本等）向实盘发送数据。实盘用{@fun/Storage/GetChannelData GetChannelData}读取，频道机制见{@进阶专题/策略实盘间通信策略实盘间通信}。\", \"与其它方法不同，```pub```**不需要API KEY，也不签名**：请求地址是```https://www.fmz.com/api/v1?method=pub&robot={robotId}&channel={channel}```，消息放在请求体中（```POST```）。知道实盘Id和频道名的任何人都能推送，所以频道名要用难以猜到的随机字符串，策略也要把收到的内容当作不可信的输入来校验。\"], \"examples\": [{\"examples\": [{\"code\": \"// 接收端实盘（假设实盘Id为123456）\\nvar CHANNEL = \\\"6BC42A119B5DBFA2188A8279DA3B5C30\\\"\\n\\nfunction main() {\\n var lastId = null\\n while (true) {\\n var msg = GetChannelData(CHANNEL) // 第一次调用即订阅，返回null\\n if (typeof msg == \\\"string\\\") {\\n var obj = null\\n try {\\n obj = JSON.parse(msg) // 请求体是JSON文本时再解析一次\\n } catch (e) {\\n Log(\\\"非JSON消息：\\\", msg)\\n }\\n if (obj && obj.id != lastId) { // 频道只保存最新一条，用id判断是否是新消息\\n lastId = obj.id\\n Log(\\\"收到外部消息：\\\", obj)\\n }\\n }\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import json\\n\\nCHANNEL = \\\"6BC42A119B5DBFA2188A8279DA3B5C30\\\"\\n\\ndef main():\\n lastId = None\\n while True:\\n msg = GetChannelData(CHANNEL) # 第一次调用即订阅，返回None\\n if isinstance(msg, str):\\n try:\\n obj = json.loads(msg) # 请求体是JSON文本时再解析一次\\n except ValueError:\\n obj = None\\n Log(\\\"非JSON消息：\\\", msg)\\n if isinstance(obj, dict) and obj.get(\\\"id\\\") != lastId:\\n lastId = obj.get(\\\"id\\\")\\n Log(\\\"收到外部消息：\\\", obj)\\n Sleep(1000)\", \"lang\": \"python\"}], \"value\": \"接收端策略：订阅频道，把收到的JSON消息解析出来，并用```id```区分新旧消息。\"}], \"isChildren\": true, \"remarks\": [\"### 投递规则\\n\\n- 先订阅、后推送：实盘第一次调用```GetChannelData(channel)```即订阅该频道（返回空值），订阅随托管者心跳上报，稍等片刻后外部系统才能推送成功。没有实盘订阅时请求失败。\\n- 消息投递到```robot```实盘所在的托管者，该托管者上所有订阅了同一频道的实盘都会收到；其它托管者上的实盘收不到。\\n- 频道只保存最新一条消息，不排队：```GetChannelData()```每次返回最近收到的一条，读取不会清除它。需要区分新旧消息时，在消息中带上递增的编号或时间戳。\\n- 每个实盘最多订阅10个频道（含其它实盘的频道），超出时```GetChannelData()```返回空值并记录错误日志```channel subscriber exceed limit```。\\n- 实盘收到的是**字符串**（请求体原文）。请求体是JSON文本时，策略需要自己再解析一次。\", \"### 推送请求示例\\n\\n外部系统推送一条消息：\\n\\n```bash\\ncurl -X POST \\\\\\n \\\"https://www.fmz.com/api/v1?method=pub&robot=123456&channel=6BC42A119B5DBFA2188A8279DA3B5C30\\\" \\\\\\n -d '{\\\"id\\\": 1, \\\"action\\\": \\\"buy\\\", \\\"symbol\\\": \\\"BTC_USDT\\\"}'\\n```\\n\\n在TradingView中使用时，把上面的URL填入告警的Webhook地址，告警消息内容就是请求体。\", \"### 返回示例\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"status\\\": \\\"ok\\\",\\n \\\"robot\\\": 123456,\\n \\\"channel\\\": \\\"6BC42A119B5DBFA2188A8279DA3B5C30\\\",\\n \\\"message\\\": \\\"{\\\\\\\"id\\\\\\\": 1, \\\\\\\"action\\\\\\\": \\\\\\\"buy\\\\\\\", \\\\\\\"symbol\\\\\\\": \\\\\\\"BTC_USDT\\\\\\\"}\\\",\\n \\\"affected\\\": 1\\n }\\n}\\n```\\n\\n没有实盘订阅该频道时：\\n\\n```json\\n{\\n \\\"code\\\": 5,\\n \\\"error\\\": \\\"No subscribers for channel: 6BC42A119B5DBFA2188A8279DA3B5C30\\\",\\n \\\"data\\\": null\\n}\\n```\"], \"returns\": [{\"info\": \"推送成功时```code```为0，```data```字段见下方属性表；没有实盘订阅该频道（或频道名不合规、```robot```为空）时，HTTP状态码为500，```code```为5。\", \"type\": \"object\"}], \"title\": \"pub\"}], \"desc\": \"所有方法都通过```https://www.fmz.com/api/v1```调用，请求格式与签名见{@扩展API接口/验证方式/token验证签名验证}，返回结构与错误码见{@扩展API接口/扩展API接口返回码扩展API接口返回码}。各方法页面示例中的```api()```即签名验证页面Python示例中的函数。\\n\\n### 方法一览\\n\\n| 对象 | 方法 | 参数（按顺序，方括号内为可选参数） | 说明 | 注意 |\\n| - | - | - | - | - |\\n| 账号 | {@扩展API接口/扩展API接口详解/GetAccount GetAccount} | 无 | 账号信息 | 只读 |\\n| 托管者 | {@扩展API接口/扩展API接口详解/GetNodeList GetNodeList} | [offset, limit] | 托管者列表 | 只读 |\\n| 托管者 | {@扩展API接口/扩展API接口详解/DeleteNode DeleteNode} | nid | 删除托管者 | 删除，不可恢复 |\\n| 交易所 | {@扩展API接口/扩展API接口详解/GetExchangeList GetExchangeList} | isSummary | 平台支持的交易所及配置项 | 只读 |\\n| 交易所 | {@扩展API接口/扩展API接口详解/GetPlatformList GetPlatformList} | [offset, limit] | 已添加的交易所账户 | 只读 |\\n| 策略 | {@扩展API接口/扩展API接口详解/GetStrategyList GetStrategyList} | offset, length, strategyType, category, language, kw[, groupId, orderBy] | 策略列表 | 只读 |\\n| 实盘 | {@扩展API接口/扩展API接口详解/GetRobotGroupList GetRobotGroupList} | 无 | 实盘分组 | 只读 |\\n| 实盘 | {@扩展API接口/扩展API接口详解/GetRobotList GetRobotList} | [offset, length, customStatus, appId, kw, groupId, orderBy, strategyId] | 实盘列表 | 只读 |\\n| 实盘 | {@扩展API接口/扩展API接口详解/GetRobotDetail GetRobotDetail} | robotId | 实盘详细信息 | 只读 |\\n| 实盘 | {@扩展API接口/扩展API接口详解/GetRobotLogs GetRobotLogs} | robotId, logMinId, …, summaryLimit[, logExchange, logKeyword, logTypes] | 日志、收益、图表与状态栏数据 | 只读 |\\n| 实盘 | {@扩展API接口/扩展API接口详解/NewRobot NewRobot} | settings | 创建并启动实盘 | 扣费；实盘会真实交易 |\\n| 实盘 | {@扩展API接口/扩展API接口详解/RestartRobot RestartRobot} | robotId[, settings] | 启动（重启）实盘 | 扣费；实盘会真实交易 |\\n| 实盘 | {@扩展API接口/扩展API接口详解/StopRobot StopRobot} | robotId | 停止实盘 | 不会平仓 |\\n| 实盘 | {@扩展API接口/扩展API接口详解/CommandRobot CommandRobot} | robotId, cmd | 向实盘发送交互命令 | 策略可能据此下单 |\\n| 实盘 | {@扩展API接口/扩展API接口详解/DeleteRobot DeleteRobot} | robotId[, removeLog] | 删除实盘 | 删除，不可恢复 |\\n| 调试 | {@扩展API接口/扩展API接口详解/PluginRun PluginRun} | settings | 在托管者上执行一段代码 | 代码可以真实下单 |\\n| 频道 | {@扩展API接口/扩展API接口详解/pub pub} | robot, channel（URL参数），消息放在请求体 | 向实盘订阅的频道推送一条消息 | 不需要API KEY、不签名 |\\n\\nAPI KEY需要有对应方法的权限，见{@扩展API接口/创建ApiKey 创建ApiKey}。\\n\\n### 参数传法\\n\\n```args```有两种写法：\\n\\n- 数组：按上表的顺序传位置参数，例如```[123, \\\"ok\\\"]```。按位置传参时，服务端只接受特定的参数个数，个数不符时返回```Params number mismatch```错误：\\n - GetNodeList、GetPlatformList：0个或2个。\\n - GetStrategyList：0、6、7、8个；不传参数时```language```为```1```（只返回Python策略），见{@扩展API接口/扩展API接口详解/GetStrategyList GetStrategyList}。\\n - GetRobotList：0、1、3、5、6、7、8个；只传1个参数时，它被当作```appId```。\\n - GetRobotLogs：15～19个（15个时不查询状态栏）。\\n - RestartRobot、DeleteRobot：1个或2个；DeleteRobot只传```robotId```时```removeLog```为```false```。\\n- 对象：按参数名传值，例如```{\\\"robotId\\\": 123, \\\"cmd\\\": \\\"ok\\\"}```。参数名不区分大小写、忽略下划线，没有传的参数取默认值。可选参数多的方法（GetRobotList、GetRobotLogs、GetStrategyList）建议用这种写法。\\n\\n### 实盘配置（settings）\\n\\nNewRobot、RestartRobot、PluginRun的```settings```参数是一个JSON对象，常用字段如下：\\n\\n| 字段 | 说明 |\\n| - | - |\\n| name | 实盘名称。 |\\n| strategy | 策略Id，可用GetStrategyList查询。RestartRobot不能更换实盘的策略。 |\\n| args | 策略参数，每个元素为```[\\\"参数名\\\", 值]```，例如```[[\\\"Interval\\\", 500]]```；策略没有参数时为```[]```。 |\\n| exchanges | 交易所对象配置数组，每个元素对应一个交易所对象，写法见下文。 |\\n| period | 默认K线周期，单位为秒，例如```60```、```3600```；不写时为60秒。请传60及以上的秒数，见表后说明。 |\\n| node | 运行实盘的托管者Id，可用GetNodeList查询；不写或为```-1```时自动分配。 |\\n| group | 实盘分组Id，可用GetRobotGroupList查询。 |\\n| appid | 自定义标签，GetRobotList可以按标签筛选。 |\\n\\n```period```为```0```、```1```、```2```、```3```、```4```、```5```、```10```、```12```时按旧的周期编号解释（依次为1分钟、3分钟、5分钟、15分钟、30分钟、1小时、1天、1周），例如传```1```实际是180秒。\\n\\n```exchanges```的元素有两种写法，同一个数组中不能混用（以第一个元素的写法为准）：\\n\\n- 引用平台上已添加的交易所账户：```{\\\"pid\\\": 123, \\\"pair\\\": \\\"BTC_USDT\\\"}```。```pid```可用GetPlatformList查询（返回数据中的```id```）。\\n- 直接传入交易所配置：```{\\\"eid\\\": \\\"Binance\\\", \\\"label\\\": \\\"test\\\", \\\"pair\\\": \\\"BTC_USDT\\\", \\\"meta\\\": {\\\"AccessKey\\\": \\\"...\\\", \\\"SecretKey\\\": \\\"...\\\"}}```。```eid```为交易所Id；```meta```的字段名见GetExchangeList返回的```meta```；```label```是交易所对象的标签，策略中用```exchange.GetLabel()```获取。平台不保存```meta```中的密钥，而是直接转发给托管者，所以用这种写法创建的实盘，每次重启时都必须重新传入```settings```。\\n\\n通用协议交易所的写法：```{\\\"eid\\\": \\\"Exchange\\\", \\\"label\\\": \\\"test\\\", \\\"pair\\\": \\\"BTC_USDT\\\", \\\"meta\\\": {\\\"AccessKey\\\": \\\"...\\\", \\\"SecretKey\\\": \\\"...\\\", \\\"Front\\\": \\\"http://127.0.0.1:6666/test\\\"}}```，```Front```为通用协议服务的地址。\", \"title\": \"扩展API接口详解\"}, {\"_src_hash\": \"eb578f0a004f6c539c811443b83db2aabde73f07a85a1325047ec75efa5edb31\", \"desc\": \"扩展API接口的每个响应都是下面的JSON结构：```code```表示请求本身是否成功，方法的结果在```data```中。\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": null,\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n```code```是请求本身的状态码：\\n\\n| 描述 | 代码 |\\n| - | - |\\n| 执行成功 | 0 |\\n| 错误的API KEY：```AccessKey```不存在或已禁用；直接验证时```secret_key```不正确 | 1 |\\n| 错误的签名 | 2 |\\n| Nonce错误：```nonce```不大于上次请求的值，或与服务器时间相差超过1小时 | 3 |\\n| 方法不正确：方法不存在、不对外开放，或这把API KEY没有该方法的权限 | 4 |\\n| 参数不正确：```args```不是合法的JSON，或请求无法分发（例如```method```与```args```的个数不一致） | 5 |\\n| 方法执行出错（例如没有操作该实盘的权限、实盘正忙、超出可运行的实盘数量），见下文 | 6 |\\n| 请求来源IP不在这把API KEY的IP白名单内 | 7 |\\n\\n```code```为0时，方法的结果在```data.result```中。参数个数或类型与方法不符时，```code```仍为0，```data.result```为```null```，```data.error```为错误信息（成功时为```null```）。例如参数个数不对：\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": null,\\n \\\"error\\\": \\\"Params number mismatch for StopRobot: expected 1, got 0\\\"\\n }\\n}\\n```\\n\\n方法执行过程中出错时，返回```code```为6，错误信息在顶层```error```字段，```data```为```null```。例如操作不属于自己的实盘：\\n\\n```json\\n{\\n \\\"code\\\": 6,\\n \\\"error\\\": \\\"Access Denied\\\",\\n \\\"data\\\": null\\n}\\n```\", \"title\": \"扩展API接口返回码\"}, {\"_src_hash\": \"cc67faf57b126609bea0a4e63338d3a009ce31d65ad492e874ba41d06cbaeb2b\", \"desc\": \"```GetRobotList```、```GetRobotDetail```、```GetRobotLogs```返回数据中的```status```字段是实盘状态码，取值如下。\\n\\n| 状态 | 代码 |\\n| - | - |\\n| 准备中（排队、编译中） | 0 |\\n| 运行中 | 1 |\\n| 停止中 | 2 |\\n| 已退出 | 3 |\\n| 被停止 | 4 |\\n| 策略有错误 | 5 |\\n\\n### 启动失败的返回值\\n\\n负数代码不会出现在```status```字段中，只作为```NewRobot```、```RestartRobot```启动失败时的返回值：\\n\\n| 含义 | 代码 |\\n| - | - |\\n| 策略不可用：租用已过期、既不是自己的策略也没有租用、策略已删除，或指定的策略版本不存在 | -1 |\\n| 没有找到可用的托管者：指定的托管者不在线，或者没有在线的托管者 | -2 |\\n| 读取实盘或账户数据失败 | -3 |\\n| 启动时实盘状态被同时修改（仅```RestartRobot```），重新查询后再试 | -4 |\\n| 余额不足 | -5 |\\n| 租用策略的并发实盘数达到上限，且策略没有设置超额单价 | -6 |\\n\\n账号可运行的实盘数量超限、没有操作该实盘的权限等错误不以返回值表示，而是返回```code```为6的错误，见{@扩展API接口/扩展API接口返回码扩展API接口返回码}。\", \"title\": \"实盘状态码\"}], \"desc\": \"平台的HTTP接口（```https://www.fmz.com/api/v1```），供脚本、定时任务等程序调用平台功能：查询账号、托管者、策略和实盘，创建、重启、停止实盘，向实盘发送交互命令等。\\n\\n在AI助手（Claude Code、Cursor等）中交互式地操作平台时，优先使用{@扩展API接口/AI接入 AI接入}（MCP服务）：工具更全，参数按名称传递，权限可以按类别授予。两者可以使用同一把API KEY。\\n\\n使用步骤：{@扩展API接口/创建ApiKey 创建ApiKey}，按{@扩展API接口/验证方式验证方式}发送请求，方法与参数见{@扩展API接口/扩展API接口详解扩展API接口详解}。\", \"title\": \"扩展API接口\"}]","language","zh-CN","languageMode","system","sessionData",{"_375":25,"_376":25,"_377":242,"_378":242,"_379":25,"_170":25,"_380":25,"_381":25},"settings",{"_30":31,"_32":33},"zone","fmz","theme",{"_28":14,"_29":-7},"colorUpGreen","isWebApp",false,"cdnBase","","themeMode","resolvedThemeMode","appSettings",{"_150":151,"_152":153,"_154":155,"_156":157,"_158":159,"_160":161,"_162":163,"_164":165,"_166":167,"_168":169,"_170":171,"_172":173,"_174":175,"_176":177,"_178":179},"uiFooter",{"_34":35,"_36":37,"_38":39},"copyright",{"_40":149,"_42":149},"download",{"_145":146,"_147":148},"footer",{"_40":41,"_42":43},"zh_CN",[101,102,103],"en_US",[44,45,46],{"_47":84,"_49":85},{"_47":67,"_49":68},{"_47":48,"_49":50},"title","API","items",[51,52,53,54,55],{"_47":65,"_57":66},{"_47":63,"_57":64},{"_47":61,"_57":62},{"_47":59,"_57":60},{"_47":56,"_57":58},"Indicator","url","/api#indicator-functions","Blockchain","/api#blockchain","Trading api","/api#trading-api","User guide","/user-guide","Syntax guide","/syntax-guide","Product",[69,70,71,72,73],{"_47":82,"_57":83},{"_47":80,"_57":81},{"_47":78,"_57":79},{"_47":76,"_57":77},{"_47":74,"_57":75},"Tickets","/m/tickets","Platforms","/m/platforms","Node","/m/add-node","Strategy","/m/add-strategy","Robot","/m/add-robot","Forums",[86,87,88,89,90],{"_47":99,"_57":100},{"_47":97,"_57":98},{"_47":95,"_57":96},{"_47":93,"_57":94},{"_47":91,"_57":92},"About Us","/about-us","Web3","/bbs-topic/10032","MyLanguage","/bbs-topic/9480","FAQ Summary","/bbs-topic/9158","PINE Language","/bbs-topic/9637",{"_47":131,"_49":132},{"_47":119,"_49":120},{"_47":104,"_49":105},"API文档",[106,107,108,109,110],{"_47":118,"_57":66},{"_47":117,"_57":64},{"_47":115,"_57":116},{"_47":113,"_57":114},{"_47":111,"_57":112},"指标函数","/api#指标函数","区块链","/api#区块链","交易api","/api#交易api","用户指南","语法手册","产品功能",[121,122,123,124,125],{"_47":130,"_57":83},{"_47":129,"_57":81},{"_47":128,"_57":79},{"_47":127,"_57":77},{"_47":126,"_57":75},"工单","交易所","部署托管者","新建策略","创建实盘","社区",[133,134,135,136,137],{"_47":143,"_57":144},{"_47":117,"_57":64},{"_47":141,"_57":142},{"_47":139,"_57":140},{"_47":138,"_57":92},"关于我们","托管者安装和升级","/bbs-topic/2848","Python入门指南","/bbs-topic/4388","回测系统","/api#回测系统","android","/dist/fmz.apk","ios","itms-apps://itunes.apple.com/WebObjects/MZStore.woa/wa/viewSoftware?id=1572932684","© 2015 - ∞ INVENTOR PTE LTD (SG)","banner",[357,358,359,360,361],"nav",[324,325,326,327,328,329,330,331],"ad",[320],"ad1",[308,309,310],"embedx",[289,290],"payments",[244,245,246,247,248],"strategy",[222,223,224,225,226,227],"sso",[204,205,206],"update",{"_145":186,"_147":187,"_188":189},"redirect",{"_184":185},"openai",true,"ui",{"_180":171,"_181":171,"_182":183},"datadata_snapshot","https://www.datadata.com/web/resources/{{uuid}}/screenshot.png","chart","https://www.fmz.com/app/chart","timeout",15000,"show_prop_strategies","aiguide","datadata","https://www.datadata.com","/strategy/268542","/strategy/520271",{"_190":191,"_197":198,"_192":202,"_194":203,"_188":195,"_199":200,"_34":201},{"_192":196,"_190":191,"_197":198,"_194":148,"_199":200,"_34":201},"web",{"_190":191,"_192":193,"_194":195},"version","v2.2.36","paymethod","balance,voucher","link","https://www.fmz.com/mobile","","min_version","v2.0.1","name","FMZ","Copyright © FMZ.COM 版权所有","voucher","https://www.fmz.com/dist/fmz.apk",{"_207":218,"_209":219,"_47":220,"_212":221},{"_207":214,"_209":215,"_47":216,"_212":217},{"_207":208,"_209":210,"_47":211,"_212":213},"source","web3","logo","/upload/asset/ee79a670efe19d2365.svg","MetaMask","platform",[188],"apple","/upload/asset/4416f8d6618c84681e.png","Apple 登录|Apple",[188,147],"google","/upload/asset/102992e886fb7a2fc67.png","Google 登录|Google",[188,147,145],{"_228":242,"_199":243},{"_228":240,"_234":238,"_199":241},{"_228":237,"_234":238,"_199":239},{"_228":233,"_234":235,"_199":236},{"_228":231,"_199":232},{"_228":229,"_199":230},"id",21,"交易插件|Plugin",20,"模板类库|Template",9,"currency","USD","加密货币|Cryptocurrency",2,"CNY","股票证券|Stocks",1,"商品期货|Futures",0,"通用策略|Common",{"_228":237,"_199":287,"_263":249,"_251":264,"_234":235,"_254":288},{"_228":266,"_199":267,"_263":242,"_268":266,"_251":258,"_234":235,"_269":270,"_271":272,"_254":273},{"_228":261,"_199":262,"_263":249,"_251":264,"_234":235,"_254":265},{"_228":256,"_199":257,"_251":258,"_259":202,"_254":260},{"_228":249,"_199":250,"_251":252,"_234":253,"_254":255},3,"余额|Balance","scope","buy","USD,CNY","image","https://www.fmz.com/upload/asset/bc7ac3c0c5e1068a32.png",4,"充值码|Voucher","charge","type","https://www.fmz.com/upload/asset/28fa674166cb24de22b.png",6,"Stripe","amount","charge,buy","https://www.fmz.com/upload/asset/174be2a35fc37c113a6.png",5,"USDT","min","chain",[274,275,276],"description","您只可发送 USDT 至此地址，若发送其他数字货币，您将会失去这笔资金。||only send USDT to this address, you will lose your assets if you send any other crypto","https://www.fmz.com/upload/asset/bb9c83903a6cbfea0f.png",{"_277":284,"_199":285,"_271":286},{"_277":281,"_199":282,"_271":283},{"_277":278,"_199":279,"_271":280},"symbol","TRX","TRC20","Tron Network","ETH","ERC20","Ethereum Network","BNB","BSC","Binance Smart Chain","Paypal","https://www.fmz.com/upload/asset/297a3cb96cf4d1e7736.png",{"_291":305,"_293":306},{"_291":292,"_293":294},"path","/square_bak","banners",[295,296],{"_254":300,"_301":300,"_302":303,"_194":304},{"_297":298,"_194":299},"text","发明者量化平台全球KOL招募令||Financial Magic Zone Global KOL Recruitment","/bbs-topic/10382","/upload/asset/11c9e5536c5d4c1e46e.png","image_dark","height","100px","https://www.jinse.cn/blockchain/3690011.html","/digest",[307],{"_254":300,"_301":300,"_194":304},{"_254":317,"_301":318,"_194":319},{"_254":314,"_301":315,"_194":316},{"_254":311,"_301":312,"_194":313},"/upload/asset/15ce9c5df17eb9af463.png","/upload/asset/309f2b0743dd12d5659.png","/bbs-topic/8238","/upload/asset/2b85d8e0029712de49d.png","/upload/asset/27b5928f8282ebe1864.png","/bbs-topic/1427","/upload/asset/19bb3b1f48c49e196d8.png","/upload/asset/33b98e51d4670de9ce5.png","/bbs-topic/4158",{"_254":321,"_301":322,"_194":323},"/upload/asset/2c2c9521b3a6d0ee73b.png","/upload/asset/2c77ab5db219dc3e78f.png","/bbs-topic/4145",{"_199":354,"_254":355,"_194":356},{"_199":349,"_350":351,"_254":352,"_194":353},{"_199":347,"_254":348,"_194":305},{"_199":344,"_254":345,"_194":346},{"_199":341,"_254":342,"_194":343},{"_199":338,"_254":339,"_194":340},{"_199":335,"_254":336,"_194":337},{"_199":332,"_254":333,"_194":334},"消息中心|Message","/upload/asset/274a5fd7d23a979cd11.png","/messages","工单|Ticket","/upload/asset/11147e72e6c33dc8cba.png","/tickets","交易所|Platform","/upload/asset/318b4addb664da55ea6.png","/platforms","交易终端|Trade","/upload/asset/733e259ec86facf025.png","/trade","社区|Forum","/upload/asset/2e5a8b06b92e5f1357f.png","/bbs","文库|Digest","/upload/asset/1716e895993c78000f3.png","围观|Live","size",30,"/upload/asset/2f23fcaecaa612555f5.png","/live","策略广场|Square","/upload/asset/36bba6d48d47a6689f3.png","/square",{"_254":300,"_301":300,"_194":304},{"_254":372,"_301":373,"_194":374},{"_254":367,"_301":368,"_369":370,"_194":371},{"_254":365,"_301":366,"_194":185},{"_254":362,"_301":363,"_194":364},"/upload/asset/10f6f33ea3b03f80a90.png","/upload/asset/158be7477c0a9a4538a.png","/strategy/520273","/upload/asset/bca3a8d340c888e609.png","/upload/asset/8f0c8df04d8bd94a73.png","/upload/asset/a56df9bdccd3fbcb28.png","/upload/asset/d08dd59b5ac36ed333.png","delay",10000,"/strategy/520272","/upload/asset/de3b761a5c58f67993.png","/upload/asset/18e8a84aec3a5e77ff4.png","/strategy/520274","isAuthenticated","isShadow","balance","fee","isAdmin","hasTwofactor","hasPassword"]