[{"_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},"lang/routes/app/user-guide.$",{"_9":10},"userGuide","[{\"_src_hash\": \"464d4f64884e4ceb2b09e5b3a35de911ecad64c2846612d9d2998cfb04306625\", \"children\": [], \"desc\": \"发明者量化交易平台是量化交易领域最专业的量化社区。在这里，您可以学习、编写、分享、出售量化交易和程序化交易策略；进行在线回测和模拟盘交易；运行、公开、围观策略实盘。发明者量化交易平台（FMZ量化）支持几乎所有主流加密货币交易所。\\n在发明者量化交易平台学习和使用过程中遇到问题，可以随时到论坛发帖提问、讨论，在平台提交工单，或在[Telegram](https://t.me/fmzquant_cn)社群@管理员，问题通常会得到快速解答。平台支持ChatGPT辅助开发，发明者量化交易平台已接入**ChatGPT**作为辅助开发工具，您可以在「控制中心」的快捷方式栏内点击「ChatGPT」跳转至[ChatGPT辅助工具页面](https://www.fmz.com/m/chat)。\\n\\n在发明者量化交易平台，您可以通过注册和登录开始您的量化交易之旅。登录后，访问[主页面](https://www.fmz.com/m)，您将看到以下内容：\\n![控制中心概览](/upload/asset/2e4e636a6fe51c8f620e8.png)\\n\\n- 左侧导航栏：包含用户控制台的主要功能跳转选项。\\n- 顶端导航栏：提供平台公共资源的跳转选项。\\n- 页面中部：展示账户设置、调试工具、分析工具、开发文档、平台功能快捷跳转等内容。\\n\\n用户控制台主要功能：\\n- [控制中心](https://www.fmz.com/m/dashboard)\\n 跳转至『控制中心』页面。在发明者量化交易平台运行量化交易程序（即实盘）需要满足三个条件：1、部署一个可用的托管者。2、拥有一个可用的策略。3、配置交易所账户供策略程序操作。\\n- [实盘](https://www.fmz.com/m/robots)\\n 跳转至『实盘』页面。实盘即量化交易策略程序实例。实盘页面主要用于管理、创建和控制策略实盘。\\n- [策略库](https://www.fmz.com/m/strategies)\\n 跳转至『策略库』页面。策略库可以分类保存、管理和编写各种编程语言的策略。\\n- [托管者](https://www.fmz.com/m/nodes)\\n 跳转至『托管者』页面。托管者页面可以管理和部署当前账户关联的托管者程序。\\n- [交易所](https://www.fmz.com/m/platforms)\\n 跳转至『交易所』页面。交易所页面可以管理和配置需要进行量化交易的交易所账户。\\n\\n平台公共资源：\\n- [策略](https://www.fmz.com/square)\\n 在策略广场，您可以找到各种编程语言编写的公开或出租策略，适合学习和参考。\\n- [围观](https://www.fmz.com/live)\\n 实盘围观页面展示用户公开的策略实盘。\\n- [文库](https://www.fmz.com/digest)\\n 平台文库保存了平台原创文章等资料，方便您入门学习。\\n- [社区](https://www.fmz.com/bbs)\\n 社区论坛为您提供交流和讨论量化交易领域的平台。\\n- [众包](https://www.fmz.com/markets)\\n 众包版块为策略设计者和需求者搭建高效的沟通渠道。\\n- [公开课](https://www.fmz.com/class)\\n 公开课页面提供平台的视频教程。\\n- [API文档](https://www.fmz.com/api)\\n API文档页面为您编写和设计策略提供技术资料支持。\", \"title\": \"欢迎使用发明者量化交易平台\"}, {\"_src_hash\": \"7027a43defaa55e0e91e9ab23894e95ca612dc4d388bc7a1261a764ce71cee27\", \"children\": [{\"_src_hash\": \"e9f25bd4a17d94b739b4fc66a9806c8df50649321b054427263d0c31db74d98c\", \"desc\": \"支持JavaScript语言，集成了以下JavaScript库：\\n- http://mathjs.org/\\n- http://mikemcl.github.io/decimal.js/\\n- http://underscorejs.org/\\n- http://ta-lib.org/\\n\\n程序异常报错、接口业务报错\\n在```JavaScript```语言策略中，发生程序异常报错或接口业务报错时，错误日志将显示策略代码中发生错误的具体行号，便于策略调试与BUG排查。\\n\\n支持```JavaScript```异步编程特性：\\n- setTimeout / clearTimeout\\n ```js\\n function main() {\\n let symbol = \\\"ETH_USDT\\\"\\n let delay = 10\\n let depth = exchange.GetDepth(symbol)\\n let callback = function(e, id, msg) {\\n Log(msg + \\\", canceling order.\\\")\\n e.CancelOrder(id)\\n }\\n\\n let ordersLen = 3\\n let arrTimerId = []\\n for (let i = 1 ; i <= ordersLen ; i++) {\\n let orderId = exchange.CreateOrder(symbol, \\\"buy\\\", depth.Bids[i * 3].Price, i * 0.1)\\n let timerId = setTimeout(callback, delay * 1000, exchange, orderId, `Delayed ${delay} seconds`)\\n Log(\\\"i:\\\", i, \\\", timerId:\\\", timerId)\\n arrTimerId.push(timerId)\\n }\\n\\n // clearTimeout\\n let clearTimeoutIdx = 1\\n Log(\\\"clearTimeoutIdx:\\\", clearTimeoutIdx, `, arrTimerId[clearTimeoutIdx]:`, arrTimerId[clearTimeoutIdx])\\n clearTimeout(arrTimerId[clearTimeoutIdx])\\n\\n Sleep(60 * 1000)\\n }\\n ```\\n- fetch\\n ```fetch```函数是```HttpQuery```函数的异步版本重载。\\n\\n 使用```await```关键字以同步语法处理异步操作：\\n ```js\\n function main() {\\n let url = \\\"https://www.okx.com/api/v5/market/books?instId=BTC-USDT\\\"\\n const promiseBooks = new Promise(async function(resolve, reject) {\\n Log(\\\"Start execution\\\")\\n let data = await fetch(url)\\n Log(\\\"data.ok:\\\", data.ok, \\\", data.text():\\\", data.text())\\n if (data.ok) {\\n Log(\\\"Successfully retrieved data:\\\", data)\\n return resolve(data.text())\\n } else {\\n return reject(new Error(\\\"data 无效\\\"))\\n }\\n })\\n\\n promiseBooks.then(function(ret) {\\n Log(\\\"ret:\\\", ret)\\n }).catch(function(err) {\\n Log(\\\"err.name:\\\", err.name, \\\"err.stack:\\\", err.stack, \\\"err.message:\\\", err.message)\\n })\\n }\\n ```\\n- 使用```Promise.all```并发执行多个异步网络请求：\\n ```js\\n async function main() {\\n // let symbols = [\\\"BTC-USDT\\\", \\\"ETH-USDT\\\", \\\"LTC-USDT\\\"] // 等待请求耗时：99毫秒\\n let symbols = [\\\"BTC-USDT\\\", \\\"ETH-USDT\\\", \\\"LTC-USDT\\\", \\\"SOL-USDT\\\", \\\"BNB-USDT\\\", \\\"ADA-USDT\\\"] // 等待请求耗时：99毫秒\\n let arr = []\\n\\n let beginTs1 = new Date().getTime()\\n for (let symbol of symbols) {\\n let url = `https://www.okx.com/api/v5/market/books?instId=${symbol}`\\n arr.push(fetch(url).then(function(resp) {\\n if (resp.ok) {\\n return {\\\"symbol\\\": symbol, \\\"json\\\": resp.json()}\\n } else {\\n throw \\\"req failed\\\"\\n }\\n }))\\n }\\n let endTs1 = new Date().getTime()\\n\\n let beginTs2 = new Date().getTime()\\n const ret = await Promise.all(arr)\\n for (let data of ret) {\\n Log(data)\\n }\\n let endTs2 = new Date().getTime()\\n\\n Log(\\\"Request creation time:\\\", endTs1 - beginTs1, \\\"ms\\\")\\n Log(\\\"Request waiting time:\\\", endTs2 - beginTs2, \\\"ms\\\")\\n\\n LogStatus(_D(), ret)\\n }\\n ```\\n- 使用```Promise.race```获取多个异步请求中最先```resolved```或```rejected```的结果：\\n ```js\\n async function getTicker(e) {\\n return Promise.resolve().then(function() {\\n /* 测试\\n if (e.GetName() == \\\"Huobi\\\" || e.GetName() == \\\"Binance\\\") {\\n Sleep(1000)\\n }\\n */\\n let ret = e.GetTicker(\\\"BTC_USDT\\\")\\n return {\\\"name\\\": e.GetName(), \\\"ret\\\": ret}\\n })\\n }\\n\\n async function main() {\\n Log(\\\"begin\\\")\\n let arrPromise = []\\n for (let e of exchanges) {\\n arrPromise.push(getTicker(e))\\n }\\n\\n let ret = await Promise.race(arrPromise)\\n Log(ret)\\n }\\n ```\\n- 在```threading.Thread```中使用```setTimeout()```函数：\\n ```js\\n function test() {\\n Log(\\\"Test function started\\\") // step 3. Test function started\\n let timerId1 = setTimeout(function() {\\n Log(\\\"Timeout callback executed after 5 seconds\\\") // step 5. Timeout callback executed after 5 seconds\\n }, 5000)\\n Log(\\\"Test function completed\\\") // step 4. Test function completed\\n }\\n\\n function main() {\\n Log(\\\"Main function started\\\") // step 1. Main function started\\n let t1 = threading.Thread(test)\\n Log(\\\"Worker thread created successfully\\\") // step 2. Worker thread created successfully\\n t1.join()\\n Log(\\\"Main function completed\\\") // step 6. Main function completed\\n }\\n ```\\n- 多线程并发获取```ticker```数据的异步处理示例：\\n 由于```exchange.GetTicker()```是同步阻塞操作，即使包装在Promise中，内部执行仍是同步的；JavaScript是单线程的，同步操作会阻塞事件循环；微任务队列中的回调函数仍然是串行执行的。\\n ```js\\n async function getTicker(symbol) {\\n Log(\\\"getTicker symbol:\\\", symbol)\\n return Promise.resolve().then(function() {\\n // 注意与fetch请求数据时的区别\\n let ret = exchange.GetTicker(symbol)\\n Log(ret)\\n return ret\\n })\\n }\\n\\n async function main() {\\n let symbols = [\\\"BTC_USDT\\\", \\\"ETH_USDT\\\", \\\"SOL_USDT\\\"]\\n let t1 = threading.Thread(async function(symbols, func) {\\n let arrPromise = []\\n for (let symbol of symbols) {\\n arrPromise.push(func(symbol))\\n }\\n let ret = await Promise.all(arrPromise)\\n Log(\\\"ret:\\\", ret)\\n }, symbols, getTicker)\\n\\n t1.join()\\n }\\n ```\", \"title\": \"JavaScript\"}, {\"_src_hash\": \"9e284f00c53855df8d53bcb5660338e27cd28f90cfcef1b651220a85e03cc2e6\", \"desc\": \"支持TypeScript语言，在策略创建时仍设置为JavaScript策略，然后在策略代码开头写入```// @ts-check```或点击策略编辑区域右上角的「TypeScript」按钮，即可切换到TypeScript。平台将自动识别代码为TypeScript，并提供相应的编译和类型检查支持：\\n\\n- 类型安全：TypeScript的静态类型检查功能可帮助您在编写代码时发现潜在错误，提高代码质量。\\n\\n- 代码自动补全：TypeScript的类型系统使您在编写代码时能够更快地找到所需的属性和方法，提高开发效率。\\n\\n- 更清晰的代码结构：使用TypeScript，您可以更好地组织和维护代码，使其易于阅读和理解。\\n\\n- 强大的面向对象编程特性：TypeScript提供了接口、类、泛型等强大的面向对象编程特性，帮助您编写更加健壮、可重用的策略代码。\", \"title\": \"TypeScript\"}, {\"_src_hash\": \"14c2b71fabc6f15ddb755b36d44276993c2e4dfa252d58e6076ad4bb3b5a0ab4\", \"desc\": \"- 设置Python策略程序使用的Python解释器\\n 使用Python编写的策略，在回测或实盘时，如果托管者所在系统环境同时安装了Python2和Python3，可以在策略开始的第一行设置策略运行时启动的Python版本。例如：```#!python3```、```#!python2```，系统将自动查找对应的解释器。也可以指定绝对路径，例如：```#!/usr/bin/python3```。\\n- 基于Python的策略安全性\\n 在发明者量化交易平台上开发的策略，仅对发明者量化交易平台账户的持有者可见。此外，在发明者量化交易平台上可以实现策略代码的完全本地化，例如将策略封装成一个**Python库**，在策略代码中加载，从而实现策略代码本地化。\\n Python代码的安全性：\\n 由于Python是开源且易于反编译的语言，如果策略非自用而是出租，担心策略泄露可以让策略运行在自己部署的托管者上，并以子账号或全托管管理的形式出租。\\n\\n Python策略代码加密：\\n 默认情况下，Python策略代码作者自用时不加密，租给他人使用时加密。在Python策略开头编写如下代码，可以指定自用或租出Python策略运行时是否加密策略代码。支持策略代码加密的Python版本为：Python 2.7版本、Python 3.5版本、Python 3.6版本。\\n\\n - 策略作者自己运行、通过注册码给他人使用时，均加密策略代码：\\n 使用代码```#!python```指定Python解释器版本，之后使用逗号```,```间隔，输入加密指令```encrypt```。如果不指定Python版本，可以直接添加```#!encrypt```。\\n ```python\\n #!python,encrypt\\n ```\\n 或\\n ```python\\n #!encrypt\\n ```\\n - 策略作者自己运行、通过注册码给他人使用时均不加密策略代码：\\n ```python\\n #!python,not encrypted\\n ```\\n 或者\\n ```python\\n #!not encrypted\\n ```\\n\\n 判断Python策略代码加密是否生效，使用代码```os.getenv('__FMZ_ENV__')```，返回字符串```\\\"encrypt\\\"```表示已经生效。仅在实盘有效，回测不会加密Python策略代码。\\n ```python\\n #!encrypt\\n def main():\\n ret = os.getenv('__FMZ_ENV__')\\n # 打印变量ret为字符串encrypt或者ret == \\\"encrypt\\\"为真，即代表加密生效\\n Log(ret, ret == \\\"encrypt\\\")\\n ```\\n- Python自定义模块导入功能\\n FMZ平台支持在Python策略中导入自定义模块，实现代码的模块化开发和复用。\\n\\n 例如，我们需要设计一个模块：```mymath```，将```mymath.py```保存为一个单独的文件。\\n\\n ```python\\n # mymath.py - 保存为一个单独的文件\\n \\\"\\\"\\\"\\n 简单的数学工具模块\\n \\\"\\\"\\\"\\n\\n def add(a, b):\\n \\\"\\\"\\\"加法\\\"\\\"\\\"\\n return a + b\\n ```\\n\\n 部署模块文件，将```mymath.py```文件放置到托管者程序目录下的指定位置（storage目录中的文件夹名称是实盘Id，以实盘Id为```123456```为例）：\\n\\n > 托管者程序目录/logs/storage/123456/mymath.py\\n\\n 最后在FMZ平台上的Python策略中直接导入```mymath```模块。\\n\\n ```python\\n import mymath\\n\\n def main():\\n Log(\\\"mymath.add(1, 2):\\\", mymath.add(1, 2))\\n ```\\n\\n Id为```123456```的实盘（策略实例）所绑定的策略中即可调用```mymath```模块中的方法。\", \"title\": \"Python\"}, {\"_src_hash\": \"68b0766eacecba8003e9be81c9f22fbdbedae6b756edb4da10ceb64887aabe82\", \"desc\": \"平台支持C++编程语言，兼容```C++ 11```标准。C++策略需要预先编译后执行，在回测系统中，C++策略运行于专用的C++回测服务器；在实盘环境中，C++策略编译通过后基于托管者运行。\\n\\n借助C++编程语言和```C++ 11```标准，您可以在FMZ量化交易平台上开发高性能的交易策略。利用C++的现代特性，您能够构建灵活、可扩展的交易算法，实现自动化交易。\\n\\n\\n集成了以下C++库：\\n\\n- https://nlohmann.github.io/json/\", \"title\": \"C++\"}, {\"_src_hash\": \"6019397439ed79ee429eedabc904e390f0aa442a687203f0731cdf2cc8fceb69\", \"desc\": \"平台支持My语言（麦语言）编写和设计策略，兼容文华麦语言的大部分语法、指令和函数。My语言鼓励积木式编程，将复杂算法拆解为函数模块。通过简洁的语法、专用数据结构和强大的金融函数库，支持复杂金融逻辑的实现。以模块化方式构建应用，提升开发效率和代码可维护性。\\n\\nMy语言策略范例：基于平移布林通道的系统\\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\": \"6931b8cbc80f11adbf0191d2f28c086f3d0f1a291c58d3eaa15405c2e50eb0b0\", \"desc\": \"平台支持并兼容```Trading View```的PINE语言脚本。PINE语言是一种轻量级但功能强大的策略编程语言，用于创建可进行回测和实盘交易的技术指标与策略。活跃的社区已创作了超过10万个PINE脚本。\\n用户可以轻松获取并应用各种技术分析工具和交易策略；能够借助社区脚本快速实现交易想法，无需从零开始编写代码，从而大幅缩短开发周期；帮助新手和资深交易员学习并理解不同的技术指标、策略及编程概念。\\n\\nPINE语言策略示例：超级趋势策略\\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\": \"46db0d70148678dfe7504c341fccc0e2f3cd5bc55cd5e3b03eee330830bf13c9\", \"desc\": \"平台支持Blockly可视化编程方式。借助Blockly编辑器，用户可以通过拼接图形块（类似积木）来表达代码概念，如变量、逻辑表达式、循环等。这种方式使编程过程无需过多关注繁琐的语法细节，而是可以直接按照编程原则进行操作。通过图形块的排列组合，用户能够轻松理解编程逻辑，实现创意想法，非常适合培养策略设计兴趣，快速入门程序化和量化交易。\\n\\n - [可视化模块搭建交易策略--初识](https://www.fmz.com/digest-topic/4016)\\n\\n - [可视化模块搭建交易策略--进阶](https://www.fmz.com/digest-topic/4046)\\n\\n - [可视化模块搭建交易策略--深入](https://www.fmz.com/digest-topic/4086)\\n\\n - [可视化模块搭建交易策略--浅出](https://www.fmz.com/digest-topic/4107)\", \"title\": \"Blockly可视化\"}, {\"_src_hash\": \"08e2fc002246d345e7118bd51513cac1ee5c601eb6e33c3465a99364c7d31ab2\", \"desc\": \"平台支持 Workflow 工作流方式编写策略。工作流是一种可视化的策略设计方式，通过节点连接和配置来构建交易逻辑，无需编写代码即可实现策略。\\n\\n**工作流特点**：\\n- 可视化拖拽设计，所见即所得\\n- 预置丰富的功能节点（数据获取、指标计算、条件判断、交易执行等）\\n- 降低编程门槛，适合快速搭建和验证策略\\n- 支持回测功能，可视化查看节点执行状态\\n\\n**学习资源**：\\n- [工作流系列视频教程](https://www.fmz.com/class/workflow)\", \"title\": \"Workflow工作流\"}], \"desc\": \"**在发明者量化交易平台，可以使用哪些编程语言实现我的策略？**\\n\\n![支持的编程语言](/upload/asset/2e52c7501f57044f7f0ef.png)\\n\\n发明者量化交易平台支持```JavaScript```、```TypeScript```、```Python```、```C++```、[```PINE```](https://www.fmz.com/bbs-topic/9315)、[```My语言```](https://www.fmz.com/bbs-topic/2569)、```Blockly```可视化以及```Workflow```工作流等多种方式编写和设计策略。\", \"title\": \"编程语言\"}, {\"_src_hash\": \"c10ea66141676e41cf048a825c3ffb2ac7019bc5bf96453c262876ba794fa06d\", \"children\": [], \"desc\": \"在发明者量化交易平台上配置的账户信息、策略参数中的加密字符串等敏感数据均在浏览器端进行加密。这些存储在发明者量化交易平台上的信息均为加密信息（非明文数据）。只有用户的私有设备可以解密使用，从而极大地提高了敏感数据的安全性。如果在策略代码、参数设置、策略描述等信息中包含了其他敏感信息，请勿公开或出售该策略。\\n\\n- 平台支持将交易所账户相关信息、密钥等敏感信息本地化配置\\n 在平台配置交易所信息的页面，所有带掩码的加密文本框控件都支持以配置文件路径的方式载入托管者本地文件。下面以交易所的```RSA KEY```验证方式为例，详细说明如何将敏感信息配置在托管者程序所在设备的本地。\\n 1、创建RSA公钥、私钥。例如创建格式为PKCS#8的公钥、私钥，有很多工具可以创建，例如：openssl。\\n 2、在交易所创建```RSA KEY```，创建时上传第一步中创建的公钥。\\n 3、将第一步中创建的私钥以txt文件格式保存在托管者目录```../logs/storage/xxx```路径下，xxx为实盘Id；也可以保存在托管者程序所在目录中的其他路径。\\n 4、在FMZ量化平台上配置交易所时，在```Access Key```的编辑框中填写在交易所创建的```RSA KEY```。\\n 5、在FMZ量化平台上配置交易所时，在```Secret Key```的编辑框中填写第三步中在托管者目录放置的txt文件的路径，例如放置的文件名为：```rsaKey.txt```，则填写：```file:///rsaKey.txt```。在运行实盘并引用该交易所（对象）时，托管者会自动载入目录```../logs/storage/xxx/rsaKey.txt```的文件内容作为交易所对象的配置信息，例如本例中的```RSA```私钥。\\n\\n 这样私钥本地化保存更加安全，详细过程可以参考[视频讲解](https://www.bilibili.com/video/BV1UM41147Jj/)\\n- 修改发明者量化交易平台的账号密码会导致交易所配置失效\\n 如果修改了发明者量化交易平台的账号密码，会导致所有交易所配置失效，需要按照以下步骤处理：\\n 1、重新在[「交易所」管理页面](https://www.fmz.com/m/platforms)配置交易所账户相关密钥、密码等信息。\\n 2、停止所有托管者，使用修改后的发明者量化交易平台账户密码重新部署、运行托管者。\", \"title\": \"密钥安全性\"}, {\"_src_hash\": \"353f2646091a956ebfff1735afa311cf61d2888c2da0a37681c920c0aa86c9cd\", \"children\": [], \"desc\": \"在发明者量化交易平台上，「实盘」的概念区别于「回测」，指的是创建一个真正与交易所交互（获取行情、查询持仓、下单撤单等）的策略程序实例。与交易所生产环境交互的策略程序实例称为实盘，与交易所模拟环境（许多交易所提供测试环境）交互的策略程序实例也称为实盘。\\n在发明者量化交易平台上[创建一个实盘](https://www.fmz.com/m/add-robot)需要满足三个条件：\\n\\n**创建实盘的条件**\\n- 一个可用的策略\\n 可以在平台[策略库页面](https://www.fmz.com/m/strategies)点击「新建策略」按钮创建策略。编写并设计策略后保存，策略将保存在策略库中。创建实盘时，在[实盘创建页面](https://www.fmz.com/m/add-robot)的「实盘配置」栏目下「运行策略」下拉框中即可选择策略库中的策略。\\n- 至少部署一个可用的托管者\\n 可以在平台[托管者页面](https://www.fmz.com/m/nodes)点击「部署托管者」按钮进行托管者部署。托管者部署成功后，创建实盘时在[实盘创建页面](https://www.fmz.com/m/add-robot)的「实盘配置」栏目下「托管主机」下拉框中即可选择已部署的托管者。\\n- 至少配置一个可用的交易所\\n 可以在平台[交易所页面](https://www.fmz.com/m/platforms)点击「添加交易所」按钮添加交易所，配置交易所账号信息。交易所配置完成后，创建实盘时在[实盘创建页面](https://www.fmz.com/m/add-robot)的「交易配置」栏目下「交易平台」下拉框中即可选择已配置的交易所。\\n\\n最后在实盘创建页面点击「创建实盘」按钮即可创建并运行一个量化交易策略程序实例（即发明者量化交易平台的实盘）。\\n\\n**实盘分组**\\n可以对已创建的实盘进行分组管理，支持自定义分组名称。\\n\\n**实盘围观**\\n实盘可以公开展示，也可以创建私有围观链接发送给特定群体展示。\\n\\n**实盘计费**\\n实盘按小时计费，每个实盘每小时 0.05 USD，不足一小时按一小时计费。创建新实盘将立即开始计费，实盘「停止」/「重启」不会重复计费。\\n\\n可以在[充值页面](https://www.fmz.com/m/billing)查询所有计费的「账单明细」。\\n\\n重要提示：使用```USDT```充值时务必注意：\\n- 1、转账网络是否正确（例如目前支持：TRC20、ERC20、BSC）。\\n- 2、充值资产选择是否正确（例如：USDT）。\\n- 3、充值地址是否一致。\\n\\n**实盘监控**\\n在[实盘管理页面](https://www.fmz.com/m/robots)的实盘列表中，处于运行中的实盘右侧**操作栏**中可以点击「监控」按钮开启实盘监控。开启监控后，如果实盘非手动操作退出，当前发明者量化交易平台绑定的邮箱将收到通知消息。\\n\\n**实盘数据库**\\n以实盘Id```123456```为例，其对应的数据库文件位于该实盘所属托管者目录下的路径：```/logs/storage/123456/123456.db3```，其中数据库文件名为```123456.db3```。\\n数据库中包含以下表：\\n- chart：记录图表数据。\\n- kvdb：记录```_G()```函数持久化保存的数据。\\n- log：记录实盘日志数据。\\n- profit：记录实盘收益数据。\", \"title\": \"实盘\"}, {\"_src_hash\": \"b105669d089835fa396b1bcbca2e45ad8670db60fc6bcb44924b982b9d7b93ac\", \"children\": [], \"desc\": \"[策略库](https://www.fmz.com/m/strategies)页面保存当前账号下的所有策略，策略可以使用多种编程语言和方式进行设计。\\n\\n**策略分组**\\n策略支持分组管理功能，可以自定义分组名称。\\n\\n**策略公开、出租**\\n可以生成策略的「复制码」用于公开策略。\\n可以生成策略的「注册码」用于出租策略。\\n\\n**策略导出、导入**\\n在策略库页面中，点击策略名称即可跳转至该策略的编辑页面，编辑页面提供「导入」、「导出」功能。\\n\\n一个完整的策略包含：\\n- 策略源码\\n- 策略描述\\n- 策略笔记\\n- 策略说明书\\n- 策略参数配置\\n- 策略交互配置\\n\\n因此在导出策略时，导出的文件为XML格式，包含上述所有信息。新建空白策略后，导入该XML文件即可完整还原策略。策略迁移不能仅复制源码，必须导入完整的策略文件（或手动添加策略参数设计、交互设计等配置）。\", \"title\": \"策略库\"}, {\"_src_hash\": \"47dbc57429c8fa15c1e1158e0ddc508dc8793220f882c9027eac115b33a52356\", \"children\": [{\"_src_hash\": \"394c192a562087085908c742d4182e4043918d17588a2a987183efc03dc5f879\", \"children\": [{\"_src_hash\": \"6e5941289f81b4a4cbfe703ed43ba507ca2630de6b3763f0551d3b03f98bfa14\", \"desc\": \"在[托管者部署页面](https://www.fmz.com/m/add-node)点击**一键租用托管者**标签，根据配置、服务器机房地区等需求选择需要部署的服务器。\\n\\n点击「立即购买」并输入当前发明者量化交易平台的账号密码进行验证，验证通过后将自动进行托管者程序部署。整个部署过程需要几分钟时间，系统会自动安装常用的Python库。\\n\\n点击「立即购买」后租用的服务器由于是通过平台代为租用，仅具有有限的系统权限，不支持远程登录。如果需要使用未预装的第三方Python库，建议使用私有服务器进行手动部署。\\n\\n通过**一键租用托管者**功能租用的服务器采用独立计费方式，与实盘计费相互独立。\\n\\n点击「重新部署」按钮不会删除托管者目录下logs目录中的实盘日志和数据文件。\", \"title\": \"一键租用托管者\"}, {\"_src_hash\": \"8b3aa6e79491fca41cc37b4c4c01c4e7bcc23e407d867da50b1443b2b28f6470\", \"desc\": \"您可以将托管者部署到各种设备上，例如：个人电脑、服务器、树莓派等，支持多种主流操作系统。\\n- Linux 命令行版本：Linux AMD64 / Linux 386 / Linux ARM64 / Linux ARMv7\\n- Mac 命令行版本：Mac Intel64 / Apple Silicon\\n- Windows 命令行版本、界面版本：64位 / 32位\\n- Docker 镜像\\n\\n登录需要部署托管者程序的设备后，根据设备的操作系统下载对应的托管者程序。下载链接可以在[托管者部署页面](https://www.fmz.com/m/add-node)点击**手动部署托管者**标签后显示的内容中找到。\\n部署托管者程序需要设置2个参数：\\n![手动部署托管者页面](/upload/asset/2e460507bc21582ba1448.png)\\n\\n1、包含发明者量化交易平台UID的通信地址。\\n2、UID对应的发明者量化交易平台账号的密码。\\n\\n**部署托管者时配置「通信地址」和「发明者量化交易平台账号密码」：**\\n- Windows界面版托管者\\n Windows界面版托管者可以直接将这两个参数填写到托管者界面上对应的输入框控件中。\\n\\n- 命令行版托管者\\n 对于其他命令行版托管者程序，不同的操作系统有不同的指令。以Linux & Mac为例，使用命令：```./robot -s node.fmz.com/123456 -p 654321```，以下说明命令中的各个部分：\\n\\n ```./robot```表示运行robot这个可执行程序（即托管者程序），其中```123456```为UID，```654321```为UID对应的发明者量化交易平台账户的密码。\\n ```-s```参数表示「发明者量化交易平台UID的通信地址」，参数值可以填写例如：```node.fmz.com/123456```。\\n ```-p```参数表示「UID对应的发明者量化交易平台账号的密码」，参数值可以填写例如：```654321```。\\n\\n 请注意这里的参数仅为示例，实际参数可以登录FMZ.COM后，在[托管者部署页面](https://www.fmz.com/m/add-node)点击**手动部署托管者**标签后查看。```-p```参数并非必须明文写在部署托管者的命令中，可以使用```./robot -s node.fmz.com/123456```命令运行，然后会提示输入密码，再手动输入密码即可。另外请注意执行程序的权限等问题，需要给予托管者程序足够的权限，解除运行限制。\", \"title\": \"手动部署托管者\"}, {\"_src_hash\": \"0535aee0048283af0923d80fae4db4df713ebe6e4415446ace54205e5f31ec64\", \"desc\": \"重要操作提示\\n- 错误操作：\\n 请勿直接在服务器等设备上强制终止托管者进程（如直接杀死进程或重启服务器）。此类操作可能导致托管者与FMZ平台断开连接，引发以下问题：\\n - 实盘无法正常停止\\n - 实盘持续运行并产生费用\\n 出现此类情况时，需要先删除已离线的托管者，才能停止实盘。\\n\\n- 正确操作流程：\\n - 确认托管者上没有任何运行中的实盘\\n - 再执行删除托管者或停止托管者进程的操作\\n 操作原则：先停止实盘，再停止托管者。\", \"title\": \"托管者操作注意事项\"}], \"desc\": \"在[托管者管理页面](https://www.fmz.com/m/nodes)可以查看当前发明者量化交易平台账号部署关联的托管者，支持列表视图和详细信息视图切换。该页面显示托管者的IP地址、版本号、编译发布时间等相关信息。点击**部署托管者**按钮可跳转至[托管者部署页面](https://www.fmz.com/m/add-node)。托管者部署提供两种模式：1、一键租用托管者；2、手动部署托管者。\\n\\n ![托管者部署页面](/upload/asset/2e527e497b3fa27ba497b.png)\", \"title\": \"部署托管者\"}, {\"_src_hash\": \"451f61add1534c3baef0a200f7b47b1b3170d6ca3cdbd64a4e98f6fd8eaeb931\", \"desc\": \"- ```Windows```系统的界面版托管者可以直接在托管者软件界面上设置IP地址，托管者软件默认为自动设置IP。\\n- 命令行环境运行的托管者使用```-I```参数指定IP地址。\\n ```log\\n -I string\\n custom local ip address\\n -c string\\n config file\\n -d string\\n custom dns resolve server\\n -e string\\n docker node executable path\\n -f string\\n docker settings json\\n -i string\\n docker image name\\n -n string\\n node name\\n -p string\\n password\\n -s string\\n server address\\n -u string\\n run as system user\\n -v version info\\n -vv\\n show verbose log\\n -w string\\n working directory\\n ```\", \"title\": \"全局指定IP地址\"}, {\"_src_hash\": \"028f82c1b576bb140387b020e7a1c9b6d257dda7fbcc3998f760227aa7c42194\", \"desc\": \"下载托管者软件后，解压缩得到的可执行文件```robot```即为托管者程序，在部署托管者时可以为托管者程序指定参数。\\n- ```-v```：\\n 查看当前托管者程序的版本、编译时间等信息。\\n 完整的执行命令以```苹果电脑Mac系统```为例：```./robot -v```。\\n- ```-vv```：\\n 托管者程序的运行详细日志和交互消息，默认不显示且不写入托管者日志文件。\\n 这样可以防止频繁的交互指令导致日志记录膨胀并占用硬盘空间。如果您需要记录托管者的详细日志并在托管者运行时显示出来，可以通过使用```-vv```参数来设置详细日志和交互消息写入托管者日志文件。\\n- ```-s```：\\n 运行托管者程序时指定与发明者量化交易平台通信的地址。\\n 完整的执行命令以```苹果电脑Mac系统```为例：```./robot -s node.fmz.com/xxxxxxx```，```xxxxxxx```部分为每个发明者量化交易平台账号的唯一识别ID，命令执行后会提示要求输入对应的发明者量化交易平台账号密码。\\n- ```-p```：\\n 可以直接在运行命令中通过参数指定密码，不建议这样做，因为会在当前系统记录中留下密码参数。假设地址```node.fmz.com/xxxxxxx```对应的账号密码为：```abc123456```。\\n 完整的执行命令以```苹果电脑Mac系统```为例：```./robot -s node.fmz.com/xxxxxxx -p abc123456```。\\n- ```-n```：\\n 为运行的托管者程序添加标签信息。\\n 完整的执行命令以```苹果电脑Mac系统```为例：```./robot -n macTest -s node.fmz.com/xxxxxxx```。在平台托管者管理页面的托管者信息中会显示```macTest```文本标记。\\n- ```-l```：\\n 打印当前托管者支持的交易所列表。\\n 完整的执行命令以```苹果电脑Mac系统```为例：```./robot -l```。即可输出所支持的交易所名称。\", \"title\": \"命令行版本托管者程序的参数\"}, {\"_src_hash\": \"b7ec6497f76db0e434f0785e1be8c3e343818f35eb1535b8abb933c5c2cee9d3\", \"desc\": \"当需要将实盘数据迁移到其他设备（服务器）上的托管者时，可以将实盘的数据库文件（扩展名为db3的数据库文件）移动到目标设备（服务器）上托管者目录中的对应路径位置。\\n\\n将文件名设置为平台上对应的实盘ID，这样之前实盘的所有日志信息就不会因为迁移到新设备而丢失。\", \"title\": \"实盘数据迁移\"}, {\"_src_hash\": \"470f9bbb1dc701d7c192348dae8cc8eb03a9749b0f07c2dd6ff537b33bb95dce\", \"desc\": \"在[托管者管理页面](https://www.fmz.com/m/nodes)的**托管者列表操作项**或**托管者详情操作项**中，可以开启**托管者监控**功能。开启监控后，若托管者异常离线，当前发明者量化交易平台绑定的邮箱将收到通知消息。\", \"title\": \"托管者监控\"}], \"desc\": \"发明者量化交易平台的托管者软件是整个量化交易系统的核心组件。[托管者](https://www.fmz.com/m/add-node)可以理解为您交易策略的执行者，负责复杂的数据请求、数据接收、网络连接、日志回传等工作。实盘策略程序运行在托管者软件上，而非运行在发明者量化交易平台网站上。托管者运行在您的服务器上，即使**发明者量化交易平台**网站出现网络故障，也不会影响您的托管者运行。托管者可运行在```Linux```、```Windows```、```Mac OS```、```Android```、```树莓派 ARM Linux```等系统上。\\n\\n托管者管理的实盘日志均保存在托管者程序所在目录```./logs/storage```内，文件为扩展名```db3```的```Sqlite```数据库文件。可以使用```Sqlite```管理软件直接编辑。对于这些扩展名为```db3```的实盘数据库文件，文件名即为实盘的```Id```。\\n\\n托管者程序支持自动识别和使用系统代理设置。当系统中运行了代理软件（例如```Clash X```、```V2Ray```、```Shadowsocks```等）并开启增强模式或系统代理模式时，托管者会自动检测并使用该代理进行网络访问，无需手动配置。这对于需要通过代理访问交易所API的用户来说非常便捷，托管者启动后即可自动适配系统的网络环境。\", \"title\": \"托管者\"}, {\"_src_hash\": \"4e524ca1ccd505c6d9068bca4cc553034e3142ba96e83aa93b9fd1d5d4a09aff\", \"children\": [], \"desc\": \"[交易所](https://www.fmz.com/m/platforms)页面用于管理和展示当前配置的交易所。在发明者量化交易平台中，「交易所」是一个核心概念，它指的是包含可供策略程序操作的资金账户相关密钥配置、通信协议和接口封装的对象。\\n\\n在交易所管理页面，点击「添加交易所」按钮即可跳转至[交易所添加页面](https://www.fmz.com/m/add-platform)，根据需求选择并填写配置信息。所有配置信息在本地加密后存储于发明者量化交易平台，因此平台不会记录任何明文数据。\\n\\n**交易所对象**\\n已配置的交易所在策略代码层面对应```exchange```对象（交易所对象）。详情请参阅「语法手册」中的[```exchange```](https://www.fmz.com/syntax-guide#var_exchange)。\\n在配置回测或实盘时，可以添加多个交易所。因此在策略代码层面存在```exchanges```对象数组（交易所对象数组）。详情请参阅「语法手册」中的[```exchanges```](https://www.fmz.com/syntax-guide#var_exchanges)。\\n\\n**使用交易所对象**\\n在策略代码中可以调用交易所对象执行账户查询、行情获取、下单、撤单等操作。以```JavaScript```语言为例：\\n\\n```js\\nfunction main() {\\n let account = exchange.GetAccount() // 查询账户信息\\n let ticker = exchange.GetTicker() // 获取ticker行情\\n let id = exchange.Buy(1000, 1) // 价格为1000，下单量为1\\n exchange.CancelOrder(id) // 如果订单没成交，则可以撤单\\n}\\n```\", \"title\": \"交易所\"}, {\"_src_hash\": \"ab97a87d3f0d3b1c2c93c7b5c94fa90dfecc5d5698c2aab4936ccb16a058f1a0\", \"children\": [{\"_src_hash\": \"78398bd8e8721556cfaaf1fccf067e35dd86771d19cd1a23377a56d182516fb2\", \"desc\": \"FMZ量化交易平台集成了先进的AI大模型助手功能，为用户提供智能化的策略开发和交易辅助服务。通过与业界领先的大语言模型深度集成，平台能够帮助用户快速解决编程问题、优化交易策略、分析市场数据，并提供专业的量化交易指导。\\n\\nFMZ平台目前支持以下AI大模型：\\nClaude Sonnet 4 - Anthropic最新发布的高性能模型，具备卓越的代码理解和生成能力。\\n\\n- 如何调用AI助手\\n\\n ![策略编辑器菜单中的AI助手](/upload/asset/16b08991d9857b82a46b.png)\\n\\n 在空白处点击右键，在弹出的菜单中选择「AI助手」选项，即可调用AI助手，或者使用快捷键```⌘K```调用AI助手。\\n- 使用AI助手解释代码\\n\\n ![策略编辑器中的AI助手解释代码](/upload/asset/16aa01684eda4e8163ed.png)\\n\\n AI助手不仅能够帮助您编写代码，还能为您解释代码逻辑。选中需要解释的代码片段后点击右键，在弹出的菜单中选择「解释这段代码」，即可查看AI助手提供的详细代码解释。\\n- 优化和改进代码\\n 选中需要优化的代码片段后点击右键，在弹出的菜单中选择「提出优化建议」或「重新优化代码」，AI助手将为您提供优化建议或直接生成优化后的代码。\", \"title\": \"AI助手\"}, {\"_src_hash\": \"581e9d89c242b20fd07c1651d675dcd2b8ec0502124f7ac63d03954bd8bb1a6a\", \"desc\": \"在策略代码编辑区域点击鼠标右键，选择弹出菜单中的「命令面板」选项，可查看各种功能的快捷键组合和编辑器命令。\\n\\n![策略编辑器中菜单的命令面板显示](/upload/asset/2e429269f02185dfbab3b.png)\", \"title\": \"命令面板\"}, {\"_src_hash\": \"3fa3321e7caf9a6dd14edad9e60003fcf5155eec3bcc4baf98136ad4bb0d6de6\", \"desc\": \"在**策略编辑页面**的「代码」编辑区内，可以快速查询「语法手册」。根据操作系统不同，使用相应的快捷键：\\n\\n![策略编辑器中语法手册速查](/upload/asset/2e4d0722af99164f69996.png)\\n\\n- Mac系统（苹果电脑）的浏览器中：按住```⌘```键不放。\\n- Windows系统的浏览器中：按住```Ctrl```键不放。\\n\\n然后将鼠标移动到需要查询的**变量名**或**函数名**上时，会出现跳转链接。点击该链接即可弹出「语法手册」，并自动定位到查询的内容。\", \"title\": \"语法手册速查\"}, {\"_src_hash\": \"86c516447509e520d1f7aa3d0b7f5db2681dce6458a64ae1648e1dc0bbb07ca4\", \"desc\": \"选中需要查询的内容，点击鼠标右键弹出菜单。\\n- 转到定义：跳转至所查询内容的定义位置。\\n- 转到引用：跳转至所查询内容的引用位置。\\n- 快速查看-速览定义：在不离开当前代码行的情况下查看所选代码的定义。\\n- 快速查看-查看引用：在不离开当前代码行的情况下查看其他代码行中对当前代码的引用情况，支持快速跳转，便于更好地理解代码逻辑和结构。\", \"title\": \"定义与引用跳转\"}, {\"_src_hash\": \"25b0f70b063e25a4ca46ec381167b9b1573906ce7357449cedf57f31c65a6766\", \"desc\": \"线上策略编辑页面提供了完善的文档记录功能，可将策略代码、策略描述、使用说明、开发日志等信息分类管理。\\n\\n![策略文档选项说明](/upload/asset/2e47983c191c1779bd52e.png)\\n\\n- 代码：策略程序的源代码。\\n 发明者量化交易平台上的完整策略包含：策略源码、[策略参数设计](https://www.fmz.com/user-guide#策略参数)、[策略交互设计](https://www.fmz.com/user-guide#交互控件)、[策略模板引用](https://www.fmz.com/user-guide#模板类库)。\\n- 笔记：用于记录策略开发过程中的相关内容。\\n- 描述：用于记录策略公开展示时的介绍信息。\\n- 手册：用于记录仅在策略租用后才可查看的详细信息。\", \"title\": \"策略文档\"}, {\"_src_hash\": \"53cc258140f6218e48231c2d765d650e672f6abfb4a234476944f5dce02c7117\", \"desc\": \"平台支持策略开发过程中的版本迭代功能，在**策略编辑页面**「代码」编辑区内，点击「历史版本」按钮可以打开策略历史版本管理页面。\\n\\n- 当前策略没有任何历史版本快照时，点击「立即创建」按钮创建当前策略的快照。快照内容包括：策略代码、笔记、描述、手册、参数设计、交互设计等。\\n\\n- 创建历史快照后，历史版本管理页面右侧会显示已保存的历史快照列表。点击该列表上方的「创建历史版本」按钮可以继续保存新的历史快照。\\n\\n- 编辑、使用历史快照：可以对已记录的策略历史快照进行**修改历史快照名称**、**删除历史快照**、**恢复到历史快照的策略版本**等操作。\\n\\n- 预览当前选定的历史快照：点击历史版本管理页面左下角的「预览」按钮，可以预览当前历史快照中的策略代码、笔记、描述、手册、参数设计、交互设计等内容。\\n\\n- 对比当前选定的历史快照与当前策略的差异：点击历史版本管理页面左下角的「对比」按钮，可以对比当前历史快照与当前策略之间的差异。\\n\\n\\n## 实盘运行历史版本\\n\\n策略的历史版本不仅可以用于代码管理和版本回滚，还可以直接在实盘中运行：\\n\\n- **设置默认运行版本**：在策略编辑器页面点击「历史版本」按钮，选中某个历史版本后，点击菜单中的「修改」按钮，在弹框中可以勾选「设置为默认版本」选项。如果不设置，默认运行最新版本。\\n\\n- **在实盘中使用历史版本**：创建实盘或修改实盘参数时，策略所有者可以选择策略的某个历史版本来运行。此功能仅对策略所有者有效。\\n\\n- **出租策略的版本控制**：当策略出租给其他用户时，租用方只能运行策略所有者设置的「默认运行版本」，无法选择其他历史版本。策略所有者可以通过设置默认运行版本来控制出租策略使用的版本。\", \"title\": \"历史版本管理\"}, {\"_src_hash\": \"5edd5570c179ca37446e74966baf71d3fd5f7d94cb3c80767071186ccc004f58\", \"desc\": \"- [远程编辑](https://www.fmz.com/user-guide#远程编辑)\\n ![远程编辑截图](/upload/asset/2e4e8975d1e32517fd989.png)\\n- [保存回测设置](https://www.fmz.com/user-guide#保存回测设置)\\n ![保存回测设置截图](/upload/asset/2e51f69b120f9b6aadaee.png)\\n- [策略导入、导出](https://www.fmz.com/user-guide#完整策略的导入与导出)\\n ![策略导入导出截图](/upload/asset/2e52ccf44526f396fb795.png)\", \"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发明者量化交易平台的在线策略编辑器提供了强大的策略编辑辅助功能。\\n\\n![线上策略编辑器界面](/upload/asset/2e50fff4160187be92248.png)\", \"title\": \"策略编辑器\"}, {\"_src_hash\": \"a5588d0c6c0febe917e88ed32a9966c5d56a0f4ac99ce33fe07c84eb2df5bdf1\", \"children\": [{\"_src_hash\": \"fd5c917dc7ac8dd10c3444eaff44079eb643f33d63f92dddef98e56b36096581\", \"desc\": \"发明者量化交易平台将回测模式分为**实盘级 Tick**回测和**模拟级 Tick**回测。**实盘级 Tick**回测完全基于完整的历史数据进行回测；**模拟级 Tick**回测则根据真实K线数据生成**tick数据**来进行回测。两者都基于真实历史数据进行回测，但**实盘级 Tick**回测的数据更精准，结果更加可信。需要注意的是，回测仅反映策略在历史数据下的表现，历史数据并不能完全代表未来的行情，因此对待回测结果应保持理性、客观的态度。\\n\\n**模拟级 Tick**回测根据底层K线周期生成模拟的**tick数据**，每个底层K线周期上最多生成12个回测时间点。而**实盘级 Tick**回测使用真实收集的逐秒tick数据，数据量大，回测速度较慢，因此不适合回测特别长的时间范围。FMZ量化的回测机制允许策略在一根K线上进行多次交易，避免了仅能在收盘价成交的局限性，在保证精准度的同时兼顾了回测速度。\\n\\n[回测系统机制说明](https://www.fmz.com/digest-topic/4009)\\n\\n- 模拟级 Tick\\n **模拟级 Tick**回测根据回测系统的底层K线数据，按照特定算法在给定的底层K线Bar的最高价、最低价、开盘价、收盘价构成的价格框架内模拟生成tick数据进行回测，作为回测时间序列上的实时tick数据，在策略程序调用接口时返回。具体可参考：[回测系统模拟级别机制说明](https://www.fmz.com/bbs-topic/662)。\\n\\n- 实盘级 Tick\\n 实盘级别回测使用Bar时间序列中的真实tick级别数据。对于基于tick级别数据的策略，使用实盘级别回测更贴近实际情况。实盘级别回测的tick是真实记录的数据，并非模拟生成。支持深度数据、市场成交记录数据回放，支持自定义深度，支持分笔数据。实盘级别回测数据最大支持50MB，在数据上限内不限制回测时间范围。如需尽可能增大回测时间范围，可降低深度档位数值设置，不使用分笔数据以扩展回测时间范围。调用```GetDepth```、```GetTrades```函数获取回放行情数据。在时间轴上某个行情数据时刻，调用```GetTicker```、```GetTrades```、```GetDepth```、```GetRecords```，不会多次推动时间在回测时间轴上移动（不会触发跳转到下一个行情数据时刻）。对于以上某个函数的重复调用，将推动回测时间在回测时间轴上移动（跳转到下一个行情数据时刻）。回测时使用实盘级别回测不宜选择过早的时间，因为过早的时间段可能没有实盘级别数据。\\n\\n**实盘级Tick**和**模拟级Tick**模式的回测系统成交撮合机制：订单成交撮合按照见价成交、全量成交进行。因此回测系统中无法测试部分成交的场景。\", \"title\": \"回测系统模式\"}, {\"_src_hash\": \"78a3a709d3884b164e81c42cb28d3845505ad85982ded63fea9713a0ef662586\", \"desc\": \"以下测试代码针对不同的数据粒度（A. 实盘级别回测、B. 模拟级别回测（较小底层K线周期）、C. 模拟级别回测（较大底层K线周期）等）会呈现不同的表现。交易次数和盈亏结果均会有所差异。进行回测时应尽可能保持较小的数据粒度。虽然数据粒度较大时回测速度可能更快，但所得结果可能缺乏客观性。\\n\\n```js\\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\": \"9bf2884b1ca849ce6643cc8f39369c02eacc7fcc55176e5f05180cd3b77fffd3\", \"desc\": \"回测系统支持：```JavaScript```、```TypeScript```、```Python```、```C++```、[```PINE```](https://www.fmz.com/bbs-topic/9315)、[```My语言```](https://www.fmz.com/bbs-topic/2569)、```Blockly```可视化、```Workflow```工作流编写设计的策略进行回测测试。\\n\\n1、**JavaScript** 和 **C++** 策略回测在浏览器端进行，**JavaScript** 和 **C++** 语言的策略在实盘、回测运行时无需安装任何其他软件、库或模块。\\n\\n2、**Python** 语言的策略回测在托管者上进行，可以在FMZ量化的公共服务器上回测，也可以在用户自己的托管者上回测。实盘和回测都依赖托管者所在系统上安装的Python环境，如需使用特定库，需自行安装。FMZ量化的公共服务器仅支持常用的 **Python** 库。\\n\\n3、支持 **JavaScript** 语言的策略在回测时于Chrome浏览器DevTools中进行调试，[参考说明](https://www.fmz.com/digest-topic/9459)。\\n\\n4、**Workflow** 工作流策略支持回测，可可视化查看节点执行状态和数据流转。\", \"title\": \"回测系统支持多种编程语言\"}, {\"_src_hash\": \"f9aab303f47366ac469ca6197898aeb9e70d0142224c2a1aa46a3e67e003c6e7\", \"desc\": \"- 加密货币\\n 支持主流加密货币现货及期货交易所，覆盖交易所全部交易品种数据。\\n- 富途证券\\n 支持港股、美股等多个市场。\\n\\n 回测注意事项：回测系统目前仅支持富途日线级别数据：\\n ```js\\n /*backtest\\n start: 2024-05-01 00:00:00\\n end: 2025-02-17 00:00:00\\n period: 1d\\n basePeriod: 1d\\n exchanges: [{\\\"eid\\\":\\\"Futures_Futu\\\",\\\"currency\\\":\\\"STOCK\\\",\\\"fee\\\":[0.03,0.03]}]\\n */\\n\\n function main() {\\n let info = exchange.SetContractType(\\\"TLSA.US\\\") // 设置股票代码：特斯拉\\n Log(\\\"info:\\\", info) // info: {\\\"InstrumentID\\\":\\\"TLSA.US\\\",\\\"LotTick\\\":1,\\\"PriceTick\\\":0.01,\\\"VolumeMultiple\\\":1}\\n Log(exchange.GetTicker()) // {\\\"Time\\\":1714482000000,\\\"Symbol\\\":\\\"TLSA.US\\\",\\\"Open\\\":0.62,\\\"High\\\":0.63,\\\"Low\\\":0.61,\\\"Sell\\\":0.63,\\\"Buy\\\":0.61,\\\"Last\\\":0.62,\\\"Volume\\\":0,\\\"OpenInterest\\\":0}\\n }\\n ```\", \"title\": \"回测系统支持的交易所\"}, {\"_src_hash\": \"81ff2744b34bab9077f469aa705bc3f5ffae15ec4d65d587b20fef3992ee807c\", \"desc\": \"发明者量化交易平台回测系统参数调优功能允许在回测时根据各个参数的调优选项设置参数组合。在「模拟回测」页面的策略参数部分，勾选策略参数右侧的**调优**选项即可显示调优设置。\\n\\n- 最小值：设定参数的起始值。\\n- 最大值：设定参数递增变化后的最大值。\\n- 步长：参数递增的变化量。\\n- 并发线程：\\n 参数调优时，设置各个回测参数组合并发执行的线程数。该选项仅支持```JavaScript```、```PINE```、```My语言```的策略参数调优，不支持模板参数的调优。\\n\\n系统根据```最小值```、```最大值```、```步长```设置生成参数组合，并遍历这些参数组合进行回测（即对每种参数组合都执行一次回测）。策略参数只有类型为**数字型(number)**的参数才能在回测系统中进行参数调优设置。\", \"title\": \"回测系统参数调优\"}, {\"_src_hash\": \"f05f0312ca211cab209d871d6b4f2f44105b28f8657c3a2bbfb5379f9cadf71e\", \"desc\": \"在[策略编辑页面](https://www.fmz.com/m/add-strategy)的「模拟回测」标签页中（即回测系统），可以设置回测配置、策略参数等选项进行策略回测。回测配置用于设置回测时间范围、回测交易所、交易滑点、手续费等条件；策略参数用于设置策略的参数选项。\\n\\n当设置好这些参数配置后即可按照设定进行策略回测，那么如何保存这些已设置的配置信息呢？\\n- 1、可以使用[策略编辑页面](https://www.fmz.com/m/add-strategy)的「保存回测设置」按钮，将所有回测配置信息（包含回测设置、策略参数设置）以代码形式记录在策略源码中。\\n- 2、在策略编辑页面点击「保存策略」按钮保存策略时，平台会自动记录当前的回测设置、策略参数配置等信息。\\n\\n回测系统如何加载回测配置？\\n- 1、刷新策略编辑页面或重新打开策略编辑页面时，优先自动加载通过「保存回测设置」按钮记录的回测配置信息。\\n- 2、如果当前策略代码中没有以注释形式```backtest```记录的回测配置信息（通过「保存回测设置」按钮保存在策略代码中），回测系统将自动配置回测设置为该策略最后一次点击「保存策略」按钮时的回测配置信息。\\n- 3、如果在策略编辑页面中修改了策略代码开头部分以注释形式记录的回测配置信息，需要将更新后的回测配置信息同步到策略回测界面的选项中，可以点击策略编辑区域```backtest```上方的「回测设置」按钮。\", \"examples\": [{\"examples\": [{\"code\": \"/*backtest\\nstart: 2021-06-26 00:00:00\\nend: 2021-09-23 00:00:00\\nperiod: 1d\\nbasePeriod: 1h\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\"}]\\n*/\", \"lang\": \"javascript\"}, {\"code\": \"'''backtest\\nstart: 2021-06-26 00:00:00\\nend: 2021-09-23 00:00:00\\nperiod: 1d\\nbasePeriod: 1h\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\"}]\\n'''\", \"lang\": \"python\"}, {\"code\": \"/*backtest\\nstart: 2021-06-26 00:00:00\\nend: 2021-09-23 00:00:00\\nperiod: 1d\\nbasePeriod: 1h\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\"}]\\n*/\", \"lang\": \"cpp\"}], \"value\": \"点击「保存回测设置」按钮后，```JavaScript```/```Python```/```C++```/```My语言```/```PINE```语言的策略保存回测设置到策略代码时，格式略有差异：\"}, {\"value\": \"My语言：\\n\\n```My\\n(*backtest\\nstart: 2021-06-26 00:00:00\\nend: 2021-09-23 00:00:00\\nperiod: 1d\\nbasePeriod: 1h\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\"}]\\n*)\\n```\"}, {\"value\": \"PINE语言：\\n\\n```pine\\n/*backtest\\nstart: 2021-06-26 00:00:00\\nend: 2021-09-23 00:00:00\\nperiod: 1d\\nbasePeriod: 1h\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\"}]\\n*/\\n```\"}], \"title\": \"保存回测设置\"}, {\"_src_hash\": \"717a58abdd56911887099f3a4c343d90b102741f9a5878011e96705b2e8ae775\", \"children\": [{\"_src_hash\": \"8d767873562969fe333df0fe4a53925890d384311dbf587eaf1677d6a0b22c5e\", \"desc\": \"返回的格式必须为以下两种格式之一（系统自动识别）：\\n- 模拟级Tick，以下是JSON数据示例：\\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\\\": 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\\\":[\\\"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- 实盘级Tick，以下是JSON数据示例：\\n Tick级回测数据（包含盘口深度信息，深度格式为```[价格, 数量]```的数组。可包含多级深度，```asks```按价格升序排列，```bids```按价格降序排列）。\\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\\\": 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\\\":[\\\"time\\\", \\\"asks\\\", \\\"bids\\\", \\\"trades\\\", \\\"close\\\", \\\"vol\\\"],\\n \\\"data\\\":[\\n [1564315200000, [[9531300, 10]], [[9531300, 10]], [[1564315200000, 0, 9531300, 10]], 9497060, 787],\\n [1564316100000, [[9531300, 10]], [[9531300, 10]], [[1564316100000, 0, 9531300, 10]], 9497060, 787]\\n ]\\n }\\n ```\\n\\n| 字段 | 说明 |\\n| - | - |\\n| detail | 请求数据的品种详细信息，包含计价币名称、交易币名称、精度、最小下单量等 |\\n| schema | 指定data数组中列的属性，区分大小写。仅限于 time, open, high, low, close, vol, asks, bids, trades |\\n| data | 按照schema设置的列结构记录的数据 |\\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特殊列属性```asks```、```bids```、```trades```说明：\\n\\n| 字段 | 说明 | 备注 |\\n| - | - | - |\\n| asks / bids | [[价格, 数量], ...] | 例如```实盘级 Tick```数据示例中的数据：```[[9531300, 10]]``` |\\n| trades | [[时间, 方向(0:买,1:卖), 价格, 数量], ...] | 例如```实盘级 Tick```数据示例中的数据：```[[1564315200000, 0, 9531300, 10]]``` |\\n\\n期货交易所的永续合约回测时，自定义数据源还需要提供额外的资金费率数据和价格指数数据。只有当请求的行情数据返回时，返回结构中的detail字段包含```\\\"contractType\\\": \\\"swap\\\"```键值对，回测系统才会继续发送资金费率请求。\\n当回测系统收到资金费率数据后，才会继续发送价格指数数据请求。\\n\\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\\\": [\\n \\\"time\\\",\\n \\\"open\\\",\\n \\\"high\\\",\\n \\\"low\\\",\\n \\\"close\\\",\\n \\\"vol\\\"\\n ],\\n \\\"data\\\": [\\n [\\n 1584921600000,\\n -16795,\\n -16795,\\n -16795,\\n -16795,\\n 0\\n ],\\n [\\n 1584950400000,\\n -16294,\\n -16294,\\n -16294,\\n -16294,\\n 0\\n ]\\n // ...\\n ]\\n}\\n```\\n\\n- 相邻周期间隔为8小时\\n- 例如币安资金费率每8小时更新一次，资金费率数据为何是 -16795？\\n 这是因为与K线数据一样，为避免网络传输过程中浮点数精度丢失，数据采用整型表示；资金费率数据也可能为负值。\\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价格指数数据结构如下：\\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\\\": [\\n \\\"time\\\",\\n \\\"open\\\",\\n \\\"high\\\",\\n \\\"low\\\",\\n \\\"close\\\",\\n \\\"vol\\\"\\n ],\\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\": \"e1c8a8ed58b95a8cc309742dd703e41328598d471917774a0f1e1fc5eed0dd54\", \"desc\": \"指定数据源地址，例如：```http://120.24.2.20:9090/data```。自定义数据源服务程序使用```Golang```编写：\\n\\n```golang\\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 DataSourse: 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&from=1584921600&period=86400000&round=true&symbol=BTC_USDT&to=1611244800&trades=1\\n // http://xxx.xx.x.xx:9090/data?custom=0&depth=20&detail=true&eid=Futures_Binance&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 []int64{1610755200000, 3673743, 3795000, 3535780, 3599498, 8634843151}, // 1610755200000 : 2021-01-16 08:00:00\\n []int64{1610841600000, 3599498, 3685250, 3385000, 3582861, 8015772738}, // 1610841600000 : 2021-01-17 08:00:00\\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, []interface{}{[]int64{9531300, 10}}, []interface{}{[]int64{9531300, 10}}, []interface{}{[]int64{1610755200000, 0, 9531300, 10}}, 9497060, 787},\\n []interface{}{1610841600000, []interface{}{[]int64{9531300, 15}}, []interface{}{[]int64{9531300, 15}}, []interface{}{[]int64{1610841600000, 0, 9531300, 11}}, 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```js\\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://120.24.2.20: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\": \"发明者量化交易平台的回测系统支持自定义数据源，回测系统使用```GET```方法请求自定义的URL（可公开访问的网址）来获取外部数据源进行回测，附加的请求参数如下：\\n\\n| 参数 | 意义 | 说明 |\\n| - | - | - |\\n| symbol | 品种名称 | 现货行情数据示例：```BTC_USDT```，期货行情数据示例：```BTC_USDT.swap```，期货永续合约资金费率数据示例：```BTC_USDT.funding```，期货永续合约价格指数数据示例：```BTC_USDT.index``` |\\n| eid | 交易所 | 例如：OKX、Futures_OKX |\\n| round | 数据精度 | 为true时，表示由自定义数据源返回的数据中定义具体精度。发明者量化交易平台回测系统向自定义数据源发送的请求固定为：```round=true``` |\\n| period | K线数据的周期（毫秒） | 例如：```60000```表示1分钟周期 |\\n| depth | 深度档数 | 1-20 |\\n| trades | 是否需要逐笔成交数据 | 真（1）/假（0） |\\n| from | 开始时间 | unix时间戳 |\\n| to | 结束时间 | unix时间戳 |\\n| detail | 请求品种的详细信息 | 为true时，表示需要由自定义数据源提供。发明者量化交易平台回测系统向自定义数据源发送的请求固定为：```detail=true``` |\\n| custom | -- | 可忽略此参数 |\\n\\n现货交易所、期货交易所对象的数据源设置为自定义数据源（feeder）时，回测系统向自定义数据源服务发送请求的示例：\\n\\n```url\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Bitget&from=1351641600&period=86400000&round=true&symbol=BTC_USDT&to=1611244800&trades=1\\nhttp://customserver:9090/data?custom=0&depth=20&detail=true&eid=Futures_OKX&from=1351641600&period=86400000&round=true&symbol=BTC_USDT.swap&to=1611244800&trades=1\\n```\", \"title\": \"自定义数据源\"}, {\"_src_hash\": \"7b6ccbf8a5e2c6839e3dd5596a96f22db6728d39170368b6cb95435ab11032d0\", \"desc\": \"发明者量化交易平台开源了```JavaScript```语言和```Python```语言的本地回测引擎，支持回测时设置底层K线周期。\\n- [JavaScript语言回测引擎](https://github.com/fmzquant/backtest_javascript)\\n- [Python语言回测引擎](https://github.com/fmzquant/backtest_python)\\n\\n以Python语言为例，简要说明本地回测引擎的使用方法：\\n```python\\n'''backtest\\nstart: 2022-02-19 00:00:00\\nend: 2022-03-22 12:00:00\\nperiod: 15m\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"balance\\\":10000,\\\"stocks\\\":0}]\\n'''\\n\\n# Part 1 -----------------------------------\\n# 初始化回测引擎，backtest 为回测引擎配置信息，与 FMZ 平台线上回测系统配置保持一致\\n# 通过 __doc__ 读取上方的配置字符串并初始化回测环境\\nfrom fmz import *\\ntask = VCtx(__doc__) # initialize backtest engine from __doc__\\n# End -----------------------------------\\n\\n\\n# Part 2 -----------------------------------\\n# 以下为待测试的策略代码示例（可以从 FMZ 平台复制完整的策略代码）\\n# 注意：仅复制策略代码时不包含参数设计、交互设计等其他配置内容\\ndef onTick():\\n\\tticker = _C(exchange.GetTicker)\\n\\tLogStatus(_D(), ticker.Last)\\n\\ndef main():\\n\\texchange.SetCurrency(\\\"ETH_USDT\\\")\\n\\t# exchange.SetContractType(\\\"swap\\\") # 如果测试期货交易所对象，需要设置合约，例如这里设置为永续合约\\n\\tLog(exchange.GetAccount())\\n\\twhile True:\\n\\t\\tonTick()\\n\\t\\tSleep(1000)\\n# End -----------------------------------\\n\\n\\n# Part 3 -----------------------------------\\n# 执行回测并捕获结束信号，回测结束时会触发 EOF 异常\\n# 捕获异常后可以输出回测结果数据或展示回测图表\\ntry:\\n\\tmain()\\nexcept:\\n\\tprint(\\\"Strategy testing completed.\\\")\\n\\tprint(task.Join(False)) # print backtest result\\n\\t# task.Show() # or show backtest chart\\n# End -----------------------------------\\n```\", \"title\": \"本地回测引擎\"}, {\"_src_hash\": \"9ce03cd655d10108b5f45e38eeb37772ca98764d20331924095fdaf7bbdb3e05\", \"desc\": \"- 策略编辑页面和策略回测页面切换的快捷键\\n 使用```Ctrl + ,```键切换回测页面和策略编辑页面，按住```Ctrl```键后，单按```,```键。\\n- 策略保存的快捷键\\n 使用```Ctrl + s```键保存策略。\\n- 启动回测的快捷键\\n 使用```Ctrl + b```键启动回测。\", \"title\": \"回测页面快捷键\"}, {\"_src_hash\": \"dce702b5a6ae6b286ad54ad0a3610fd64657893ef04b1c93dd68a9b59be3d27e\", \"desc\": \"- 回测系统日志数据下载\\n 打开具体策略，切换到「回测页面」进行策略回测。回测结束后，在显示的「状态信息」栏右上角有「下载表格」按钮，点击即可下载回测结束时状态栏数据的CSV格式文件。\\n- 回测系统状态栏数据下载\\n 打开具体策略，切换到「回测页面」进行策略回测。回测结束后，在显示的「日志信息」栏右上角有「下载表格」按钮，点击即可下载回测日志数据的CSV格式文件。\", \"title\": \"回测数据下载\"}, {\"_src_hash\": \"59a3f88bc44be0d9c0fddfca115d4dac1bba5871e6fd9013b191a8a157abba94\", \"desc\": \"回测系统夏普比率算法源码：\\n```js\\nfunction returnAnalyze(totalAssets, profits, ts, te, period, yearDays) {\\n // force by days\\n period = 86400000\\n if (profits.length == 0) {\\n return null\\n }\\n var freeProfit = 0.03 // 0.04\\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```\", \"title\": \"回测系统夏普算法\"}], \"desc\": \"当您完成量化交易策略的设计后，如何验证策略的逻辑正确性、收益预期等关键指标？显然不能直接使用真实资金在市场中测试。正确的做法是使用历史数据对策略进行回测，通过分析策略在历史行情中的表现来评估其盈利能力和风险特征。\", \"title\": \"回测系统\"}, {\"_src_hash\": \"aee3d5ab44774edec4358eaeba69ffab0234e47acbbfe8f6fec9efb3862ea711\", \"children\": [{\"_src_hash\": \"1fbcc9b4cde6a326b2f1bae8614321d9754105699217a10111c80948d4b926ae\", \"desc\": \"```onexit()```函数用于处理策略退出时的清理工作，最长执行时间为5分钟，需由用户自行实现。\", \"examples\": [{\"examples\": [{\"code\": \"function main(){\\n Log(\\\"Starting, will stop after 5 seconds and execute cleanup function!\\\")\\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(\\\"Program stop countdown..cleanup started, elapsed time:\\\", (nowTime - beginTime) / 1000, \\\"seconds!\\\")\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import time\\ndef main():\\n Log(\\\"Starting, will stop after 5 seconds and execute cleanup function!\\\")\\n Sleep(1000 * 5)\\n\\ndef onexit():\\n beginTime = time.time() * 1000\\n while True:\\n ts = time.time() * 1000\\n Log(\\\"Program stop countdown..cleanup started, elapsed time:\\\", (ts - beginTime) / 1000, \\\"seconds!\\\")\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"void main() {\\n Log(\\\"Starting, will stop after 5 seconds and execute cleanup function!\\\");\\n Sleep(1000 * 5);\\n}\\n\\nvoid onexit() {\\n auto beginTime = Unix() * 1000;\\n while(true) {\\n auto ts = Unix() * 1000;\\n Log(\\\"Program stop countdown..cleanup started, elapsed time:\\\", (ts - beginTime) / 1000, \\\"seconds!\\\");\\n Sleep(1000);\\n }\\n}\", \"lang\": \"cpp\"}], \"value\": \"测试```onexit()```函数：\"}, {\"examples\": [{\"code\": \"function main() {\\n if (exchange.GetName().startsWith(\\\"Futures_\\\")) {\\n Log(\\\"Exchange is futures\\\")\\n exchange.SetContractType(\\\"swap\\\")\\n } else {\\n Log(\\\"Exchange is spot\\\")\\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(\\\"Executing cleanup function\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n if exchange.GetName().startswith(\\\"Futures_\\\"):\\n Log(\\\"Exchange is futures\\\")\\n else:\\n Log(\\\"Exchange is spot\\\")\\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(\\\"Executing cleanup function\\\")\", \"lang\": \"python\"}, {\"code\": \"#include \\n#include \\n#include \\n\\nvoid onTick() {\\n while (true) {\\n auto ticker = exchange.GetTicker();\\n LogStatus(_D(), ticker);\\n Sleep(500);\\n }\\n}\\n\\nvoid main() {\\n std::string prefix = \\\"Futures_\\\";\\n bool startsWith = exchange.GetName().substr(0, prefix.length()) == prefix;\\n if (startsWith) {\\n Log(\\\"Exchange is futures\\\");\\n exchange.SetContractType(\\\"swap\\\");\\n } else {\\n Log(\\\"Exchange is spot\\\");\\n }\\n\\n if (IsVirtual()) {\\n try {\\n onTick();\\n } catch (...) {\\n std::cerr << \\\"Caught unknown exception\\\" << std::endl;\\n }\\n } else {\\n onTick();\\n }\\n}\\n\\nvoid onexit() {\\n Log(\\\"Executing cleanup function\\\");\\n}\", \"lang\": \"cpp\"}], \"value\": \"由于回测系统中策略通常设计为无限循环持续轮询执行，导致回测系统无法触发策略中实现的```onexit()```函数。可以通过检测回测系统结束标记（EOF异常）来触发```onexit()```函数的执行。\"}], \"title\": \"onexit()\"}, {\"_src_hash\": \"a289ba49537e8d5c2bda8f373824b785e2642d3cff27cb935a8148c94b1682e7\", \"desc\": \"```init()```，用户实现初始化函数```init()```，策略开始运行时会首先自动执行```init()```函数，用于完成策略中设计的初始化任务。\", \"examples\": [{\"examples\": [{\"code\": \"function main(){\\n Log(\\\"First line of code executed!\\\", \\\"#FF0000\\\")\\n Log(\\\"Exiting!\\\")\\n}\\n\\n// 初始化函数\\nfunction init(){\\n Log(\\\"Initializing!\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n Log(\\\"First line of code executed!\\\", \\\"#FF0000\\\")\\n Log(\\\"Exiting!\\\")\\n\\ndef init():\\n Log(\\\"Initializing!\\\")\", \"lang\": \"python\"}, {\"code\": \"void main() {\\n Log(\\\"First line of code executed!\\\", \\\"#FF0000\\\");\\n Log(\\\"Exiting!\\\");\\n}\\n\\nvoid init() {\\n Log(\\\"Initializing!\\\");\\n}\", \"lang\": \"cpp\"}]}], \"title\": \"init()\"}, {\"_src_hash\": \"e0fa9e5417df7b574e49017330bb8e2525587a505f3b457357149b3c45da381b\", \"desc\": \"```onerror()```，当发生异常时会触发```onerror()```函数执行，该函数不支持```Python```、```C++```语言的策略。```onerror()```函数可以接收一个```msg```参数，该```msg```参数为异常触发时的错误信息。\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var arr = []\\n Log(arr[6].Close) // 这里故意引发一个程序异常\\n}\\n\\nfunction onerror(msg) {\\n Log(\\\"Error:\\\", msg)\\n}\", \"lang\": \"javascript\"}, {\"code\": \"# python不支持\", \"lang\": \"python\"}, {\"code\": \"// C++不支持\", \"lang\": \"cpp\"}]}], \"title\": \"onerror()\"}], \"desc\": \"对于```JavaScript```、```Python```、```C++```语言的策略，发明者量化交易平台已定义以下入口函数。\\n\\n| 函数名 | 说明 |\\n| - | - |\\n|```main()```| 入口函数，策略的主函数。 |\\n|```onexit()```| 正常退出时的清理函数，最长执行时间为5分钟，可以不声明。如果超时会报**interrupt**错误。在实盘中，如果先触发了```onerror()```函数，则不会再触发```onexit()```函数。 |\\n|```onerror()```| 异常退出时触发执行的函数，最长执行时间为5分钟，可以不声明。```Python```语言、```C++```语言编写的策略不支持该函数，回测系统也不支持该函数。 |\\n|```init()```| 初始化函数，策略程序在开始运行时会首先自动调用，可以不声明。 |\\n\\n**注意事项：**\\n- 当```main()```函数执行结束时，所有创建的子线程会被自动终止。\", \"title\": \"策略入口函数\"}, {\"_src_hash\": \"632e2a5ecd97520841f17ecccc1bac59825fe403f910412b7cc922c9a3ac6412\", \"children\": [{\"_src_hash\": \"70a106861b4e596c4dcd08b3f5409cc5cff117c9f7e4b49eaa6c7d83fd9aaf4e\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| [Version](/syntax-guide#fun_version) | 返回系统当前版本号 |\\n| [Sleep](/syntax-guide#fun_sleep) | 休眠函数，参数为暂停的毫秒数 |\\n| [IsVirtual](/syntax-guide#fun_isvirtual) | 判断执行环境，返回真值表示回测环境 |\\n| [Mail](/syntax-guide#fun_mail) | 发送邮件 |\\n| [Mail_Go](/syntax-guide#fun_mail_go) | ```Mail```函数的异步版本 |\\n| [SetErrorFilter](/syntax-guide#fun_seterrorfilter) | 过滤错误日志，参数为正则表达式字符串，匹配该正则表达式的错误日志将不会上传到日志系统 |\\n| [GetPid](/syntax-guide#fun_getpid) | 获取实盘进程ID |\\n| [GetLastError](/syntax-guide#fun_getlasterror) | 获取最近一次的错误信息 |\\n| [GetCommand](/syntax-guide#fun_getcommand) | 获取策略交互命令，策略交互控件设置请参考：[交互控件](/user-guide#交互控件) |\\n| [GetMeta](/syntax-guide#fun_getmeta) | 获取生成策略注册码时写入的Meta值 |\\n| [Dial](/syntax-guide#fun_dial) | 用于原始Socket访问 |\\n| [HttpQuery](/syntax-guide#fun_httpquery) | 发送HTTP请求 |\\n| [HttpQuery_Go](/syntax-guide#fun_httpquery_go) | ```HttpQuery```函数的异步版本 |\\n| [Encode](/syntax-guide#fun_encode) | 数据编码函数 |\\n| [UnixNano](/syntax-guide#fun_unixnano) | 获取纳秒级时间戳 |\\n| [Unix](/syntax-guide#fun_unix) | 获取秒级时间戳 |\\n| [GetOS](/syntax-guide#fun_getos) | 获取系统信息 |\\n| [MD5](/syntax-guide#fun_md5) | 计算MD5哈希值 |\\n| [DBExec](/syntax-guide#fun_dbexec) | 数据库函数，用于执行SQL语句并进行数据库操作 |\\n| [UUID](/syntax-guide#fun_uuid) | 生成UUID |\\n| [EventLoop](/syntax-guide#fun_eventloop) | 监听事件，在任意WebSocket可读或```exchange.Go```、```HttpQuery_Go```等并发任务完成后返回，该函数仅适用于实盘 |\\n| [_G](/syntax-guide#fun__g) | 持久化保存数据，该函数实现了一个可保存的全局字典功能。数据结构为键值对表，永久保存在托管者本地数据库文件中 |\\n| [_D](/syntax-guide#fun__d) | 时间戳处理函数，将毫秒时间戳或Date对象转换为时间字符串 |\\n| [_N](/syntax-guide#fun__n) | 格式化浮点数，例如```_N(3.1415, 2)```将删除3.1415小数点后两位以后的数值，函数返回3.14 |\\n| [_C](/syntax-guide#fun__c) | 重试函数，用于接口容错。注意，例如对```exchange.GetTicker```函数进行容错，应使用```_C(exchange.GetTicker)```而非```_C(exchange.GetTicker())``` |\\n| [_Cross](/syntax-guide#fun__cross) | 交叉判断函数，```_Cross()```函数返回正数表示上穿周期数，负数表示下穿周期数，0表示当前价格相同 |\\n| [JSONParse](/syntax-guide#fun_jsonparse) | 解析JSON，能够正确解析包含大数值的JSON字符串，将大数值解析为字符串类型。回测系统不支持```JSONParse()```函数 |\\n| [SetChannelData](/syntax-guide#fun_setchanneldata) | 在频道上发布最新状态数据，用于实盘间通信 |\\n| [GetChannelData](/syntax-guide#fun_getchanneldata) | 订阅指定实盘的频道数据，用于实盘间通信 |\", \"title\": \"全局函数\"}, {\"_src_hash\": \"b8cd24fa5737e6865b949073470cb7a01f94100ad0336cc744b7d897dff1af70\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| [Log](/syntax-guide#fun_log) | 输出日志，支持设置日志文本颜色、推送功能，以及打印base64编码的图片 |\\n| [LogProfit](/syntax-guide#fun_logprofit) | 输出盈亏数据，打印盈亏数值并根据数值绘制收益曲线 |\\n| [LogProfitReset](/syntax-guide#fun_logprofitreset) | 清空```LogProfit```函数输出的所有收益日志和收益图表 |\\n| [LogStatus](/syntax-guide#fun_logstatus) | 在状态栏输出信息，支持在状态栏中设置按钮控件和输出表格 |\\n| [EnableLog](/syntax-guide#fun_enablelog) | 开启或关闭订单信息的日志记录功能 |\\n| [Chart](/syntax-guide#fun_chart) | 图表绘制函数，基于Highcharts/Highstocks图表库 |\\n| [KLineChart](/syntax-guide#fun_klinechart) | Pine语言风格的图表绘制函数，用于在策略运行时以类似Pine语言的方式进行自定义绘图 |\\n| [LogReset](/syntax-guide#fun_logreset) | 清除日志，支持通过参数设置保留最近指定数量的日志记录 |\\n| [LogVacuum](/syntax-guide#fun_logvacuum) | 回收SQLite资源，在调用```LogReset()```函数清除日志后，回收SQLite删除数据时占用的存储空间 |\\n| [console.log](/syntax-guide#fun_console.log) | 在实盘页面的「调试信息」栏中输出调试信息 |\\n| [console.error](/syntax-guide#fun_console.error) | 在实盘页面的「调试信息」栏中输出错误信息 |\", \"title\": \"日志函数\"}, {\"_src_hash\": \"7dac1e0cdfc6ecaf8f699baee2719db1ba3e1616b3c5f316467500e888049565\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| [exchange.GetTicker](/syntax-guide#fun_exchange.getticker) | 获取Tick行情数据 |\\n| [exchange.GetDepth](/syntax-guide#fun_exchange.getdepth) | 获取订单簿深度数据 |\\n| [exchange.GetTrades](/syntax-guide#fun_exchange.gettrades) | 获取市场成交记录 |\\n| [exchange.GetRecords](/syntax-guide#fun_exchange.getrecords) | 获取K线数据 |\\n| [exchange.GetPeriod](/syntax-guide#fun_exchange.getperiod) | 获取当前K线周期 |\\n| [exchange.SetMaxBarLen](/syntax-guide#fun_exchange.setmaxbarlen) | 设置K线最大长度 |\\n| [exchange.GetRawJSON](/syntax-guide#fun_exchange.getrawjson) | 获取最近一次REST请求返回的原始内容 |\\n| [exchange.GetRate](/syntax-guide#fun_exchange.getrate) | 获取当前设置的汇率值 |\\n| [exchange.SetData](/syntax-guide#fun_exchange.setdata) | 设置策略运行时加载的数据 |\\n| [exchange.GetData](/syntax-guide#fun_exchange.getdata) | 获取已加载的数据或外部链接提供的数据 |\\n| [exchange.GetMarkets](/syntax-guide#fun_exchange.getmarkets) | 获取交易所市场信息 |\\n| [exchange.GetTickers](/syntax-guide#fun_exchange.gettickers) | 获取交易所聚合行情数据 |\", \"title\": \"行情函数\"}, {\"_src_hash\": \"1e299ae4eed288934dd0d321b68b2791645523ec1d97599ddaac44dc1f8913c2\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| [exchange.Buy](/syntax-guide#fun_exchange.buy) | 提交买单，期货合约下单时必须注意交易方向是否设置正确，如果交易方向与交易函数不匹配将报错 |\\n| [exchange.Sell](/syntax-guide#fun_exchange.sell) | 提交卖单，期货合约下单时必须注意交易方向是否设置正确，如果交易方向与交易函数不匹配将报错 |\\n| [exchange.CreateOrder](/syntax-guide#fun_exchange.createorder) | 提交订单，通过参数指定交易品种、交易方向、价格、数量 |\\n| [exchange.ModifyOrder](/syntax-guide#fun_exchange.modifyorder) | 修改普通订单的价格和数量，支持通过附加参数修改订单的其他属性 |\\n| [exchange.ModifyConditionOrder](/syntax-guide#fun_exchange.modifyconditionorder) | 修改条件单的数量和触发条件，支持通过附加参数修改条件单的其他属性 |\\n| [exchange.CancelOrder](/syntax-guide#fun_exchange.cancelorder) | 取消订单 |\\n| [exchange.GetOrder](/syntax-guide#fun_exchange.getorder) | 获取订单信息，数据结构为[Order](/syntax-guide#struct_order)结构 |\\n| [exchange.GetOrders](/syntax-guide#fun_exchange.getorders) | 获取未完成的订单，数据结构为[Order](/syntax-guide#struct_order)结构数组（列表） |\\n| [exchange.GetHistoryOrders](/syntax-guide#fun_exchange.gethistoryorders)| 获取当前交易对、合约的历史订单，支持指定具体交易品种 |\\n| [exchange.SetPrecision](/syntax-guide#fun_exchange.setprecision) | 设置exchange交易所对象的价格与下单量精度，设置后系统将自动忽略数据的多余部分 |\\n| [exchange.SetRate](/syntax-guide#fun_exchange.setrate) | 设置汇率 |\\n| [exchange.IO](/syntax-guide#fun_exchange.io) | 用于交易所对象相关的其他接口调用 |\\n| [exchange.Log](/syntax-guide#fun_exchange.log) | 输出并记录交易日志，不实际下单 |\\n| [exchange.Encode](/syntax-guide#fun_exchange.encode) | 签名加密计算 |\\n| [exchange.Go](/syntax-guide#fun_exchange.go) | 多线程异步支持函数 |\\n| [exchange.GetAccount](/syntax-guide#fun_exchange.getaccount) | 获取账户信息 |\\n| [exchange.GetAssets](/syntax-guide#fun_exchange.getassets) | 请求交易所账户资产信息 |\\n| [exchange.GetName](/syntax-guide#fun_exchange.getname) | 获取交易所对象的名称 |\\n| [exchange.GetLabel](/syntax-guide#fun_exchange.getlabel) | 获取交易所对象的标签 |\\n| [exchange.GetCurrency](/syntax-guide#fun_exchange.getcurrency) | 获取当前交易对 |\\n| [exchange.SetCurrency](/syntax-guide#fun_exchange.setcurrency) | 切换交易对 |\\n| [exchange.GetQuoteCurrency](/syntax-guide#fun_exchange.getquotecurrency)| 获取当前交易对的计价币名称 |\", \"title\": \"交易函数\"}, {\"_src_hash\": \"a94309b29b3babf63cc7942dfe5fa55643908c713f7f6cbde351572d27d6710a\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| [exchange.GetPositions](/syntax-guide#fun_exchange.getpositions) | 获取期货持仓信息，返回[Position](/syntax-guide#struct_position)结构数组（列表） |\\n| [exchange.SetMarginLevel](/syntax-guide#fun_exchange.setmarginlevel) | 设置杠杆倍数 |\\n| [exchange.SetDirection](/syntax-guide#fun_exchange.setdirection) | 设置[exchange.Buy](/syntax-guide#fun_exchange.buy)函数、[exchange.Sell](/syntax-guide#fun_exchange.sell)函数在期货合约下单时的订单方向 |\\n| [exchange.SetContractType](/syntax-guide#fun_exchange.setcontracttype) | 设置合约代码，例如：```exchange.SetContractType(\\\"swap\\\")```设置合约代码为```swap```，将当前操作的合约设置为永续合约 |\\n| [exchange.GetContractType](/syntax-guide#fun_exchange.getcontracttype) | 获取当前设置的合约代码 |\\n| [exchange.GetFundings](/syntax-guide#fun_exchange.getfundings) | 获取当前期货交易所永续合约的资金费率数据 |\", \"title\": \"期货函数\"}, {\"_src_hash\": \"2ed1b8da2ef32619f05c820d89a00aee1fe4327cae3c971c90d2f2e6d816037b\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| [exchange.SetBase](/syntax-guide#fun_exchange.setbase) | 设置交易所API接口的基础地址 |\\n| [exchange.GetBase](/syntax-guide#fun_exchange.getbase) | 获取当前交易所API接口的基础地址 |\\n| [exchange.SetProxy](/syntax-guide#fun_exchange.setproxy) | 设置网络代理 |\\n| [exchange.SetTimeout](/syntax-guide#fun_exchange.settimeout) | 设置REST协议的超时时间 |\", \"title\": \"网络函数\"}, {\"_src_hash\": \"1f55b29b50ce99a4cd2d96b1daf4b7f5027c181a20da796aeeff04bd25bfe5cd\", \"desc\": \"## 功能概述\\n\\nAPI限流控制功能用于限制策略对交易所API的调用频率，防止触发交易所的频率限制导致账户被封禁或临时限制。FMZ平台提供了灵活的限流配置方式，支持两种限流模式和多种配置策略。\\n\\n### 为什么需要API限流\\n\\n- **避免触发交易所限制**：大多数交易所对API调用频率有严格限制，超限会导致账户被暂时或永久封禁。\\n- **合理分配API配额**：在多策略、多交易对场景下，需要合理分配API调用资源。\\n- **提高策略稳定性**：通过主动限流，避免因频繁调用导致的连接失败和数据获取异常。\\n- **符合交易所规范**：遵守交易所的API使用规范，维护良好的API使用关系。\\n\\n### 两种限流模式\\n\\n**rate模式（平滑限流）**\\n- 适用于一般限流需求\\n- 不严格对齐时间窗口\\n- 调用分布相对平滑\\n- 推荐用于日常API调用限制\\n\\n**quota模式（额度限流）**\\n- 严格对齐时间窗口\\n- 例如设置```\\\"1s\\\"```时，窗口对齐到整秒；设置```\\\"1m\\\"```时，窗口对齐到整分钟\\n- 适用于需要严格控制时间窗口的场景\\n- 推荐用于日内配额管理\\n\\n## 基本用法\\n\\n### rate模式基本示例\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n // Limit GetTicker to maximum 10 times per second\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\")\\n\\n // Normal API calls\\n for (var i = 0; i < 20; i++) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (ticker) {\\n Log(\\\"Success:\\\", ticker.Last)\\n } else {\\n Log(\\\"Rate limit exceeded\\\") // Returns null when exceeding 10 times/second\\n }\\n Sleep(50)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # Limit GetTicker to maximum 10 times per second\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\")\\n\\n # Normal API calls\\n for i in range(20):\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if ticker:\\n Log(\\\"Success:\\\", ticker[\\\"Last\\\"])\\n else:\\n Log(\\\"Rate limit exceeded\\\") # Returns None when exceeding 10 times/second\\n Sleep(50)\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}]}, {\"examples\": [{\"code\": \"function main() {\\n // Strict limit, time window aligned to whole seconds\\n exchange.IO(\\\"quota\\\", \\\"GetTicker\\\", 5, \\\"1s\\\")\\n\\n for (var i = 0; i < 10; i++) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n Log(_D(), \\\"Call\\\", i+1, ticker ? \\\"Success\\\" : \\\"Quota exceeded\\\")\\n Sleep(150) // About 6-7 calls per second, will trigger limit\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # Strict limit, time window aligned to whole seconds\\n exchange.IO(\\\"quota\\\", \\\"GetTicker\\\", 5, \\\"1s\\\")\\n\\n for i in range(10):\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n Log(_D(), \\\"Call\\\", i+1, \\\"Success\\\" if ticker else \\\"Quota exceeded\\\")\\n Sleep(150) # About 6-7 calls per second, will trigger limit\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"### quota模式基本示例\"}, {\"examples\": [{\"code\": \"function main() {\\n // Only limit GetTicker function\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\")\\n\\n // GetTicker is limited, GetDepth is not limited\\n exchange.GetTicker(\\\"BTC_USDT\\\")\\n exchange.GetDepth(\\\"BTC_USDT\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # Only limit GetTicker function\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\")\\n\\n # GetTicker is limited, GetDepth is not limited\\n exchange.GetTicker(\\\"BTC_USDT\\\")\\n exchange.GetDepth(\\\"BTC_USDT\\\")\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"## 函数名配置\\n\\n### 单个函数限流\"}, {\"examples\": [{\"code\": \"function main() {\\n // GetTicker and GetDepth share quota, total 10 times per second\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 10, \\\"1s\\\")\\n\\n for (var i = 0; i < 15; i++) {\\n if (i % 2 == 0) {\\n exchange.GetTicker(\\\"BTC_USDT\\\") // Counted in shared quota\\n } else {\\n exchange.GetDepth(\\\"BTC_USDT\\\") // Counted in shared quota\\n }\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # GetTicker and GetDepth share quota, total 10 times per second\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 10, \\\"1s\\\")\\n\\n for i in range(15):\\n if i % 2 == 0:\\n exchange.GetTicker(\\\"BTC_USDT\\\") # Counted in shared quota\\n else:\\n exchange.GetDepth(\\\"BTC_USDT\\\") # Counted in shared quota\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"### 多个函数联合限流\"}, {\"examples\": [{\"code\": \"function main() {\\n // Limit all API calls to total 100 times per minute\\n exchange.IO(\\\"rate\\\", \\\"*\\\", 100, \\\"1m\\\")\\n\\n // All calls are counted in total quota\\n exchange.GetTicker(\\\"BTC_USDT\\\")\\n exchange.GetDepth(\\\"BTC_USDT\\\")\\n exchange.GetAccount()\\n exchange.CreateOrder(\\\"BTC_USDT\\\", \\\"buy\\\", 50000, 0.001)\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # Limit all API calls to total 100 times per minute\\n exchange.IO(\\\"rate\\\", \\\"*\\\", 100, \\\"1m\\\")\\n\\n # All calls are counted in total quota\\n exchange.GetTicker(\\\"BTC_USDT\\\")\\n exchange.GetDepth(\\\"BTC_USDT\\\")\\n exchange.GetAccount()\\n exchange.CreateOrder(\\\"BTC_USDT\\\", \\\"buy\\\", 50000, 0.001)\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"### 使用通配符限制所有函数\"}, {\"examples\": [{\"code\": \"function main() {\\n // Different time period configurations\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\") // 10 times per second\\n exchange.IO(\\\"rate\\\", \\\"GetDepth\\\", 30, \\\"1m\\\") // 30 times per minute\\n exchange.IO(\\\"rate\\\", \\\"GetAccount\\\", 100, \\\"1h\\\") // 100 times per hour\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder\\\", 500, \\\"1d\\\") // 500 times per day\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 不同时间周期的配置\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\") # 每秒10次\\n exchange.IO(\\\"rate\\\", \\\"GetDepth\\\", 30, \\\"1m\\\") # 每分钟30次\\n exchange.IO(\\\"rate\\\", \\\"GetAccount\\\", 100, \\\"1h\\\") # 每小时100次\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder\\\", 500, \\\"1d\\\") # 每天500次\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"## 时间周期配置\\n\\n### 支持的时间单位\\n\\n- ```ns```：纳秒\\n- ```us``` 或 ```µs```：微秒\\n- ```ms```：毫秒\\n- ```s```：秒\\n- ```m```：分钟\\n- ```h```：小时\\n- ```d```：天\\n\\n示例：```\\\"100ms\\\"```, ```\\\"1s\\\"```, ```\\\"5m\\\"```, ```\\\"1h\\\"```, ```\\\"1d\\\"```\"}, {\"examples\": [{\"code\": \"function main() {\\n // Reset quota daily at 08:15\\n exchange.IO(\\\"quota\\\", \\\"GetTicker\\\", 1000, \\\"@0815\\\")\\n\\n // Reset quota daily at 00:00\\n exchange.IO(\\\"quota\\\", \\\"CreateOrder\\\", 500, \\\"@0000\\\")\\n\\n // Reset quota daily at 23:59:59\\n exchange.IO(\\\"quota\\\", \\\"*\\\", 5000, \\\"@235959\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # Reset quota daily at 08:15\\n exchange.IO(\\\"quota\\\", \\\"GetTicker\\\", 1000, \\\"@0815\\\")\\n\\n # Reset quota daily at 00:00\\n exchange.IO(\\\"quota\\\", \\\"CreateOrder\\\", 500, \\\"@0000\\\")\\n\\n # Reset quota daily at 23:59:59\\n exchange.IO(\\\"quota\\\", \\\"*\\\", 5000, \\\"@235959\\\")\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"### 重置时间点配置\\n\\n使用```@HHMM```或```@HHMMSS```格式指定每日重置时间点，仅在quota模式下生效。\"}, {\"examples\": [{\"code\": \"function main() {\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\") // 不指定behavior参数\\n\\n for (var i = 0; i < 10; i++) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (ticker) {\\n Log(\\\"Call\\\", i+1, \\\"Success:\\\", ticker.Last)\\n } else {\\n Log(\\\"Call\\\", i+1, \\\"Failed: rate limit exceeded\\\")\\n // 可以选择Sleep等待，或者跳过本次调用\\n Sleep(200)\\n }\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\") # 不指定behavior参数\\n\\n for i in range(10):\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if ticker:\\n Log(\\\"Call\\\", i+1, \\\"Success:\\\", ticker[\\\"Last\\\"])\\n else:\\n Log(\\\"Call\\\", i+1, \\\"Failed: rate limit exceeded\\\")\\n # 可以选择Sleep等待，或者跳过本次调用\\n Sleep(200)\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"## 行为模式\\n\\n### 默认模式（超限返回null）\"}, {\"examples\": [{\"code\": \"function main() {\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\", \\\"delay\\\") // 指定delay参数\\n\\n // 调用超限时会自动等待，确保每次调用都成功\\n for (var i = 0; i < 10; i++) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n Log(\\\"Call\\\", i+1, \\\"Success:\\\", ticker.Last) // ticker不会为null\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\", \\\"delay\\\") # 指定delay参数\\n\\n # 调用超限时会自动等待，确保每次调用都成功\\n for i in range(10):\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n Log(\\\"Call\\\", i+1, \\\"Success:\\\", ticker[\\\"Last\\\"]) # ticker不会为None\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"### delay模式（超限自动等待）\"}, {\"value\": \"## 支持的函数列表\\n\\n### 交易类函数\\n\\n- ```CreateOrder```：创建订单\\n\\n- ```CancelOrder```：取消订单\\n\\n- ```Buy```：买入（受CreateOrder限制）\\n\\n- ```Sell```：卖出（受CreateOrder限制）\\n\\n- ```CreateConditionOrder```：创建条件单\\n\\n- ```CancelConditionOrder```：取消条件单\\n\\n### 账户类函数\\n\\n- ```GetAccount```：获取账户信息\\n\\n- ```GetAssets```：获取资产信息\\n\\n- ```GetPositions```：获取持仓信息\\n\\n### 订单类函数\\n\\n- ```GetOrder```：获取单个订单\\n\\n- ```GetOrders```：获取所有订单\\n\\n- ```GetHistoryOrders```：获取历史订单\\n\\n- ```GetConditionOrder```：获取单个条件单\\n\\n- ```GetConditionOrders```：获取所有条件单\\n\\n- ```GetHistoryConditionOrders```：获取历史条件单\\n\\n### 行情类函数\\n\\n- ```GetTicker```：获取ticker数据\\n\\n- ```GetTickers```：获取多个ticker数据\\n\\n- ```GetDepth```：获取市场深度\\n\\n- ```GetRecords```：获取K线数据\\n\\n- ```GetTrades```：获取最新成交记录\\n\\n### 其他函数\\n\\n- ```GetMarkets```：获取市场列表\\n\\n- ```GetFundings```：获取资金费率\\n\\n- ```SetMarginLevel```：设置杠杆倍数\\n\\n- ```Go```：并发调用（受实际调用函数限制）\\n\\n- ```IO/api```：自定义API调用（仅限exchange.IO(\\\"api\\\", ...)）\"}, {\"examples\": [{\"code\": \"function main() {\\n // 假设交易所限制：GetTicker每秒20次，CreateOrder每秒5次\\n // 设置略低于交易所限制的值，留出安全余量\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 15, \\\"1s\\\")\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder\\\", 4, \\\"1s\\\")\\n\\n while (true) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (ticker && ticker.Last < 50000) {\\n exchange.CreateOrder(\\\"BTC_USDT\\\", \\\"buy\\\", ticker.Last, 0.001)\\n }\\n Sleep(100)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 假设交易所限制：GetTicker每秒20次，CreateOrder每秒5次\\n # 设置略低于交易所限制的值，留出安全余量\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 15, \\\"1s\\\")\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder\\\", 4, \\\"1s\\\")\\n\\n while True:\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if ticker and ticker[\\\"Last\\\"] < 50000:\\n exchange.CreateOrder(\\\"BTC_USDT\\\", \\\"buy\\\", ticker[\\\"Last\\\"], 0.001)\\n Sleep(100)\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"## 实际应用场景\\n\\n### 场景1：防止触发交易所频率限制\"}, {\"examples\": [{\"code\": \"function main() {\\n // 为每个交易所对象设置限流\\n for (var i = 0; i < exchanges.length; i++) {\\n exchanges[i].IO(\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\")\\n exchanges[i].IO(\\\"rate\\\", \\\"CreateOrder\\\", 2, \\\"1s\\\")\\n }\\n\\n // 并发获取多个交易所行情\\n while (true) {\\n for (var i = 0; i < exchanges.length; i++) {\\n var ticker = exchanges[i].GetTicker(\\\"BTC_USDT\\\")\\n if (ticker) {\\n Log(exchanges[i].GetName(), \\\"Price:\\\", ticker.Last)\\n }\\n }\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 为每个交易所对象设置限流\\n for i in range(len(exchanges)):\\n exchanges[i].IO(\\\"rate\\\", \\\"GetTicker\\\", 10, \\\"1s\\\")\\n exchanges[i].IO(\\\"rate\\\", \\\"CreateOrder\\\", 2, \\\"1s\\\")\\n\\n # 并发获取多个交易所行情\\n while True:\\n for i in range(len(exchanges)):\\n ticker = exchanges[i].GetTicker(\\\"BTC_USDT\\\")\\n if ticker:\\n Log(exchanges[i].GetName(), \\\"Price:\\\", ticker[\\\"Last\\\"])\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"### 场景2：多交易所对象统一限流\"}, {\"examples\": [{\"code\": \"function main() {\\n // 每天最多1000次API调用，每天早上8点重置\\n exchange.IO(\\\"quota\\\", \\\"*\\\", 1000, \\\"@0800\\\")\\n\\n var callCount = 0\\n while (true) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (ticker) {\\n callCount++\\n Log(\\\"Call count:\\\", callCount, \\\"Price:\\\", ticker.Last)\\n } else {\\n Log(\\\"Daily quota exceeded, waiting for tomorrow 08:00\\\")\\n Sleep(60000) // 等待1分钟后重试\\n }\\n Sleep(10000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 每天最多1000次API调用，每天早上8点重置\\n exchange.IO(\\\"quota\\\", \\\"*\\\", 1000, \\\"@0800\\\")\\n\\n callCount = 0\\n while True:\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if ticker:\\n callCount += 1\\n Log(\\\"Call count:\\\", callCount, \\\"Price:\\\", ticker[\\\"Last\\\"])\\n else:\\n Log(\\\"Daily quota exceeded, waiting for tomorrow 08:00\\\")\\n Sleep(60000) # 等待1分钟后重试\\n Sleep(10000)\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"### 场景3：日内配额管理\"}, {\"examples\": [{\"code\": \"function main() {\\n // 组合多种限流策略\\n // 1. 行情类API每秒限制\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\")\\n\\n // 2. 交易类API每秒限制\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\")\\n\\n // 3. 账户查询每分钟限制\\n exchange.IO(\\\"rate\\\", \\\"GetAccount,GetPositions\\\", 30, \\\"1m\\\")\\n\\n // 4. 所有API每天总配额\\n exchange.IO(\\\"quota\\\", \\\"*\\\", 10000, \\\"@0000\\\")\\n\\n Log(\\\"Multi-level rate limiting configured\\\")\\n\\n // 策略主循环\\n while (true) {\\n // 获取行情\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n var depth = exchange.GetDepth(\\\"BTC_USDT\\\")\\n\\n // 查询账户\\n if (Date.now() % 60000 < 1000) { // 每分钟查询一次\\n var account = exchange.GetAccount()\\n Log(\\\"Account:\\\", account)\\n }\\n\\n // 交易逻辑\\n if (ticker && ticker.Last < 50000) {\\n exchange.CreateOrder(\\\"BTC_USDT\\\", \\\"buy\\\", ticker.Last, 0.001)\\n }\\n\\n Sleep(500)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import time\\ndef main():\\n # 组合多种限流策略\\n # 1. 行情类API每秒限制\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\")\\n\\n # 2. 交易类API每秒限制\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\")\\n\\n # 3. 账户查询每分钟限制\\n exchange.IO(\\\"rate\\\", \\\"GetAccount,GetPositions\\\", 30, \\\"1m\\\")\\n\\n # 4. 所有API每天总配额\\n exchange.IO(\\\"quota\\\", \\\"*\\\", 10000, \\\"@0000\\\")\\n\\n Log(\\\"Multi-level rate limiting configured\\\")\\n\\n # 策略主循环\\n while True:\\n # 获取行情\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n depth = exchange.GetDepth(\\\"BTC_USDT\\\")\\n\\n # 查询账户\\n if int(time.time() * 1000) % 60000 < 1000: # 每分钟查询一次\\n account = exchange.GetAccount()\\n Log(\\\"Account:\\\", account)\\n\\n # 交易逻辑\\n if ticker and ticker[\\\"Last\\\"] < 50000:\\n exchange.CreateOrder(\\\"BTC_USDT\\\", \\\"buy\\\", ticker[\\\"Last\\\"], 0.001)\\n\\n Sleep(500)\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"### 场景4：组合限流策略\"}, {\"examples\": [{\"code\": \"function main() {\\n // quota模式：严格对齐到整秒\\n exchange.IO(\\\"quota\\\", \\\"GetTicker\\\", 3, \\\"1s\\\")\\n\\n // 假设当前时间为 12:00:00.500\\n exchange.GetTicker(\\\"BTC_USDT\\\") // 第1次，成功\\n exchange.GetTicker(\\\"BTC_USDT\\\") // 第2次，成功\\n exchange.GetTicker(\\\"BTC_USDT\\\") // 第3次，成功\\n exchange.GetTicker(\\\"BTC_USDT\\\") // 第4次，失败（超限）\\n\\n Sleep(500) // 等待500ms，此时时间为 12:00:01.000\\n\\n // 窗口已重置\\n exchange.GetTicker(\\\"BTC_USDT\\\") // 新窗口第1次，成功\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # quota模式：严格对齐到整秒\\n exchange.IO(\\\"quota\\\", \\\"GetTicker\\\", 3, \\\"1s\\\")\\n\\n # 假设当前时间为 12:00:00.500\\n exchange.GetTicker(\\\"BTC_USDT\\\") # 第1次，成功\\n exchange.GetTicker(\\\"BTC_USDT\\\") # 第2次，成功\\n exchange.GetTicker(\\\"BTC_USDT\\\") # 第3次，成功\\n exchange.GetTicker(\\\"BTC_USDT\\\") # 第4次，失败（超限）\\n\\n Sleep(500) # 等待500ms，此时时间为 12:00:01.000\\n\\n # 窗口已重置\\n exchange.GetTicker(\\\"BTC_USDT\\\") # 新窗口第1次，成功\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"## 注意事项\\n\\n### 1. quota模式时间窗口对齐\\n\\nquota模式严格对齐时间窗口：\\n\\n- ```\\\"1s\\\"```：对齐到整秒（例如：12:00:00, 12:00:01, 12:00:02...）\\n- ```\\\"1m\\\"```：对齐到整分钟（例如：12:00:00, 12:01:00, 12:02:00...）\\n- ```\\\"1h\\\"```：对齐到整小时（例如：12:00:00, 13:00:00, 14:00:00...）\\n\\n这意味着即使在12:00:00.500开始计数，到12:00:01.000时窗口就会重置。\"}, {\"examples\": [{\"code\": \"function main() {\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 2, \\\"1s\\\", \\\"delay\\\")\\n\\n Log(_D(), \\\"Call 1\\\") // 12:00:00.000\\n exchange.GetTicker(\\\"BTC_USDT\\\")\\n\\n Log(_D(), \\\"Call 2\\\") // 12:00:00.100\\n exchange.GetTicker(\\\"BTC_USDT\\\")\\n\\n Log(_D(), \\\"Call 3\\\") // 12:00:00.200，但实际会等待到12:00:01.000\\n exchange.GetTicker(\\\"BTC_USDT\\\") // 触发限流，自动等待\\n\\n Log(_D(), \\\"Call 3 completed\\\") // 日志显示12:00:01.000+\\n // 看起来一秒内调用了3次，但实际第3次是在新窗口执行的\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 2, \\\"1s\\\", \\\"delay\\\")\\n\\n Log(_D(), \\\"Call 1\\\") # 12:00:00.000\\n exchange.GetTicker(\\\"BTC_USDT\\\")\\n\\n Log(_D(), \\\"Call 2\\\") # 12:00:00.100\\n exchange.GetTicker(\\\"BTC_USDT\\\")\\n\\n Log(_D(), \\\"Call 3\\\") # 12:00:00.200，但实际会等待到12:00:01.000\\n exchange.GetTicker(\\\"BTC_USDT\\\") # 触发限流，自动等待\\n\\n Log(_D(), \\\"Call 3 completed\\\") # 日志显示12:00:01.000+\\n # 看起来一秒内调用了3次，但实际第3次是在新窗口执行的\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"### 2. delay模式下的时间差异\\n\\n使用```\\\"delay\\\"```参数时，实际API调用时间与日志记录时间可能不一致。这是因为当触发限流时，程序会等待，但日志记录的是等待结束后的时间。\"}, {\"examples\": [{\"code\": \"function main() {\\n // 设置CreateOrder限流\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder\\\", 5, \\\"1s\\\")\\n\\n // Buy和Sell也会受到此限制\\n for (var i = 0; i < 10; i++) {\\n if (i % 2 == 0) {\\n exchange.Buy(50000, 0.001) // 受CreateOrder限制\\n } else {\\n exchange.Sell(51000, 0.001) // 受CreateOrder限制\\n }\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 设置CreateOrder限流\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder\\\", 5, \\\"1s\\\")\\n\\n # Buy和Sell也会受到此限制\\n for i in range(10):\\n if i % 2 == 0:\\n exchange.Buy(50000, 0.001) # 受CreateOrder限制\\n else:\\n exchange.Sell(51000, 0.001) # 受CreateOrder限制\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"### 3. Buy/Sell函数的限流\\n\\n```Buy```和```Sell```函数底层调用```CreateOrder```，因此它们的限流遵循```CreateOrder```的设置。\"}, {\"examples\": [{\"code\": \"function main() {\\n // 限制GetTicker\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\")\\n\\n // 并发调用GetTicker时受限\\n var tasks = []\\n for (var i = 0; i < 10; i++) {\\n tasks.push(exchange.Go(\\\"GetTicker\\\", \\\"BTC_USDT\\\"))\\n }\\n\\n for (var i = 0; i < tasks.length; i++) {\\n var ticker = tasks[i].wait()\\n Log(\\\"Task\\\", i, ticker ? \\\"Success\\\" : \\\"Rate limited\\\")\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 限制GetTicker\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\")\\n\\n # 并发调用GetTicker时受限\\n tasks = []\\n for i in range(10):\\n tasks.append(exchange.Go(\\\"GetTicker\\\", \\\"BTC_USDT\\\"))\\n\\n for i in range(len(tasks)):\\n ticker = tasks[i].wait()\\n Log(\\\"Task\\\", i, \\\"Success\\\" if ticker else \\\"Rate limited\\\")\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"### 4. Go函数的限流\\n\\n```Go```函数的限流取决于实际并发调用的函数。\"}, {\"examples\": [{\"code\": \"function main() {\\n // 限制exchange.IO(\\\"api\\\", ...)调用\\n exchange.IO(\\\"rate\\\", \\\"IO/api\\\", 10, \\\"1s\\\")\\n\\n // 受限制\\n for (var i = 0; i < 15; i++) {\\n var ret = exchange.IO(\\\"api\\\", \\\"GET\\\", \\\"/api/v5/account/balance\\\", \\\"\\\")\\n Log(\\\"API call\\\", i, ret ? \\\"Success\\\" : \\\"Rate limited\\\")\\n }\\n\\n // 不受限制\\n exchange.IO(\\\"currency\\\", \\\"LTC_USDT\\\") // 切换交易对，不受限\\n exchange.IO(\\\"rate\\\", \\\"GetDepth\\\", 5, \\\"1s\\\") // 设置其他限流，不受限\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 限制exchange.IO(\\\"api\\\", ...)调用\\n exchange.IO(\\\"rate\\\", \\\"IO/api\\\", 10, \\\"1s\\\")\\n\\n # 受限制\\n for i in range(15):\\n ret = exchange.IO(\\\"api\\\", \\\"GET\\\", \\\"/api/v5/account/balance\\\", \\\"\\\")\\n Log(\\\"API call\\\", i, \\\"Success\\\" if ret else \\\"Rate limited\\\")\\n\\n # 不受限制\\n exchange.IO(\\\"currency\\\", \\\"LTC_USDT\\\") # 切换交易对，不受限\\n exchange.IO(\\\"rate\\\", \\\"GetDepth\\\", 5, \\\"1s\\\") # 设置其他限流，不受限\", \"lang\": \"python\"}, {\"code\": \"// C++暂不支持\", \"lang\": \"cpp\"}], \"value\": \"### 5. IO/api的限流\\n\\n```IO/api```限流仅对```exchange.IO(\\\"api\\\", ...)```调用生效，不影响其他```exchange.IO```功能。\"}, {\"value\": \"## 最佳实践\\n\\n\\n 1. **根据交易所限制进行设置**：参考交易所API文档，将限制值设置为略低于交易所规定的最大值。\\n\\n 2. **预留安全余量**：不要将限制设置为交易所的最大值，建议设置为最大值的70%-80%。\\n\\n 3. **实施分层限流**：针对不同类型的API设置不同的限制，为重要API预留更多余量。\\n\\n 4. **对关键调用使用delay模式**：对于必须成功的API调用，使用```\\\"delay\\\"```模式确保调用成功。\\n\\n 5. **监控API使用情况**：定期检查策略的API调用频率，持续优化调用逻辑。\\n\\n 6. **避免过度调用**：合理设计策略逻辑，减少不必要的API调用。\\n\\n 7. **测试限流配置**：在实盘交易前，先在模拟环境中测试限流配置的合理性。\"}], \"seeAlso\": [\"{@fun/Trade/exchange.IO exchange.IO}, {@fun/Trade/exchange.Go exchange.Go}, {@fun/Trade/exchange.Buy exchange.Buy}, {@fun/Trade/exchange.Sell exchange.Sell}\"], \"title\": \"API限流控制\"}, {\"_src_hash\": \"9f9aa63514dee8ec0f38778b33a815608adaac6b7b91be3923d6ba14f04e94ba\", \"desc\": \"## 功能概述\\n\\n策略实盘间通信功能允许不同的实盘策略之间进行数据共享和状态同步。通过频道机制，一个实盘可以将自己的状态数据广播给其他实盘，实现跨实盘、跨托管者、跨服务器的数据通信。\\n\\n### 核心概念\\n\\n- **频道(Channel)**：每个实盘都有一个独立的频道，频道ID即为实盘ID\\n- **广播端**：使用```SetChannelData()```函数在频道上发布数据的实盘\\n- **订阅端**：使用```GetChannelData()```函数订阅其他实盘频道数据的实盘\\n- **状态覆盖**：频道上仅保存最新状态，新数据会覆盖旧数据，而非消息队列\\n\\n### 主要特性\\n\\n- **非阻塞通信**：所有函数调用均为非阻塞式，不会影响策略主流程\\n- **跨平台支持**：支持跨实盘、跨托管者、跨服务器进行数据传输\\n- **多频道订阅**：单个实盘可同时订阅多个不同实盘的频道\\n- **灵活的数据格式**：支持任意可JSON序列化的数据结构\\n\\n### 应用场景\\n\\n- **主从策略协同**：主策略分析市场并广播信号，从策略接收信号执行交易\\n- **多账户同步**：在多个交易账户之间同步交易信号和仓位信息\\n- **策略监控**：监控策略广播运行状态，监控实盘订阅并进行展示或告警\\n- **数据共享**：共享行情分析、指标计算等结果，避免重复计算\\n\\n## 基本用法\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var updateId = 0\\n var robotId = _G() // 获取当前实盘ID\\n\\n while(true) {\\n // 获取市场数据\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (!ticker) {\\n Sleep(5000)\\n continue\\n }\\n\\n // 准备频道状态数据\\n var channelState = {\\n robotId: robotId,\\n updateId: ++updateId,\\n timestamp: Date.now(),\\n symbol: \\\"BTC_USDT\\\",\\n lastPrice: ticker.Last,\\n volume: ticker.Volume,\\n high: ticker.High,\\n low: ticker.Low\\n }\\n\\n // 在频道上发布最新状态（覆盖旧状态）\\n SetChannelData(channelState)\\n\\n // 显示当前频道状态\\n LogStatus(\\\"Channel Broadcaster [Bot ID: \\\" + robotId + \\\"]\\\\n\\\" +\\n \\\"Update ID: #\\\" + channelState.updateId + \\\"\\\\n\\\" +\\n \\\"Time: \\\" + _D(channelState.timestamp) + \\\"\\\\n\\\" +\\n \\\"Symbol: \\\" + channelState.symbol + \\\"\\\\n\\\" +\\n \\\"Last Price: $\\\" + channelState.lastPrice.toFixed(2))\\n\\n Sleep(60000) // 每分钟更新一次频道状态\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n updateId = 0\\n robotId = _G() # 获取当前实盘ID\\n\\n while True:\\n # 获取市场数据\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if not ticker:\\n Sleep(5000)\\n continue\\n\\n # 准备频道状态数据\\n channelState = {\\n \\\"robotId\\\": robotId,\\n \\\"updateId\\\": updateId + 1,\\n \\\"timestamp\\\": time.time() * 1000,\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"lastPrice\\\": ticker[\\\"Last\\\"],\\n \\\"volume\\\": ticker[\\\"Volume\\\"],\\n \\\"high\\\": ticker[\\\"High\\\"],\\n \\\"low\\\": ticker[\\\"Low\\\"]\\n }\\n updateId += 1\\n\\n # 在频道上发布最新状态（覆盖旧状态）\\n SetChannelData(channelState)\\n\\n # 显示当前频道状态\\n LogStatus(\\\"Channel Broadcaster [Bot ID: {}]\\\\n\\\".format(robotId) +\\n \\\"Update ID: #{}\\\\n\\\".format(channelState[\\\"updateId\\\"]) +\\n \\\"Time: {}\\\\n\\\".format(_D(channelState[\\\"timestamp\\\"])) +\\n \\\"Last Price: ${:.2f}\\\".format(channelState[\\\"lastPrice\\\"]))\\n\\n Sleep(60000) # 每分钟更新一次频道状态\", \"lang\": \"python\"}, {\"code\": \"\", \"lang\": \"cpp\"}], \"value\": \"### 广播端示例 - 发布市场数据\"}, {\"examples\": [{\"code\": \"function main() {\\n // 需要订阅的两个频道ID（根据实际情况修改）\\n var channelId1 = \\\"632799\\\" // 频道1的实盘ID\\n var channelId2 = \\\"632800\\\" // 频道2的实盘ID\\n\\n while(true) {\\n // 订阅频道1的当前状态\\n var state1 = GetChannelData(channelId1)\\n\\n // 订阅频道2的当前状态\\n var state2 = GetChannelData(channelId2)\\n\\n // 构建状态显示\\n var statusMsg = \\\"频道订阅端 - 当前订阅状态\\\\n\\\\n\\\"\\n\\n // 显示频道1状态\\n statusMsg += \\\"═══ 频道1 [\\\" + channelId1 + \\\"] ═══\\\\n\\\"\\n if (state1 !== null) {\\n statusMsg += \\\"更新ID: #\\\" + state1.updateId + \\\"\\\\n\\\"\\n statusMsg += \\\"时间: \\\" + _D(state1.timestamp) + \\\"\\\\n\\\"\\n statusMsg += \\\"交易对: \\\" + state1.symbol + \\\"\\\\n\\\"\\n statusMsg += \\\"最新价: $\\\" + state1.lastPrice.toFixed(2) + \\\"\\\\n\\\"\\n } else {\\n statusMsg += \\\"状态: 等待中...（首次调用返回 null）\\\\n\\\"\\n }\\n\\n statusMsg += \\\"\\\\n\\\"\\n\\n // 显示频道2状态\\n statusMsg += \\\"═══ 频道2 [\\\" + channelId2 + \\\"] ═══\\\\n\\\"\\n if (state2 !== null) {\\n statusMsg += \\\"更新ID: #\\\" + state2.updateId + \\\"\\\\n\\\"\\n statusMsg += \\\"时间: \\\" + _D(state2.timestamp) + \\\"\\\\n\\\"\\n statusMsg += \\\"最新价: $\\\" + state2.lastPrice.toFixed(2) + \\\"\\\\n\\\"\\n } else {\\n statusMsg += \\\"状态: 等待中...（首次调用返回 null）\\\\n\\\"\\n }\\n\\n LogStatus(statusMsg)\\n\\n Sleep(5000) // 每5秒订阅一次频道\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 需要订阅的两个频道ID（根据实际情况修改）\\n channelId1 = \\\"632799\\\" # 频道1的实盘ID\\n channelId2 = \\\"632800\\\" # 频道2的实盘ID\\n\\n while True:\\n # 订阅频道1的当前状态\\n state1 = GetChannelData(channelId1)\\n\\n # 订阅频道2的当前状态\\n state2 = GetChannelData(channelId2)\\n\\n # 构建状态显示\\n statusMsg = \\\"频道订阅端 - 当前订阅状态\\\\n\\\\n\\\"\\n\\n # 显示频道1状态\\n statusMsg += \\\"═══ 频道1 [{}] ═══\\\\n\\\".format(channelId1)\\n if state1 is not None:\\n statusMsg += \\\"更新ID: #{}\\\\n\\\".format(state1[\\\"updateId\\\"])\\n statusMsg += \\\"时间: {}\\\\n\\\".format(_D(state1[\\\"timestamp\\\"]))\\n statusMsg += \\\"最新价: ${:.2f}\\\\n\\\".format(state1[\\\"lastPrice\\\"])\\n else:\\n statusMsg += \\\"状态: 等待中...（首次调用返回 None）\\\\n\\\"\\n\\n statusMsg += \\\"\\\\n\\\"\\n\\n # 显示频道2状态\\n statusMsg += \\\"═══ 频道2 [{}] ═══\\\\n\\\".format(channelId2)\\n if state2 is not None:\\n statusMsg += \\\"更新ID: #{}\\\\n\\\".format(state2[\\\"updateId\\\"])\\n statusMsg += \\\"时间: {}\\\\n\\\".format(_D(state2[\\\"timestamp\\\"]))\\n statusMsg += \\\"最新价: ${:.2f}\\\\n\\\".format(state2[\\\"lastPrice\\\"])\\n else:\\n statusMsg += \\\"状态: 等待中...（首次调用返回 None）\\\\n\\\"\\n\\n LogStatus(statusMsg)\\n\\n Sleep(5000) # 每5秒订阅一次频道\", \"lang\": \"python\"}, {\"code\": \"\", \"lang\": \"cpp\"}], \"value\": \"### 订阅端示例 - 订阅多个频道\"}, {\"examples\": [{\"code\": \"function main() {\\n var robotId = _G()\\n Log(\\\"Main strategy started, Bot ID:\\\", robotId)\\n\\n while(true) {\\n // 分析市场，生成交易信号\\n var records = exchange.GetRecords(\\\"BTC_USDT\\\")\\n if (!records || records.length < 20) {\\n Sleep(5000)\\n continue\\n }\\n\\n // 简单的均线策略\\n var ma5 = TA.MA(records, 5)\\n var ma20 = TA.MA(records, 20)\\n var signal = \\\"HOLD\\\"\\n\\n if (ma5[ma5.length-1] > ma20[ma20.length-1] &&\\n ma5[ma5.length-2] <= ma20[ma20.length-2]) {\\n signal = \\\"BUY\\\"\\n } else if (ma5[ma5.length-1] < ma20[ma20.length-1] &&\\n ma5[ma5.length-2] >= ma20[ma20.length-2]) {\\n signal = \\\"SELL\\\"\\n }\\n\\n // 广播交易信号\\n var signalData = {\\n timestamp: Date.now(),\\n symbol: \\\"BTC_USDT\\\",\\n signal: signal,\\n price: records[records.length-1].Close,\\n ma5: ma5[ma5.length-1],\\n ma20: ma20[ma20.length-1]\\n }\\n\\n SetChannelData(signalData)\\n LogStatus(\\\"Main Strategy - Signal Broadcast\\\\n\\\" +\\n \\\"Signal: \\\" + signal + \\\"\\\\n\\\" +\\n \\\"Price: $\\\" + signalData.price.toFixed(2) + \\\"\\\\n\\\" +\\n \\\"MA5: \\\" + signalData.ma5.toFixed(2) + \\\"\\\\n\\\" +\\n \\\"MA20: \\\" + signalData.ma20.toFixed(2))\\n\\n Sleep(60000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n robotId = _G()\\n Log(\\\"Main strategy started, Bot ID:\\\", robotId)\\n\\n while True:\\n # 分析市场，生成交易信号\\n records = exchange.GetRecords(\\\"BTC_USDT\\\")\\n if not records or len(records) < 20:\\n Sleep(5000)\\n continue\\n\\n # 简单的均线策略\\n ma5 = TA.MA(records, 5)\\n ma20 = TA.MA(records, 20)\\n signal = \\\"HOLD\\\"\\n\\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\\n # 广播交易信号\\n signalData = {\\n \\\"timestamp\\\": time.time() * 1000,\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"signal\\\": signal,\\n \\\"price\\\": records[-1][\\\"Close\\\"],\\n \\\"ma5\\\": ma5[-1],\\n \\\"ma20\\\": ma20[-1]\\n }\\n\\n SetChannelData(signalData)\\n LogStatus(\\\"Main Strategy - Signal Broadcast\\\\n\\\" +\\n \\\"Signal: {}\\\\n\\\".format(signal) +\\n \\\"Price: ${:.2f}\\\\n\\\".format(signalData[\\\"price\\\"]) +\\n \\\"MA5: {:.2f}\\\\n\\\".format(signalData[\\\"ma5\\\"]) +\\n \\\"MA20: {:.2f}\\\".format(signalData[\\\"ma20\\\"]))\\n\\n Sleep(60000)\", \"lang\": \"python\"}, {\"code\": \"\", \"lang\": \"cpp\"}], \"value\": \"## 实际应用场景\\n\\n### 场景1：主从策略协同交易\\n\\n**主策略（信号广播端）**\"}, {\"examples\": [{\"code\": \"function main() {\\n var masterRobotId = \\\"632799\\\" // 主策略的实盘ID\\n var lastSignal = null\\n\\n Log(\\\"Follower strategy started, subscribing to main strategy:\\\", masterRobotId)\\n\\n while(true) {\\n // 获取主策略的信号\\n var signalData = GetChannelData(masterRobotId)\\n\\n if (signalData === null) {\\n LogStatus(\\\"Waiting for main strategy signal...\\\")\\n Sleep(5000)\\n continue\\n }\\n\\n // 检查是否有新信号\\n if (lastSignal !== signalData.signal) {\\n Log(\\\"Received new signal:\\\", signalData.signal, \\\"Price:\\\", signalData.price)\\n\\n // 执行交易\\n if (signalData.signal === \\\"BUY\\\") {\\n var ticker = exchange.GetTicker(signalData.symbol)\\n if (ticker) {\\n exchange.Buy(ticker.Last, 0.01)\\n Log(\\\"Executing buy, Price:\\\", ticker.Last)\\n }\\n } else if (signalData.signal === \\\"SELL\\\") {\\n var ticker = exchange.GetTicker(signalData.symbol)\\n if (ticker) {\\n exchange.Sell(ticker.Last, 0.01)\\n Log(\\\"Executing sell, Price:\\\", ticker.Last)\\n }\\n }\\n\\n lastSignal = signalData.signal\\n }\\n\\n LogStatus(\\\"Follower Strategy - Following Main Strategy\\\\n\\\" +\\n \\\"Current Signal: \\\" + signalData.signal + \\\"\\\\n\\\" +\\n \\\"Signal Price: $\\\" + signalData.price.toFixed(2) + \\\"\\\\n\\\" +\\n \\\"Signal Time: \\\" + _D(signalData.timestamp))\\n\\n Sleep(5000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n masterRobotId = \\\"632799\\\" # 主策略的实盘ID\\n lastSignal = None\\n\\n Log(\\\"Follower strategy started, subscribing to main strategy:\\\", masterRobotId)\\n\\n while True:\\n # 获取主策略的信号\\n signalData = GetChannelData(masterRobotId)\\n\\n if signalData is None:\\n LogStatus(\\\"Waiting for main strategy signal...\\\")\\n Sleep(5000)\\n continue\\n\\n # 检查是否有新信号\\n if lastSignal != signalData[\\\"signal\\\"]:\\n Log(\\\"Received new signal:\\\", signalData[\\\"signal\\\"], \\\"Price:\\\", signalData[\\\"price\\\"])\\n\\n # 执行交易\\n if signalData[\\\"signal\\\"] == \\\"BUY\\\":\\n ticker = exchange.GetTicker(signalData[\\\"symbol\\\"])\\n if ticker:\\n exchange.Buy(ticker[\\\"Last\\\"], 0.01)\\n Log(\\\"Executing buy, Price:\\\", ticker[\\\"Last\\\"])\\n elif signalData[\\\"signal\\\"] == \\\"SELL\\\":\\n ticker = exchange.GetTicker(signalData[\\\"symbol\\\"])\\n if ticker:\\n exchange.Sell(ticker[\\\"Last\\\"], 0.01)\\n Log(\\\"Executing sell, Price:\\\", ticker[\\\"Last\\\"])\\n\\n lastSignal = signalData[\\\"signal\\\"]\\n\\n LogStatus(\\\"Follower Strategy - Following Main Strategy\\\\n\\\" +\\n \\\"Current Signal: {}\\\\n\\\".format(signalData[\\\"signal\\\"]) +\\n \\\"Signal Price: ${:.2f}\\\\n\\\".format(signalData[\\\"price\\\"]) +\\n \\\"Signal Time: {}\\\".format(_D(signalData[\\\"timestamp\\\"])))\\n\\n Sleep(5000)\", \"lang\": \"python\"}, {\"code\": \"\", \"lang\": \"cpp\"}], \"value\": \"## 实际应用场景\\n\\n### 场景1：主从策略协同交易\\n\\n**从策略（信号接收执行端）**\"}, {\"examples\": [{\"code\": \"function main() {\\n // 需要监控的策略实盘ID列表\\n var monitorList = [\\\"632799\\\", \\\"632800\\\", \\\"632801\\\"]\\n\\n while(true) {\\n var table = {\\n type: \\\"table\\\",\\n title: \\\"策略运行状态监控\\\",\\n cols: [\\\"实盘ID\\\", \\\"状态\\\", \\\"最后更新\\\", \\\"交易对\\\", \\\"当前价格\\\", \\\"盈亏\\\"],\\n rows: []\\n }\\n\\n for (var i = 0; i < monitorList.length; i++) {\\n var robotId = monitorList[i]\\n var data = GetChannelData(robotId)\\n\\n if (data !== null) {\\n var updateTime = _D(data.timestamp)\\n var timeDiff = Date.now() - data.timestamp\\n var status = timeDiff < 120000 ? \\\"运行中\\\" : \\\"异常\\\"\\n\\n table.rows.push([\\n robotId,\\n status,\\n updateTime,\\n data.symbol || \\\"-\\\",\\n data.lastPrice ? \\\"$\\\" + data.lastPrice.toFixed(2) : \\\"-\\\",\\n data.profit ? data.profit.toFixed(2) + \\\"%\\\" : \\\"-\\\"\\n ])\\n } else {\\n table.rows.push([\\n robotId,\\n \\\"等待数据\\\",\\n \\\"-\\\",\\n \\\"-\\\",\\n \\\"-\\\",\\n \\\"-\\\"\\n ])\\n }\\n }\\n\\n LogStatus(\\\"`\\\" + JSON.stringify(table) + \\\"`\\\")\\n Sleep(10000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 需要监控的策略实盘ID列表\\n monitorList = [\\\"632799\\\", \\\"632800\\\", \\\"632801\\\"]\\n\\n while True:\\n table = {\\n \\\"type\\\": \\\"table\\\",\\n \\\"title\\\": \\\"策略运行状态监控\\\",\\n \\\"cols\\\": [\\\"实盘ID\\\", \\\"状态\\\", \\\"最后更新\\\", \\\"交易对\\\", \\\"当前价格\\\", \\\"盈亏\\\"],\\n \\\"rows\\\": []\\n }\\n\\n for robotId in monitorList:\\n data = GetChannelData(robotId)\\n\\n if data is not None:\\n updateTime = _D(data[\\\"timestamp\\\"])\\n timeDiff = time.time() * 1000 - data[\\\"timestamp\\\"]\\n status = \\\"运行中\\\" if timeDiff < 120000 else \\\"异常\\\"\\n\\n table[\\\"rows\\\"].append([\\n robotId,\\n status,\\n updateTime,\\n data.get(\\\"symbol\\\", \\\"-\\\"),\\n \\\"${:.2f}\\\".format(data[\\\"lastPrice\\\"]) if \\\"lastPrice\\\" in data else \\\"-\\\",\\n \\\"{:.2f}%\\\".format(data[\\\"profit\\\"]) if \\\"profit\\\" in data else \\\"-\\\"\\n ])\\n else:\\n table[\\\"rows\\\"].append([\\n robotId,\\n \\\"等待数据\\\",\\n \\\"-\\\",\\n \\\"-\\\",\\n \\\"-\\\",\\n \\\"-\\\"\\n ])\\n\\n LogStatus(\\\"`\\\" + json.dumps(table) + \\\"`\\\")\\n Sleep(10000)\", \"lang\": \"python\"}, {\"code\": \"\", \"lang\": \"cpp\"}], \"value\": \"### 场景2：多策略状态监控\\n\\n**监控策略**\"}, {\"value\": \"## API函数说明\\n\\n### SetChannelData(data)\\n\\n**功能**：在频道上发布最新状态数据\\n\\n**参数**：\\n- data：需要发布的数据，可以是任何可JSON序列化的数据结构\\n\\n**返回值**：无\\n\\n**特性**：\\n- 非阻塞调用\\n- 覆盖之前的数据，不累积历史\\n- 自动使用当前实盘ID作为频道ID\\n\\n**数据长度限制**：\\n- JSON序列化后不超过1024字节\\n- 建议仅传输必要的状态信息\\n\\n**详细文档**：[SetChannelData](/syntax-guide#fun_setchanneldata)\\n\\n### GetChannelData(robotId)\\n\\n**功能**：订阅指定实盘的频道数据\\n\\n**参数**：\\n- robotId：要订阅的实盘ID（字符串或数字）\\n\\n**返回值**：\\n- 首次调用返回null，需要重试\\n- 成功后返回频道的最新数据\\n\\n**特性**：\\n- 非阻塞调用\\n- 可订阅多个频道\\n- 可订阅自己的频道\\n\\n**详细文档**：[GetChannelData](/syntax-guide#fun_getchanneldata)\\n\\n## 注意事项\\n\\n- **首次调用返回null**：```GetChannelData()```函数首次调用时会返回```null```，这是正常现象，需要等待数据同步完成。建议在代码中进行null判断。\\n\\n- **数据覆盖机制**：频道上仅保存最新状态，调用```SetChannelData()```会覆盖之前的数据。如需保存历史数据，应在订阅端自行记录。\\n\\n- **非阻塞特性**：所有频道通信函数均为非阻塞的，不会影响策略的主流程执行。但这也意味着无法保证数据的即时性。\\n\\n- **数据大小限制**：传入SetChannelData的数据在JSON序列化后不得超过1024字节。应仅传输必要的状态信息，如交易信号、价格、持仓等关键数据，避免传输完整的K线数组或大量历史数据。\\n\\n- **实盘环境限制**：频道通信功能主要适用于实盘环境，在回测系统中可能受限或不可用。\\n\\n- **实盘ID获取**：可通过```_G()```函数获取当前实盘ID，也可在平台界面查看实盘ID。\\n\\n- **安全性考虑**：频道数据可能被其他有权限的实盘订阅，请勿在频道中传输敏感信息（如API密钥等）。\\n\\n## 最佳实践\\n\\n- **合理的更新频率**：根据实际需求设置数据更新频率，避免过于频繁的更新造成资源浪费。\\n\\n- **数据结构设计**：设计清晰的数据结构，包含必要的元数据（如时间戳、版本号等），便于订阅端处理。\\n\\n- **错误处理**：订阅端应处理null返回值，广播端应确保数据格式正确。\\n\\n- **状态版本控制**：在数据中包含版本号或更新ID，帮助订阅端判断是否有新数据。\\n\\n- **监控与告警**：对于关键的通信链路，建议实现超时监控和告警机制。\\n\\n- **测试验证**：在正式使用前，先在测试环境验证频道通信的稳定性和延迟。\\n\\n- **文档记录**：记录频道数据格式和通信协议，便于后续维护和多人协作。\"}], \"seeAlso\": [\"{@fun/Global/SetChannelData SetChannelData}\", \"{@fun/Global/GetChannelData GetChannelData}\", \"{@fun/Global/G _G}\"], \"title\": \"策略实盘间通信\"}, {\"_src_hash\": \"0636b05d0977be547aab53ad3517c8653820015082fd7a42736258e4ff6b0078\", \"desc\": \"发明者量化交易平台从系统底层真正支持```JavaScript```语言策略的多线程功能，实现了以下对象：\\n\\n| 对象 | 说明 | 备注 |\\n| - | - | - |\\n| threading | 多线程全局对象 | 成员函数：```Thread```、```getThread```、```mainThread```等。 |\\n| Thread | 线程对象 | 成员函数：```peekMessage```、```postMessage```、```join```等。 |\\n| ThreadLock | 线程锁对象 | 成员函数：```acquire```、```release```。可作为线程执行函数的参数传入线程环境。 |\\n| ThreadEvent | 事件对象 | 成员函数：```set```、```clear```、```wait```、```isSet```。可作为线程执行函数的参数传入线程环境。 |\\n| ThreadCondition | 条件对象 | 成员函数：```notify```、```notifyAll```、```wait```、```acquire```、```release```。可作为线程执行函数的参数传入线程环境。 |\\n| ThreadDict | 字典对象 | 成员函数：```get```、```set```。可作为线程执行函数的参数传入线程环境。 |\\n\\n发明者量化交易平台语法手册：[JavaScript多线程](https://www.fmz.com/syntax-guide/fun/threads)\", \"title\": \"JavaScript多线程\"}, {\"_src_hash\": \"ce6fa44bd90271b516e3ad82300a5c34b09830c13de1ab0f8fe7b8bfb040470e\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| [exchange.IO(\\\"abi\\\", ...)](/syntax-guide#fun_exchange.ioabi-...) | 注册ABI接口 |\\n| [exchange.IO(\\\"api\\\", \\\"eth\\\", ...)](/syntax-guide#fun_exchange.ioapi-eth-...) | 调用以太坊RPC方法 |\\n| [exchange.IO(\\\"encode\\\", ...)](/syntax-guide#fun_exchange.ioencode-...) | 对函数调用进行编码 |\\n| [exchange.IO(\\\"encodePacked\\\", ...)](/syntax-guide#fun_exchange.ioencodepacked-...) | 执行encodePacked编码 |\\n| [exchange.IO(\\\"decode\\\", ...)](/syntax-guide#fun_exchange.iodecode-...) | 对数据进行解码 |\\n| [exchange.IO(\\\"key\\\", ...)](/syntax-guide#fun_exchange.iokey-...) | 切换私钥 |\\n| [exchange.IO(\\\"api\\\", ...)](/syntax-guide#fun_exchange.ioapi-...) | 调用智能合约方法 |\\n| [exchange.IO(\\\"address\\\")](/syntax-guide#fun_exchange.ioaddress) | 获取当前配置的钱包地址 |\\n| [exchange.IO(\\\"base\\\", ...)](/syntax-guide#fun_exchange.iobase-...) | 设置RPC节点地址 |\", \"title\": \"Web3\"}, {\"_src_hash\": \"b750f3966c2f6d43e592200ae9b7d5ae4c3216fb28b37fa313af48dd5d76b3c3\", \"desc\": \"| 函数名称 | 简介 |\\n| - | - |\\n| [TA.MACD](/syntax-guide#fun_ta.macd) | 计算指数平滑异同移动平均线指标 |\\n| [TA.KDJ](/syntax-guide#fun_ta.kdj) | 计算随机指标 |\\n| [TA.RSI](/syntax-guide#fun_ta.rsi) | 计算相对强弱指标 |\\n| [TA.ATR](/syntax-guide#fun_ta.atr) | 计算真实波动幅度均值指标 |\\n| [TA.OBV](/syntax-guide#fun_ta.obv) | 计算能量潮指标 |\\n| [TA.MA](/syntax-guide#fun_ta.ma) | 计算移动平均线指标 |\\n| [TA.EMA](/syntax-guide#fun_ta.ema) | 计算指数移动平均线指标 |\\n| [TA.BOLL](/syntax-guide#fun_ta.boll) | 计算布林带指标 |\\n| [TA.Alligator](/syntax-guide#fun_ta.alligator) | 计算鳄鱼线指标 |\\n| [TA.CMF](/syntax-guide#fun_ta.cmf) | 计算蔡金资金流量指标 |\\n| [TA.Highest](/syntax-guide#fun_ta.highest) | 计算指定周期内的最高价 |\\n| [TA.Lowest](/syntax-guide#fun_ta.lowest) | 计算指定周期内的最低价 |\\n| [TA.SMA](/syntax-guide#fun_ta.sma) | 计算简单移动平均线指标 |\", \"title\": \"TA指标库\"}, {\"_src_hash\": \"fefeeb195c3a0ffe2913d6d4cdd9ef2b8d6e27cd8dfe03df11cf545ef2acecc8\", \"desc\": \"talib指标库包含众多技术分析指标，例如：[talib.CDL2CROWS](/syntax-guide#fun_talib.cdl2crows)。详细信息请参阅语法手册。\", \"title\": \"talib指标库\"}], \"desc\": \"在```JavaScript```、```Python```、```C++```语言编写的策略中，需要在策略主循环中调用```Sleep()```函数。回测时用于控制回测的速度，实盘时用于控制策略轮询的时间间隔，从而控制访问交易所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\": \"void onTick() {\\n Log(exchange.GetTicker());\\n}\\n\\nvoid main() {\\n while(true) {\\n onTick();\\n Sleep(60000);\\n }\\n}\", \"lang\": \"cpp\"}], \"value\": \"加密货币策略基本框架范例：\"}, {\"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\": \"void onTick() {\\n exchange.Buy(100, 1);\\n}\\n\\nvoid main() {\\n while(true) {\\n onTick();\\n Sleep(1000);\\n }\\n}\", \"lang\": \"cpp\"}], \"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\": \"void onTick() {\\n Log(\\\"K-line updated, new BAR generated\\\");\\n}\\n\\nvoid main() {\\n auto exName = exchange.GetName();\\n if (exName.find(\\\"Futures_\\\") != std::string::npos) {\\n exchange.SetContractType(\\\"swap\\\");\\n }\\n\\n Record lastBar;\\n lastBar.Time = 0;\\n while (true) {\\n auto r = _C(exchange.GetRecords);\\n if (r.size() > 0 && r[r.size() - 1].Time != lastBar.Time) {\\n onTick();\\n lastBar.Time = r[r.size() - 1].Time;\\n }\\n Sleep(1000);\\n }\\n}\", \"lang\": \"cpp\"}], \"value\": \"设计一个On Bar架构的策略\"}, {\"value\": \"以下展示所有API接口的速查表，详细的API描述请参考：[发明者量化交易平台API手册](https://www.fmz.com/syntax-guide)。\"}], \"title\": \"策略框架与API函数\"}, {\"_src_hash\": \"809d1963be7cb1accb7f231517922cfa729e74a8ecf122fa1ffd7af121496363\", \"children\": [{\"_src_hash\": \"5247294e6c56e06de54074c26e142deeabcccaa6480714d2983ea0a46bee63ff\", \"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() 调用此方法\\nvoid Test() {\\n Log(\\\"template call\\\");\\n}\", \"lang\": \"cpp\"}], \"value\": \"不同编程语言的模板类库编写格式有所不同，以下是导出函数在模板类库中声明和实现的示例代码：\"}, {\"value\": \"```Blockly可视化```方式编写的策略可通过```JavaScript```语言的模板类库实现类库功能，请使用以下格式编写。\\n\\n```js\\n/*blockly\\n {\\n \\\"type\\\": \\\"ext_testA\\\",\\n \\\"message0\\\": \\\"testA|testA\\\",\\n \\\"template\\\": \\\"function(){return 99;}()\\\",\\n \\\"order\\\": \\\"ORDER_ATOMIC\\\",\\n \\\"output\\\": \\\"Number\\\"\\n },{\\n \\\"type\\\": \\\"ext_MA\\\",\\n \\\"message0\\\": \\\"MA 周期 %1| MA Period %1\\\",\\n \\\"args0\\\": [{\\n \\\"type\\\": \\\"input_value\\\",\\n \\\"check\\\": \\\"Number\\\"\\n }],\\n \\\"template\\\": \\\"(function(){var r = exchange.GetRecords(); return (!r || r.length < %1) ? false : TA.MA(r, %1); })()\\\",\\n \\\"order\\\": \\\"ORDER_ATOMIC\\\",\\n \\\"output\\\": null,\\n \\\"colour\\\": 85\\n }\\n*/\\n```\"}], \"title\": \"模板类库的导出函数\"}, {\"_src_hash\": \"c162b427afeefa1165d34e829e7e7dab9545a025233296b93ef1a2941856cd0c\", \"desc\": \"模板类库也可以设置自己的界面参数，模板类库的参数在模板类库代码中以全局变量的形式使用。\\n\\n例如，我们设置了一个模板类库的参数：\\n\\n\\n![模板参数](/upload/asset/2e4ab550b85e6a1cac08e.png)\\n\\n\\n| 策略代码中参数的变量名 | 策略界面上显示的参数名称 | 类型 | 默认值 |\\n| - | - | - | - |\\n| param1 | 模板参数1 | 数字型(number) | 99 |\", \"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\"}, {\"code\": \"void SetParam1(float p1) {\\n param1 = p1;\\n}\\n\\nfloat GetParam1() {\\n Log(\\\"param1:\\\", param1);\\n return param1;\\n}\", \"lang\": \"cpp\"}], \"value\": \"用于测试```param1```参数的模板类库代码：\"}, {\"examples\": [{\"code\": \"function main () {\\n Log(\\\"Calling $.GetParam1:\\\", $.GetParam1())\\n Log(\\\"Calling $.SetParam1:\\\", \\\"#FF0000\\\")\\n $.SetParam1(20)\\n Log(\\\"Calling $.GetParam1:\\\", $.GetParam1())\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n Log(\\\"Calling ext.GetParam1:\\\", ext.GetParam1())\\n Log(\\\"Calling ext.SetParam1:\\\", \\\"#FF0000\\\")\\n ext.SetParam1(20)\\n Log(\\\"Calling ext.GetParam1:\\\", ext.GetParam1())\", \"lang\": \"python\"}, {\"code\": \"void main() {\\n Log(\\\"Calling ext::GetParam1:\\\", ext::GetParam1());\\n Log(\\\"Calling ext::SetParam1:\\\", \\\"#FF0000\\\");\\n ext::SetParam1(20);\\n Log(\\\"Calling ext::GetParam1:\\\", ext::GetParam1());\\n}\", \"lang\": \"cpp\"}], \"value\": \"引用上述模板类库示例的策略代码，使用模板类库的导出函数获取参数```param1```并修改参数```param1```。\"}], \"title\": \"模板类库的参数\"}, {\"_src_hash\": \"7c36c7f9ab41a47ad0fdc24bdae20408883fc51ebc04cfdb93bb6e3453cf6f83\", \"desc\": \"策略引用模板类库时，需要当前登录的发明者量化交易平台账号的策略库中存在可用的模板类库。在[策略编辑页面](https://www.fmz.com/m/add-strategy)的模板栏中勾选需要引用的模板，保存策略后即可完成引用。\\n\\n![模板引用截图](/upload/asset/2e4ee2ec7b3e7b1649af8.png)\", \"title\": \"引用模板类库\"}], \"desc\": \"**模板类库**是发明者量化交易平台中可复用的代码模块，属于策略代码的一种类别。发明者量化交易平台支持模板类库功能的编程语言包括：```JavaScript```、```Python```、```C++```、```Blockly可视化```。创建策略时，如果将类别设置为模板类库，系统会在发明者量化交易平台当前登录账号的策略库中创建一个模板类库。创建后，该类别无法再修改为普通策略。\\n\\n![创建模板类库页面](/upload/asset/2e4c55da99fd457ca94a0.png)\", \"title\": \"模板类库\"}, {\"_src_hash\": \"c18c64e673e154c24c1caa8ad6ef21ce0b8e5034230cabd7276f372c93c79ea2\", \"children\": [{\"_src_hash\": \"0a170933aa7cdb5bb603a488d2d4b2b5ba679e0a41d685fb21e32077b09970ea\", \"desc\": \"| 变量(命名举例) | 描述 | 类型 | 默认值(说明) | 组件配置(说明) | 备注 |\\n| - | - | - | - | - | - |\\n| pNum | 参数pNum的描述 | 数字型(number) | 举例：设置默认值为100，C++策略中为浮点型| 用于设置当前参数绑定的界面控件：组件类型、最小值、最大值、分组、过滤器等 | 参数pNum的备注信息，pNum的值为数值类型 |\\n| pBool | 参数pBool的描述 | 布尔型(true/false) | 使用开关控件设置默认值，不支持选填控件 | 同上 | 参数pBool的备注信息，pBool的值为布尔类型 |\\n| pStr | 参数pStr的描述 | 字符串(string) | 举例：设置默认值为abc | 同上 | 参数pStr的备注信息，pStr的值为字符串类型 |\\n| pCombox | 参数pCombox的描述 | 下拉框(selected) | 设置选项中的一个或多个选项 | 同上 | 参数pCombox的备注信息，pCombox的值可能有多种形式 |\\n| pSecretStr | 参数pSecretStr的描述 | 加密串(string) | 举例：设置默认值为xyz | 同上 | 参数pSecretStr的备注信息，pSecretStr的值为字符串类型 |\\n\\n界面参数在策略编辑页面代码编辑区下方的策略参数区进行设置，需要注意以下几点：\\n1、参数设置的默认值选项中，「选填」控件默认为选填状态，可以更改该控件的状态，将当前参数设置为必填。设置参数为必填后，如果策略在回测或实盘时未设置该参数，则无法进行回测或启动实盘。\\n2、界面参数在策略代码中的变量名不应使用当前编程语言的保留字（关键字）。\\n3、在回测或实盘界面，将鼠标悬停在参数绑定的控件上时，会显示该参数的备注信息。\\n4、参数的「描述」即为参数绑定控件的显示名称。\\n5、参数的「变量」即上表中的：```pNum```、```pBool```、```pStr```、```pCombox```、```pSecretStr```。在策略代码中以全局变量形式存在，因此可以在代码中修改策略参数的值。\\n6、对于「加密串」和「字符串」类型的参数，输入默认值时无需添加引号，所有输入均作为字符串处理。「加密串」参数的使用方式与「字符串」参数相同，但加密字符串会被加密传输，不会以明文形式发送。\\n7、「字符串」类型的参数如果设置为「选填」，当参数绑定的控件中未填写参数时，参数变量的值为**空字符串**；\\n 同理，「数字型」参数的值为**空值**；\\n 同理，「下拉框」参数的值为**空值**；\\n 同理，「加密串」参数的值为**空值**。\\n8、对于下拉框类型的界面参数（例如变量名为```pCombox```），在「组件配置」中未开启「支持多选」时，pCombox的值为当前选中选项的索引或具体数据（当给选项绑定数据时）。\\n 如果开启了「支持多选」，pCombox的值为一个数组，包含所有当前选中选项的索引或具体数据（当给选项绑定数据时）。\", \"title\": \"界面参数种类\"}, {\"_src_hash\": \"a014688a7e6e8af1ec38fe785720608ec009bef0b381db988f0e66dc29cd4f16\", \"desc\": \"策略界面参数的「组件配置」选项用于设置平台上5种参数类型对应的控件，增强功能并简化设计。\\n\\n5种界面参数支持的组件类型：\\n- 数字型（number）参数\\n 支持的组件类型：输入框控件（默认）、时间选择器控件、滑动输入条控件。\\n- 布尔型（true/false）参数\\n 仅支持开关控件（默认）。\\n- 字符串（string）参数\\n 支持的组件类型：输入框控件（默认）、文本框控件、时间选择器控件、颜色选择器控件、币种选择器、交易代码选择器。\\n- 下拉框（selected）参数\\n 支持的组件类型：下拉框控件（默认）、分段控制器控件、币种选择器、交易代码选择器。\\n- 加密串（string）参数\\n 仅支持加密输入框控件（默认）。\\n\\n除了设置界面参数对应的控件类型外，还可以设置界面参数的分组和过滤。\\n- 分组\\n 在组件配置的「分组」输入框中，可以输入一个标签名称，将若干个策略界面参数划分到同一个分组标签中（替代平台旧功能「策略分组」）。\\n- 过滤器\\n 在组件配置的「过滤器」输入框中，可以输入过滤判定的表达式，控制界面参数是否生效（替代平台旧功能「参数依赖」）。\\n 过滤器默认为空，不进行任何参数条件过滤；可以设置：```a > b```、```a == 1```、```a```、```!a```、```a >= 1 && a <= 10```、```a > b```等。当过滤器条件为真时，当前参数可用。\\n - 当某个参数设置了过滤器```a == 1```时，该参数的可用性依赖于参数```a```的取值。当参数```a```等于1时该参数可用，否则该参数不可用。\\n - 当某个参数设置了过滤器```a >= 1 && a <= 10```时，表示过滤条件为：a大于等于1且a小于等于10。符合此条件时参数可用，否则参数不可用。\\n - 当某个参数设置了过滤器```!a```时，表示过滤条件为：非a；a可以是布尔值，也可以是数值（!0表示真值）。\", \"title\": \"组件配置\"}, {\"_src_hash\": \"4ab5006c718f479b3f90b42508dcd7981e11cccfb6eb3f790912d60e0f1be24c\", \"desc\": \"- 回测系统中的参数保存\\n 在回测时如果希望保存策略参数，可以在策略参数修改后点击「保存回测设置」按钮，详情请参考回测系统[「保存回测设置」](/user-guide/回测系统/保存回测设置)。\\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@isShowA |数值A |数字型(number) |2 |\\n |isShowA |是否显示numberA参数 |布尔型(true/false) |false |\\n\\n 设置后的策略参数将以代码形式保存在策略中，例如：\\n\\n ```js\\n /*backtest\\n start: 2020-02-29 00:00:00\\n end: 2020-03-29 00:00:00\\n period: 1d\\n args: [[\\\"number\\\",2],[\\\"string\\\",\\\"Hello FMZ.COM\\\"],[\\\"combox\\\",2],[\\\"bool\\\",false],[\\\"numberA@isShowA\\\",666],[\\\"isShowA\\\",true]]\\n */\\n ```\\n\\n ```python\\n '''backtest\\n start: 2020-02-29 00:00:00\\n end: 2020-03-29 00:00:00\\n period: 1d\\n args: [[\\\"number\\\",2],[\\\"string\\\",\\\"Hello FMZ.COM\\\"],[\\\"combox\\\",2],[\\\"bool\\\",false],[\\\"numberA@isShowA\\\",666],[\\\"isShowA\\\",true]]\\n '''\\n ```\\n\\n ```cpp\\n /*backtest\\n start: 2020-02-29 00:00:00\\n end: 2020-03-29 00:00:00\\n period: 1d\\n args: [[\\\"number\\\",2],[\\\"string\\\",\\\"Hello FMZ.COM\\\"],[\\\"combox\\\",2],[\\\"bool\\\",false],[\\\"numberA@isShowA\\\",666],[\\\"isShowA\\\",true]]\\n */\\n ```\\n- 实盘参数导入导出\\n 运行实盘时如需保存实盘配置的参数数据，可以点击策略实盘页面中的「参数设置」选项，然后点击「导出参数」按钮，导出的策略参数将以```json```文件格式保存。\\n 导出的策略参数配置可以再次导入实盘，点击「导入参数」按钮即可将保存的策略实盘参数导入到当前实盘，导入后点击「更新参数」按钮使配置生效。\", \"title\": \"保存参数设置\"}], \"desc\": \"策略界面上设置的参数在策略代码中以全局变量的形式存在。```JavaScript```、```C++```、```My语言```策略代码可以直接访问和修改策略界面上设置的参数值。```Python```策略在函数中修改全局变量或策略界面参数时需要使用```global```关键字。```PINE```语言使用```input()```函数创建界面参数。```Blockly可视化```方式设计的策略不支持界面参数。\\n\\n![策略参数设置界面](/upload/asset/2e46b5e593de3b2f11445.png)\", \"title\": \"策略参数\"}, {\"_src_hash\": \"70184178561129bbfddaf37ee4be18adc9c541b538c1c265aee8a63436b6e4e1\", \"children\": [{\"_src_hash\": \"f83d46901c3dafee786de7eaec053808549a4661aa225343e9a1afec58b3d624\", \"desc\": \"| 变量(命名举例) | 描述 | 类型 | 默认值(说明) | 组件配置(说明) | 备注 |\\n| - | - | - | - | - | - |\\n| cmdNum | 交互控件cmdNum的描述 | 数字型(number) | 默认值选填，可留空 | 用于设置当前交互项绑定的界面控件的组件类型、最小值、最大值、分组等 | 交互控件cmdNum的备注 |\\n| cmdBool | 交互控件cmdBool的描述 | 布尔型(true/false) | 默认值必填，开启或关闭 | 同上 | 交互控件cmdBool的备注 |\\n| cmdStr | 交互控件cmdStr的描述 | 字符串(string) | 默认值选填，可留空 | 同上 | 交互控件cmdStr的备注 |\\n| cmdCombox | 交互控件cmdCombox的描述 | 下拉框(selected) | 默认值选填，可留空 | 同上 | 交互控件cmdCombox的备注 |\\n| cmdBtn | 交互控件cmdBtn的描述 | 按钮(button) | 按钮控件不绑定输入项 | 同上 | 交互控件cmdBtn的备注 |\\n\\n交互控件触发后发送给策略的消息（字符串）：\\n- 数字型\\n 在交互控件```cmdNum```的输入框中输入交互数据```123```后，点击交互控件cmdNum的按钮。策略程序中的```GetCommand()```函数将收到消息：```cmdNum:123```。\\n- 布尔型\\n 在交互控件```cmdBool```的开关控件上设置为打开，点击交互控件cmdBool的按钮。策略程序中的```GetCommand()```函数将收到消息：```cmdBool:true```。\\n- 字符串\\n 在交互控件```cmdStr```的输入框中输入交互数据```abc```后，点击交互控件cmdStr的按钮。策略程序中的```GetCommand()```函数将收到消息：```cmdStr:abc```。\\n- 下拉框\\n 在交互控件```cmdCombox```的下拉框中选中第二个选项后，点击交互控件cmdCombox的按钮。策略程序中的```GetCommand()```函数将收到消息：```cmdCombox:1```，其中1表示所选选项的索引，第一个选项索引为0，第二个选项索引为1。\\n- 按钮\\n 点击交互控件```cmdBtn```的按钮。策略程序中的```GetCommand()```函数将收到消息：```cmdBtn```。\\n\\n交互控件的应用：动态修改策略参数\\n例如，策略有一个参数为symbol，在策略界面上添加的策略参数也是全局变量，因此这里使用代码中的全局变量作为演示。\\n\\n```js\\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(\\\"Changed symbol parameter to:\\\", arr[1])\\n symbol = arr[1]\\n }\\n }\\n\\n LogStatus(_D(), \\\", Current symbol parameter value:\\\", symbol)\\n Sleep(3000)\\n }\\n}\\n```\\n\\n设置交互控件：\\n\\n/upload/asset/1741a2b35e569c5e07e3.png\", \"title\": \"交互控件种类\"}, {\"_src_hash\": \"bf145f95da9ace16da5e429bb29bf43cee68e7f4330d6e59a4d101741a66d33e\", \"desc\": \"策略交互控件的「组件配置」选项用于设置平台上5种交互控件类型对应的控件，增强功能并简化设计。\\n\\n5种交互控件支持的组件类型：\\n- 数字型(number)交互控件\\n 支持的组件类型：输入框控件（默认）、时间选择器控件、滑动输入条控件。\\n- 布尔型(true/false)交互控件\\n 仅支持开关控件（默认）。\\n- 字符串(string)交互控件\\n 支持的组件类型：输入框控件（默认）、文本框控件、时间选择器控件、颜色选择器控件、币种选择器、交易代码选择器。\\n- 下拉框(selected)交互控件\\n 支持的组件类型：下拉框控件（默认）、分段控制器控件、币种选择器、交易代码选择器。\\n- 按钮(button)交互控件\\n 仅支持按钮控件（默认），无输入项控件。\\n\\n交互控件与界面参数设置相同，均支持分组功能。在组件配置中可进行分组设置。\\n- 分组\\n 在组件配置的「分组」输入框中，可以输入标签名称，将多个策略交互控件划分到同一分组标签下（此功能替代平台原有的「交互控件分组」功能）。\", \"title\": \"组件配置\"}, {\"_src_hash\": \"c92a1c095c4e70381ee236336d99a8838cb6ca05815bcb631d384c393016b310\", \"desc\": \"除了在「策略交互」栏中设计交互控件，还可以在策略状态栏中设计交互控件。目前支持的交互控件类型仅有按钮类型，可以参考[「语法手册」中```LogStatus```函数章节](https://www.fmz.com/syntax-guide#fun_logstatus)。\\n\\n状态栏中的按钮控件可以分为：\\n- 普通按钮控件\\n 数据结构示例：\\n ```json\\n {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"Button 1\\\", \\\"cmd\\\": \\\"button1\\\", \\\"description\\\": \\\"This is the first button\\\"}\\n ```\\n- 带单个输入数据的按钮控件\\n 使用```input```属性设置输入控件选项，数据结构示例：\\n ```json\\n {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"Button 2\\\", \\\"cmd\\\": \\\"button2\\\", \\\"description\\\": \\\"This is the second button\\\", \\\"input\\\": {\\\"name\\\": \\\"Open Quantity\\\", \\\"type\\\": \\\"number\\\", \\\"defValue\\\": 1}}\\n ```\\n\\n ```json\\n {\\n \\\"type\\\": \\\"button\\\",\\n \\\"cmd\\\": \\\"test1\\\",\\n \\\"name\\\": \\\"test1\\\",\\n \\\"input\\\": {\\n \\\"type\\\": \\\"selected\\\",\\n \\\"name\\\": \\\"selected\\\",\\n \\\"label\\\": \\\"Dropdown\\\",\\n \\\"description\\\": \\\"description\\\",\\n \\\"default\\\": 100,\\n \\\"settings\\\": {\\n \\\"multiple\\\": true,\\n \\\"customizable\\\": true,\\n \\\"options\\\":[{\\\"name\\\": \\\"A\\\", \\\"value\\\": 100}, {\\\"name\\\": \\\"B\\\", \\\"value\\\": 200}]\\n }\\n },\\n }\\n ```\\n- 带一组输入数据的按钮控件\\n 使用```group```属性设置一组输入控件的选项，数据结构示例：\\n ```json\\n {\\n \\\"type\\\": \\\"button\\\",\\n \\\"cmd\\\": \\\"open\\\",\\n \\\"name\\\": \\\"Open\\\",\\n \\\"group\\\": [\\n {\\\"name\\\": \\\"orderType\\\", \\\"description\\\": \\\"下单方式|order type\\\", \\\"type\\\": \\\"selected\\\", \\\"defValue\\\": \\\"市价单|挂单\\\"},\\n {\\\"name\\\": \\\"tradePrice@orderType==1\\\", \\\"description\\\": \\\"交易价格|trade price\\\", \\\"type\\\": \\\"number\\\", \\\"defValue\\\": 100},\\n {\\\"name\\\": \\\"orderAmount\\\", \\\"description\\\": \\\"委托数量|order amount\\\", \\\"type\\\": \\\"string\\\", \\\"defValue\\\": 100},\\n {\\\"name\\\": \\\"boolean\\\", \\\"description\\\": \\\"是/否|boolean\\\", \\\"type\\\": \\\"boolean\\\", \\\"defValue\\\": true}\\n ]\\n }\\n ```\\n\\n ```json\\n {\\n \\\"type\\\": \\\"button\\\",\\n \\\"cmd\\\": \\\"test2\\\",\\n \\\"name\\\": \\\"test2\\\",\\n \\\"group\\\": [{\\n \\\"type\\\": \\\"selected\\\",\\n \\\"name\\\": \\\"selected\\\",\\n \\\"label\\\": \\\"Dropdown\\\",\\n \\\"description\\\": \\\"description\\\",\\n \\\"default\\\": 200,\\n \\\"group\\\": \\\"group1\\\",\\n \\\"settings\\\": {\\n \\\"multiple\\\": true,\\n \\\"options\\\":[{\\\"name\\\": \\\"A\\\", \\\"value\\\": 100}, {\\\"name\\\": \\\"B\\\", \\\"value\\\": 200}]\\n }\\n }, {\\n \\\"type\\\": \\\"string\\\",\\n \\\"name\\\": \\\"string\\\",\\n \\\"label\\\": \\\"Input Box\\\",\\n \\\"description\\\": \\\"description\\\",\\n \\\"default\\\": \\\"ABC\\\",\\n \\\"group\\\": \\\"group1\\\"\\n }],\\n }\\n ```\\n\\n将这些按钮控件的JSON数据编码为JSON字符串，然后使用``` ` ```字符包裹，在状态栏中输出。以JavaScript语言为例：\\n\\n```js\\nfunction main() {\\n var btn = {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"Button 1\\\", \\\"cmd\\\": \\\"button1\\\", \\\"description\\\": \\\"This is the first button\\\"}\\n LogStatus(\\\"`\\\" + JSON.stringify(btn) + \\\"`\\\")\\n}\\n```\\n\\n这些按钮控件也可以写入状态栏表格中，详细示例请参阅[语法手册](https://www.fmz.com/syntax-guide#fun_logstatus)。\\n\\n```input```字段结构与```group```字段中单个控件结构一致，以下为详细说明：\\n\\n```desc\\n{\\n \\\"type\\\": \\\"selected\\\", // 控件类型（必填字段），支持设置为：number、string、selected、boolean\\n \\\"name\\\": \\\"test\\\", // 名称（在group中使用时为必填字段）\\n \\\"label\\\": \\\"topic\\\", // 标题（必填字段）\\n \\\"description\\\": \\\"desc\\\", // 组件的提示信息\\n \\\"default\\\": 1, // 默认值；当前JSON结构中如果不设置settings字段，兼容defValue，可以用defValue代替default\\n \\\"filter\\\": \\\"a>1\\\", // 选择器，不设置该字段表示不过滤（显示控件）；设置该字段时，当表达式为真时不过滤（显示控件），当表达式为假时过滤（不显示控件）\\n // 对于选择器，以当前示例中表达式a>1为例，a指的是type=button结构中group字段下name为a的控件值，根据此数值判断是否过滤\\n \\\"group\\\": \\\"group1\\\", // 分组\\n \\\"settings\\\": { ... }, // 组件配置\\n}\\n```\\n\\n组件配置```settings```各字段详细说明：\\n- ```settings.required```：是否必填。\\n- ```settings.disabled```：是否禁用。\\n- ```settings.min```：```type=number```时有效，表示最小值或字符串最小长度。\\n- ```settings.max```：```type=number```时有效，表示最大值或字符串最大长度。\\n- ```settings.step```：```type=number```且```render=slider```时有效，表示步长。\\n- ```settings.multiple```：```type=selected```时有效，表示支持多选。\\n- ```settings.customizable```：```type=selected```时有效，表示支持自定义；用户可以直接在下拉框控件中编辑添加新选项，如果选中新编辑的选项，触发交互时将使用该选项的名称而非选项代表的值。\\n- ```settings.options```：```type=selected```时有效，表示选择器的选项数据格式：```[\\\"Option 1\\\", \\\"Option 2\\\"]```、```[{'name':'xxx','value':0}, {'name':'xxx','value':1}]```。\\n- ```settings.render```：渲染组件类型。\\n ```type=number```时，```settings.render```不设置（默认为数字输入框），可选：```slider```（滑动条）、```date```（时间选择器，返回时间戳）。\\n ```type=string```时，```settings.render```不设置（默认为单行输入框），可选：```textarea```（多行输入）、```date```（时间选择器，返回yyyy-MM-dd hh:mm:ss）、```color```（颜色选择器，返回#FF00FF）。\\n ```type=selected```时，```settings.render```不设置（默认为下拉框），可选：```segment```（分段选择器）。\\n ```type=boolean```时，目前仅有默认复选框。\\n\\n支持双语设置，例如：```'选项｜options'```文本内容会根据当前语言环境自动适配；以```group```字段中单个控件为例，完整示例：\\n\\n```json\\n{\\n type:'selected',\\n name:'test',\\n label:'选项｜options',\\n description:'描述｜description',\\n default:0, // 此处default默认值设置为0，表示{name:'xxx|yyy',value:0}选项中的value值\\n filter:'a>1&&a<10',\\n group:'分组|group',\\n settings:{\\n multiple:true,\\n customizable:true,\\n options:[{name:'xxx|yyy',value:0}]\\n }\\n}\\n```\", \"title\": \"状态栏中的交互控件\"}], \"desc\": \"```JavaScript```、```Python```、```C++```、My语言策略均支持设计交互控件，用于在策略实盘运行时向运行中的策略程序发送交互指令。对于```JavaScript```、```Python```、```C++```语言类型的策略，可在策略代码中使用[```GetCommand()```](https://www.fmz.com/syntax-guide#fun_getcommand)函数获取交互控件产生的消息。\\n\\n![交互控件](/upload/asset/2e4320d0cc33c15eb935d.png)\\n\\n在策略中设计好处理交互控件消息的代码后，实盘运行时使用交互控件可以实现以下功能（但不限于）：\\n- 手动平仓策略持有的头寸。\\n- 动态修改策略参数，无需重启策略实盘。\\n- 切换策略运行逻辑。\\n- 触发打印调试信息或数据，用于测试特定功能。\", \"title\": \"交互控件\"}, {\"_src_hash\": \"b32ddf438ef687f3d9c24f20d047350e8166d1074610a98d3806d80845621635\", \"children\": [{\"_src_hash\": \"466652b411fe968ec4a18bae03da9226b10a26e119745807a8cfa8283a612973\", \"desc\": \"使用```exchange.SetContractType()```函数设置期权合约，不同交易所的期权合约代码格式各不相同。发明者量化交易平台支持以下加密货币期权交易所：\\n\\n- Futures_Deribit\\n 对于```Deribit```交易所，只需调用```exchange.SetContractType()```函数设置期权合约即可。设置期权合约后，调用```GetTicker()```等行情接口时，获取的均为该期权合约的行情数据。\\n 下单使用```exchange.Sell()```、```exchange.Buy()```函数，下单时需注意交易方向，使用```exchange.SetDirection()```设置交易方向。\\n 撤单使用```exchange.CancelOrder()```函数。查询持仓使用```exchange.GetPositions()```函数。\\n\\n 可供参考的策略代码：[Deribit期权测试策略](https://www.fmz.com/strategy/179475)\\n 期权合约代码示例：```BTC-13SEP24-60000-C```、```XRP_USDC-27SEP24-1-C```、```BTC-CS-6SEP24-57000_57500```、```BTC-PCAL-20SEP24_13SEP24-55000```等。\\n- Futures_OKX\\n 设置合约、下单、撤单、查询订单、获取行情等操作与```Deribit```相同，合约代码格式为```BTC-USD-200626-4500-C```。\\n 查询合约相关信息可通过```https://www.okx.com/api/v5/public/instruments```接口实现。\\n\\n 例如查询BTC期权合约信息：\\n ```js\\n function main() {\\n Log(HttpQuery(\\\"https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD\\\"))\\n }\\n ```\\n\\n ```python\\n import json\\n import urllib.request\\n def main():\\n ret = json.loads(urllib.request.urlopen(\\\"https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD\\\").read().decode('utf-8'))\\n Log(ret)\\n ```\\n\\n ```cpp\\n void main() {\\n Log(HttpQuery(\\\"https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD\\\"));\\n }\\n ```\\n- Futures_HuobiDM\\n 火币期权合约代码示例：```BTC-USDT-201225-P-13000```，表示```BTC```合约，行权日为2020年12月25日，期权类型为看跌期权（PUT），行权价格为13000美元。\\n 看涨期权：买方支付的权利金为USDT，使用账户资产中的USDT；卖方保证金为币，使用资产中的币作为担保。\\n 看跌期权：买方支付的权利金为USDT，使用账户资产中的USDT；卖方保证金为USDT，使用资产中的USDT作为担保。\\n- Futures_Bybit\\n 支持Bybit交易所的USDC期权，交易对设置为```ETH_USDC```，调用```exchange.SetContractType()```函数设置期权合约即可。\\n 期权合约代码示例：```ETH-25NOV22-1375-P```。\\n- Futures_Aevo\\n 支持Aevo交易所的USDC期权，期权合约代码示例：```ETH-30JUN23-1600-C```。\\n- Futures_GateIO\\n 支持GATE.IO交易所的USDT期权，期权合约代码示例：```BTC_USDT-20211130-65000-C```。\", \"title\": \"加密货币期权\"}], \"desc\": \"发明者量化交易平台支持加密货币期权交易。\", \"title\": \"期权交易\"}, {\"_src_hash\": \"33ec37f0c095f3382dd803956cde62babb152d3a395142051382929ed4278de3\", \"children\": [], \"desc\": \"1、使用```C++```编写策略与```JavaScript```编写策略的主要区别在于发明者量化交易平台的API函数返回数据的差异，例如```exchange.GetTicker()```函数：\\n- JavaScript\\n ```exchange.GetTicker()```调用成功时返回一个对象，如果调用失败（如交易所服务器问题、网络问题等）返回```null```。\\n\\n ```js\\n function main() {\\n var ticker = exchange.GetTicker()\\n // 判断exchange.GetTicker函数是否调用失败，返回null\\n if (ticker){\\n Log(ticker)\\n }\\n }\\n ```\\n- C++\\n ```exchange.GetTicker()```调用成功时返回一个对象，调用失败时返回的仍然是一个对象。成功调用与失败调用返回的对象通过```Valid```属性来区分。\\n\\n ```cpp\\n void main() {\\n auto ticker = exchange.GetTicker();\\n // 判断exchange.GetTicker()函数是否调用失败，检查返回对象中Valid属性是否为false\\n if (ticker.Valid) {\\n Log(ticker);\\n }\\n }\\n ```\\n2、```C++```策略中的```main()```函数与标准C11中```main()```函数的区别：\\nC11中的C++程序入口函数```main()```返回值为```int```类型，而在FMZ量化的C++策略中，策略的启动函数也是```main()```函数。但这两者并非同一个函数，仅是同名而已。FMZ量化的C++策略中```main()```函数的返回值为```void```类型。\\n\\n```cpp\\nvoid main() {\\n // 使用Test函数测试\\n if (!Test(\\\"c++\\\")) {\\n // 抛出异常，终止程序运行\\n Panic(\\\"请下载最新版本托管者\\\");\\n }\\n\\n // 所有返回的对象使用Valid属性判断是否有效\\n LogProfitReset();\\n LogReset();\\n Log(_N(9.12345, 2));\\n Log(\\\"use _C\\\", _C(exchange.GetTicker), _C(exchange.GetAccount));\\n}\\n```\", \"title\": \"C++策略编写说明\"}, {\"_src_hash\": \"2c39134bee552c10c6d729184cd16fc4e3dd37c93785c0a90f8e6837512775e4\", \"children\": [], \"desc\": \"由于```JavaScript```语言自身的特性（JavaScript语言内置字符串仅支持ASCII与UTF-16编码，为避免数据丢失），当遇到无法编码的字符串时会返回```ArrayBuffer```类型。FMZ量化平台的所有API接口中，可以传入字符串参数的地方均支持传入```ArrayBuffer```类型。\\n\\n以下示例详细说明了这一特性：\\n```js\\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 const inputString = \\\"abc𠮷123\\\"; // 此\\\"𠮷\\\"字符的Unicode码点超出了16位范围\\n // const inputString = \\\"abcG123\\\"; // 如果使用abcG123字符串测试，则变量outputD不会被赋值为ArrayBuffer\\n\\n // 使用Encode函数将inputString编码为十六进制编码\\n const encodedHex = Encode(\\\"raw\\\", \\\"string\\\", \\\"hex\\\", inputString);\\n Log(encodedHex); // 内容为：61 62 63 f0a0aeb7 31 32 33\\n\\n // 使用自定义的stringToHex函数编码，由于无法处理\\\"𠮷\\\"字符，导致十六进制编码错误\\n const manuallyEncodedHex = stringToHex(inputString);\\n Log(manuallyEncodedHex); // 内容为：61 62 63 d842dfb7 31 32 33\\n\\n // 成功从十六进制编码还原为字符串（变量inputString）\\n const decodedString = Encode(\\\"raw\\\", \\\"hex\\\", \\\"string\\\", encodedHex);\\n Log(decodedString);\\n\\n // 无法解码，返回ArrayBuffer，即变量outputD为ArrayBuffer类型\\n const outputD = Encode(\\\"raw\\\", \\\"hex\\\", \\\"string\\\", manuallyEncodedHex);\\n Log(outputD);\\n\\n // 验证返回的ArrayBuffer类型变量outputD\\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); // 61 62 63 d842dfb7 31 32 33\\n}\\n```\", \"title\": \"JavaScript策略编写说明\"}, {\"_src_hash\": \"cb679735be144d3b92d325382d49562d93ddd49ca708724bce816af62326b980\", \"children\": [{\"_src_hash\": \"befe654eda373199b87a1359d59320a22fb477377456688b5e300f863071d73f\", \"children\": [{\"_src_hash\": \"691df4af84cf5b99260fecab6cab96f71e440e99d9ae30e473c8de7c9e7d244e\", \"desc\": \"需要在发明者量化交易平台上配置接入节点。接入节点可以是自建节点或使用第三方服务，例如：```infura```。在发明者量化交易平台的[「交易所」](https://www.fmz.com/m/add-platform)页面，选择协议：**加密货币**，然后选择交易所为```Web3```。\\n\\n配置```Rpc Address```（接入节点的服务地址）和```Private Key```（私钥）。支持私钥本地化部署，详情请参考[「密钥安全性」](/user-guide/密钥安全性)。\", \"title\": \"Web3交易所对象配置\"}, {\"_src_hash\": \"d825bf297711213de229b719a688fa000d03f0148849d07491baf99450e217c3\", \"desc\": \"调用合约时，如果使用标准的```ERC20```方法，则无需注册即可直接调用。调用标准合约以外的方法需要先注册ABI内容：```exchange.IO(\\\"abi\\\", tokenAddress, abiContent)```。\\n\\n获取合约的ABI内容可以通过以下URL获取，仅需提取```result```字段。\\n\\n```url\\nhttps://api.etherscan.io/api?module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45\\n```\", \"title\": \"注册ABI\"}, {\"_src_hash\": \"9cf1c04e90268dbf6a2d01fcc284cb46ab5b13ae5951d7c32d9a294bec556b57\", \"desc\": \"使用```exchange.IO()```函数调用以太坊RPC方法。\\n- 查询钱包中ETH余额\\n ```\\n exchange.IO(\\\"api\\\", \\\"eth\\\", \\\"eth_getBalance\\\", owner, \\\"latest\\\") // owner为具体的钱包地址\\n ```\\n- ETH转账\\n ```\\n exchange.IO(\\\"api\\\", \\\"eth\\\", \\\"send\\\", toAddress, toAmount) // toAddress为接收ETH的钱包地址，toAmount为转账数量\\n ```\\n- 查询Gas价格\\n ```\\n exchange.IO(\\\"api\\\", \\\"eth\\\", \\\"eth_gasPrice\\\")\\n ```\\n- 查询预估Gas费用\\n ```\\n exchange.IO(\\\"api\\\", \\\"eth\\\", \\\"eth_estimateGas\\\", data)\\n ```\", \"title\": \"调用以太坊RPC方法\"}, {\"_src_hash\": \"518fb4c8d625cce5e30f87a946c6a532d0989203cbee331905d79eb07ccc0561\", \"desc\": \"```exchange.IO()```函数封装了```encode```方法，可以将函数调用编码并返回为```hex```字符串格式。具体使用方法可参考平台公开的[「Uniswap V3 交易类库」模板](https://www.fmz.com/strategy/397260)。\\n\\n以下示例展示了如何编码```unwrapWETH9```方法的调用：\\n```js\\nfunction main() {\\n // ContractV3SwapRouterV2 主网地址：0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45\\n // 调用unwrapWETH9方法需要先注册ABI，此处省略注册步骤\\n // \\\"owner\\\"代表钱包地址，需要填写实际地址，1代表解包装数量，将一个WETH解包装为ETH\\n var data = exchange.IO(\\\"encode\\\", \\\"0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45\\\", \\\"unwrapWETH9(uint256,address)\\\", 1, \\\"owner\\\")\\n Log(data)\\n}\\n```\\n\\n在调用```exchange.IO(\\\"encode\\\", ...)```函数时，如果第二个参数（字符串类型）以```0x```开头，表示编码（encode）智能合约上的方法调用。\\n如果不以```0x```开头，则用于编码指定的类型顺序，功能等同于```solidity```中的```abi.encode```，请参考以下示例。\\n\\n```js\\nfunction main() {\\n var x = 10\\n var address = \\\"0x02a5fBb259d20A3Ad2Fdf9CCADeF86F6C1c1Ccc9\\\"\\n var str = \\\"Hello World\\\"\\n var array = [1, 2, 3]\\n var ret = exchange.IO(\\\"encode\\\", \\\"uint256,address,string,uint256[]\\\", x, address, str, array) // uint 即 uint256，FMZ上需要指定类型长度\\n Log(\\\"ret:\\\", ret)\\n /*\\n 000000000000000000000000000000000000000000000000000000000000000a // x\\n 00000000000000000000000002a5fbb259d20a3ad2fdf9ccadef86f6c1c1ccc9 // address\\n 0000000000000000000000000000000000000000000000000000000000000080 // str 的偏移\\n 00000000000000000000000000000000000000000000000000000000000000c0 // array 的偏移\\n 000000000000000000000000000000000000000000000000000000000000000b // str 的长度\\n 48656c6c6f20576f726c64000000000000000000000000000000000000000000 // str 数据\\n 0000000000000000000000000000000000000000000000000000000000000003 // array 的长度\\n 0000000000000000000000000000000000000000000000000000000000000001 // array 第一个数据\\n 0000000000000000000000000000000000000000000000000000000000000002 // array 第二个数据\\n 0000000000000000000000000000000000000000000000000000000000000003 // array 第三个数据\\n */\\n}\\n```\\n\\n支持对元组（tuple）或包含元组的类型顺序进行编码：\\n```js\\nfunction main() {\\n var types = \\\"tuple(a uint256,b uint8,c address),bytes\\\"\\n var ret = exchange.IO(\\\"encode\\\", types, {\\n a: 30,\\n b: 20,\\n c: \\\"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\\\"\\n }, \\\"0011\\\")\\n Log(\\\"encode: \\\", ret)\\n}\\n```\\n\\n该类型顺序由```tuple```、```bytes```组成，因此在调用```exchange.IO()```函数进行```encode```时需要传入两个参数：\\n- 对应tuple类型的变量：\\n ```json\\n {\\n a: 30,\\n b: 20,\\n c: \\\"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\\\"\\n }\\n ```\\n 传入的参数必须与```tuple```的结构、类型保持一致，如```types```参数中定义的形式：```tuple(a uint256,b uint8,c address)```。\\n- 对应bytes类型的变量：\\n ```string\\n \\\"0011\\\"\\n ```\\n\\n支持对数组或包含数组的类型顺序进行编码：\\n```js\\nfunction main() {\\n var path = [\\\"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\\\", \\\"0xdac17f958d2ee523a2206206994597c13d831ec7\\\"] // ETH address, USDT address\\n var ret = exchange.IO(\\\"encode\\\", \\\"address[]\\\", path)\\n Log(\\\"encode: \\\", ret)\\n}\\n```\", \"title\": \"支持encode\"}, {\"_src_hash\": \"2a8342b688d5afa975798759d932b37d484f1b494de5772424843d0c01d515b2\", \"desc\": \"例如在```Uniswap V3```这个去中心化交易所的方法调用时，需要传入兑换路径等参数，就需要使用```encodePacked```操作：\\n```js\\nfunction main() {\\n var fee = exchange.IO(\\\"encodePacked\\\", \\\"uint24\\\", 3000)\\n var tokenInAddress = \\\"0x111111111117dC0aa78b770fA6A738034120C302\\\"\\n var tokenOutAddress = \\\"0x6b175474e89094c44da98b954eedeac495271d0f\\\"\\n var path = tokenInAddress.slice(2).toLowerCase()\\n path += fee + tokenOutAddress.slice(2).toLowerCase()\\n Log(\\\"path:\\\", path)\\n}\\n```\", \"title\": \"支持encodePacked\"}, {\"_src_hash\": \"02ba69acedc72784d0e9c28d83aa0ee8932b773e997f38543155255ea62049e4\", \"desc\": \"对于数据的处理不仅支持编码（encode），还支持解码（decode）。使用```exchange.IO(\\\"decode\\\", types, rawData)```函数进行解码操作。\\n```js\\nfunction main() {\\n // register SwapRouter02 abi\\n var walletAddress = \\\"0x398a93ca23CBdd2642a07445bCD2b8435e0a373f\\\"\\n var routerAddress = \\\"0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45\\\"\\n var abi = `[{\\\"inputs\\\":[{\\\"components\\\":[{\\\"internalType\\\":\\\"bytes\\\",\\\"name\\\":\\\"path\\\",\\\"type\\\":\\\"bytes\\\"},{\\\"internalType\\\":\\\"address\\\",\\\"name\\\":\\\"recipient\\\",\\\"type\\\":\\\"address\\\"},{\\\"internalType\\\":\\\"uint256\\\",\\\"name\\\":\\\"amountOut\\\",\\\"type\\\":\\\"uint256\\\"},{\\\"internalType\\\":\\\"uint256\\\",\\\"name\\\":\\\"amountInMaximum\\\",\\\"type\\\":\\\"uint256\\\"}],\\\"internalType\\\":\\\"struct IV3SwapRouter.ExactOutputParams\\\",\\\"name\\\":\\\"params\\\",\\\"type\\\":\\\"tuple\\\"}],\\\"name\\\":\\\"exactOutput\\\",\\\"outputs\\\":[{\\\"internalType\\\":\\\"uint256\\\",\\\"name\\\":\\\"amountIn\\\",\\\"type\\\":\\\"uint256\\\"}],\\\"stateMutability\\\":\\\"payable\\\",\\\"type\\\":\\\"function\\\"}]`\\n exchange.IO(\\\"abi\\\", routerAddress, abi) // 此处ABI仅包含exactOutput方法的内容，完整的ABI可以在网上搜索获取\\n\\n // encode path\\n var fee = exchange.IO(\\\"encodePacked\\\", \\\"uint24\\\", 3000)\\n var tokenInAddress = \\\"0xc02aaa39b223fe8d0a0e5c4f27ead9083c756cc2\\\"\\n var tokenOutAddress = \\\"0xdac17f958d2ee523a2206206994597c13d831ec7\\\"\\n var path = tokenInAddress.slice(2).toLowerCase()\\n path += fee + tokenOutAddress.slice(2).toLowerCase()\\n Log(\\\"path:\\\", path)\\n\\n var dataTuple = {\\n \\\"path\\\" : path,\\n \\\"recipient\\\" : walletAddress,\\n \\\"amountOut\\\" : 1000,\\n \\\"amountInMaximum\\\" : 1,\\n }\\n // encode SwapRouter02 exactOutput\\n var rawData = exchange.IO(\\\"encode\\\", routerAddress, \\\"exactOutput\\\", dataTuple)\\n Log(\\\"method hash:\\\", rawData.slice(0, 8)) // 09b81346\\n Log(\\\"params hash:\\\", rawData.slice(8))\\n\\n // decode exactOutput params\\n var decodeRaw = exchange.IO(\\\"decode\\\", \\\"tuple(path bytes,recipient address,amountOut uint256,amountInMaximum uint256)\\\", rawData.slice(8))\\n Log(\\\"decodeRaw:\\\", decodeRaw)\\n}\\n```\\n\\n该示例首先在处理```path```参数时执行了```encodePacked```操作，因为后续需要编码的```exactOutput```方法调用需要将```path```作为参数。然后对路由合约的```exactOutput```方法进行编码，该方法仅有一个参数，参数类型为```tuple```类型。\\n```exactOutput```方法名编码后为：```0x09b81346```，使用```exchange.IO(\\\"decode\\\", ...)```方法解码得到的```decodeRaw```与变量```dataTuple```一致。\", \"title\": \"支持decode\"}, {\"_src_hash\": \"3f0d2beb76f22c30e5d45fe55f8d34f5873f71f8c6274469809e2dcb613eb771\", \"desc\": \"支持切换私钥，可以操作多个钱包地址，例如：\\n```js\\nfunction main() {\\n exchange.IO(\\\"key\\\", \\\"Private Key\\\") // \\\"Private Key\\\"代表私钥字符串，需要填写实际的私钥值\\n}\\n```\", \"title\": \"支持切换私钥\"}, {\"_src_hash\": \"689860c5c3058a9d29324260b08ab1dea5d0f5ee7b7652bdb5a842d83ff18076\", \"desc\": \"以下内容是一些智能合约方法的调用示例。\\n- decimals\\n ```decimals```方法是```ERC20```的一个```constant```方法（在FMZ量化策略代码中调用标准ERC20方法时无需注册ABI），不会产生```gas```消耗，可以查询某个```token```的精度数据。\\n ```decimals```方法没有参数，返回值为```token```的精度数据。\\n\\n ```js\\n function main(){\\n var tokenAddress = \\\"0x111111111117dC0aa78b770fA6A738034120C302\\\" // 代币的合约地址，例子中的代币为1INCH\\n Log(exchange.IO(\\\"api\\\", tokenAddress, \\\"decimals\\\")) // 查询，打印1INCH代币的精度指数为18\\n }\\n ```\\n- allowance\\n ```allowance```方法是```ERC20```的一个```constant```方法，不会产生```gas```消耗，可以查询某个```token```对某个合约地址的授权额度。\\n ```allowance```方法需要传入2个参数，第一个参数为钱包地址，第二个参数为被授权的地址。返回值为```token```的授权额度。\\n\\n ```js\\n function main(){\\n // 代币的合约地址，例子中的代币为1INCH\\n var tokenAddress = \\\"0x111111111117dC0aa78b770fA6A738034120C302\\\"\\n var owner = \\\"\\\"\\n var spender = \\\"\\\"\\n\\n // 例如查询得出1000000000000000000，除以该token的精度单位1e18，得出当前交易所对象绑定的钱包给spender地址授权了1个1INCH数量\\n Log(exchange.IO(\\\"api\\\", tokenAddress, \\\"allowance\\\", owner, spender))\\n }\\n ```\\n\\n ```owner```：钱包地址，实际使用时需要填写具体地址。\\n ```spender```：被授权的合约地址，实际使用时需要填写具体地址，例如可以是```Uniswap V3 router v1```地址。\\n- approve\\n ```approve```方法是```ERC20```的一个非```constant```方法，会产生```gas```消耗，用于给某个合约地址授权```token```的操作额度。\\n ```approve```方法需要传入2个参数，第一个参数为被授权的地址，第二个参数为授权的额度。返回值为```txid```。\\n\\n ```js\\n function main(){\\n // 代币的合约地址，例子中的代币为1INCH\\n var tokenAddress = \\\"0x111111111117dC0aa78b770fA6A738034120C302\\\"\\n var spender = \\\"\\\"\\n var amount = \\\"0xde0b6b3a7640000\\\"\\n\\n // 授权量的十六进制字符串: 0xde0b6b3a7640000 , 对应的十进制字符串: 1e18 , 1e18除以该token的精度单位，即1个代币数量 , 所以这里指授权一个代币\\n Log(exchange.IO(\\\"api\\\", tokenAddress, \\\"approve\\\", spender, amount))\\n }\\n ```\\n\\n ```spender```：被授权的合约地址，实际使用时需要填写具体地址，例如可以是```Uniswap V3 router v1```地址。\\n ```amount```：授权数量，这里使用的是十六进制字符串表示。对应的十进制数值为```1e18```，除以示例中的```token```精度单位（即1e18），得出授权了1个```token```。\\n\\n ```exchange.IO()```函数的第三个参数传入方法名```approve```，也可以写成```methodId```的形式，例如：\\\"0x571ac8b0\\\"。也可以写成完整的标准方法名，例如：\\\"approve(address,uint256)\\\"。\\n- multicall\\n ```multicall```方法是```Uniswap V3```的一个非constant方法，会产生```gas```消耗，用于批量兑换代币。\\n ```multicall```方法可能有多种传参方式，具体可以查询包含该方法的ABI，调用该方法之前需要先注册ABI。返回值为```txid```。\\n\\n 具体的```multicall```方法调用示例，可以参考平台公开的[「Uniswap V3 交易类库」模板](https://www.fmz.com/strategy/397260)\\n\\n ```js\\n function main() {\\n var ABI_Route = \\\"\\\"\\n var contractV3SwapRouterV2 = \\\"\\\"\\n var value = 0\\n var deadline = (new Date().getTime() / 1000) + 3600\\n var data = \\\"\\\"\\n exchange.IO(\\\"abi\\\", contractV3SwapRouterV2, ABI_Route)\\n exchange.IO(\\\"api\\\", contractV3SwapRouterV2, \\\"multicall(uint256,bytes[])\\\", value, deadline, data)\\n }\\n ```\\n\\n ```ABI_Route```：Uniswap V3的router v2合约的ABI，需要根据实际情况填写。\\n ```contractV3SwapRouterV2```：Uniswap V3的router v2地址，实际使用时需要填写具体地址。\\n ```value```：转账的ETH数量，如果兑换操作的```tokenIn```代币不是ETH则设置为0，需要根据实际情况填写。\\n ```deadline```：可以设置为```(new Date().getTime() / 1000) + 3600```，表示一小时内有效。\\n ```data```：需要执行的打包操作数据，需要根据实际情况填写。\\n\\n 也可以指定方法调用的```gasLimit/gasPrice/nonce```设置：\\n\\n ```js\\n exchange.IO(\\\"api\\\", contractV3SwapRouterV2, \\\"multicall(uint256,bytes[])\\\", value, deadline, data, {gasPrice: 5000000000, gasLimit: 21000})\\n ```\\n\\n 可以根据具体需求设置```{gasPrice: 5000000000, gasLimit: 21000, nonce: 100}```参数，该参数设置在```exchange.IO()```函数的最后一个参数上。\\n 可以省略其中的```nonce```使用系统默认值，或者不设置```gasLimit/gasPrice/nonce```，全部使用系统默认值。\\n\\n 需要注意示例中的```multicall(uint256,bytes[])```方法的```stateMutability```属性是```payable```，需要传入```value```参数。\\n ```stateMutability\\\":\\\"payable\\\"```属性可以从```ABI```中查看，```exchange.IO()```函数会根据已注册的```ABI```中的```stateMutability```属性判断所需的参数，\\n 如果```stateMutability```属性是```nonpayable```则不需要传入```value```参数。\", \"title\": \"调用智能合约方法\"}, {\"_src_hash\": \"d7ad22b7016feb6e9a2abb004ca3cff63b5b2285619c87cb2e990531e4015b5b\", \"desc\": \"- 获取交易所对象配置的钱包地址\\n ```js\\n function main() {\\n Log(exchange.IO(\\\"address\\\")) // 打印交易所对象配置的私钥对应的钱包地址\\n }\\n ```\\n- 切换区块链RPC节点\\n ```js\\n function main() {\\n var chainRpc = \\\"https://bsc-dataseed.binance.org\\\"\\n\\n // 切换至BSC链，也可使用SetBase函数进行切换\\n e.IO(\\\"base\\\", chainRpc)\\n }\\n ```\", \"title\": \"其它功能调用\"}], \"desc\": \"在发明者量化交易平台，通过```exchange.IO()```函数编写策略代码，实现以太坊链上RPC方法调用和智能合约交互。\", \"title\": \"以太坊\"}, {\"_src_hash\": \"ab3338da0d7a05ecf1ad9cbb223ad7bfafd64212561eb8332c33865699907b97\", \"children\": [{\"_src_hash\": \"7e3bc1c2f271c4e780528631a39999bb59d5d2d5a7830e80a672509e3023c319\", \"desc\": \"配置方式与以太坊交易所对象配置类似，```ChainType```需要选择为```TRON```。```RPC Address```默认为：```grpc.trongrid.io:50051```，即波场官方节点地址。\", \"title\": \"Web3交易所对象配置\"}, {\"_src_hash\": \"1a0d777b53e40c1eb555e85bd51656a4f89265a652d4858091d5c90720aad3a4\", \"desc\": \"默认已注册TRC20的合约ABI，底层封装了自动根据合约地址获取合约ABI的机制。通常情况下无需手动注册ABI，仅在某些合约ABI无法自动获取时才需要手动注册。\\n\\n注册ABI的方式与以太坊一致，例如：\\n```js\\n// USDT合约地址：TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\nlet abi = `[{\\\"constant\\\":true,\\\"inputs\\\":[{\\\"name\\\":\\\"who\\\",\\\"type\\\":\\\"address\\\"}],\\\"name\\\":\\\"balanceOf\\\",\\\"outputs\\\":[{\\\"name\\\":\\\"\\\",\\\"type\\\":\\\"uint256\\\"}],\\\"payable\\\":false,\\\"stateMutability\\\":\\\"view\\\",\\\"type\\\":\\\"function\\\"}]`\\n\\n// 注册 balanceOf 方法\\nexchange.IO(\\\"abi\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\", abi)\\n```\", \"title\": \"注册ABI\"}, {\"_src_hash\": \"afb48bb1743de4c7ee2fcffeaad9b8de2a4233e969b217cc593e44705575c8b8\", \"desc\": \"使用```exchange.IO()```函数调用TRON的RPC方法。对于需要签名的方法，底层已自动封装签名操作。以下列举常用方法，其他方法请参考TRON官方项目文档。\\n- GetAccount\\n ```js\\n exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"GetAccount\\\", \\\"TKCG...\\\") // \\\"TKCG...\\\"为TRON钱包地址，该函数返回\\\"TKCG...\\\"地址的账户信息。\\n ```\\n- GetAccountResource\\n ```js\\n exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"GetAccountResource\\\", \\\"TKCG...\\\") // 获取指定钱包地址的资源，包括能量和带宽。\\n ```\\n- GetContractABI\\n ```js\\n exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"GetContractABI\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\") // 获取 USDT TRC20合约ABI\\n ```\\n- GetAssetIssueByName\\n ```js\\n exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"GetAssetIssueByName\\\", \\\"TRX\\\") // 根据代币名称获取代币资产信息\\n ```\\n- GetNowBlock\\n ```js\\n exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"GetNowBlock\\\") // 获取当前区块信息\\n ```\\n- GetBlockByNum\\n ```js\\n exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"GetBlockByNum\\\", 70624300)\\n ```\\n- GetTransactionByID\\n ```js\\n exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"GetTransactionByID\\\", \\\"05a8fae2cd1cbf36b61d12e219588d25b4826436f055f93388a96e620ec3f3f2\\\") // 根据交易哈希值获取Transaction\\n ```\\n- TRC20ContractBalance\\n ```js\\n exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"TRC20ContractBalance\\\", \\\"TKCG...\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\") // 获取钱包 USDT 余额，注意返回的数据未经精度处理，例如返回数据为：```6890251```，即```6.890251 USDT```。\\n ```\\n- TriggerConstantContract\\n ```js\\n function main() {\\n let ret = exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"TriggerConstantContract\\\", \\\"\\\", \\\"TSUUVjysXV8YqHytSNjfkNXnnB49QDvZpx\\\", \\\"token0()\\\", \\\"\\\") // 调用智能合约的token0()方法，TriggerConstantContract用于调用只读方法\\n let data = exchange.IO(\\\"decode\\\", \\\"address\\\", Encode(\\\"raw\\\", \\\"raw\\\", \\\"hex\\\", ret[\\\"constant_result\\\"][0])) // 解码数据\\n return data // data: 0x891cdb91d149f23b1a45d9c5ca78a88d0cb44c18\\n }\\n ```\\n- TRC20Call\\n ```js\\n function main() {\\n let ret = exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"TRC20Call\\\", \\\"\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\", \\\"0x06fdde03\\\", true, 0) // 使用TRC20Call调用只读方法0x06fdde03\\n let data = Encode(\\\"raw\\\", \\\"raw\\\", \\\"hex\\\", ret.constant_result[0])\\n return exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"ParseTRC20StringProperty\\\", data) // Tether USD\\n }\\n ```\\n- Transfer\\n ```js\\n exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"Transfer\\\", \\\"TWTbn...\\\", \\\"TKCG...\\\", 1000000) // 使用Transfer方法转账TRX，从\\\"TWTbn...\\\"转至\\\"TKCG...\\\"，1000000即1TRX。\\n ```\", \"title\": \"调用TRON的RPC方法\"}, {\"_src_hash\": \"09cfe8288d49bca030d2ddd1a2bc1d5f5564de511861ef2fadd2b4bc9d1024a8\", \"desc\": \"当交易所对象设置为Web3并选择TRON时，编码/解码等操作与以太坊的Web3交易所对象保持一致。\\n- encode：\\n ```js\\n let ret = exchange.IO(\\\"encode\\\", \\\"address\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\")\\n Log(ret) // ret: 000000000000000000000000a614f803b6fd780986a42c78ec9c7f77e6ded13c , 对USDT代币的TRON地址进行编码。\\n ```\\n- decode：\\n ```js\\n let data = \\\"0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000a5465746865722055534400000000000000000000000000000000000000000000\\\"\\n let ret = exchange.IO(\\\"decode\\\", \\\"string\\\", data)\\n Log(ret) // ret: Tether USD , 类似于ParseTRC20StringProperty的功能\\n ```\\n- encodePacked：\\n ```js\\n let ret = exchange.IO(\\\"encodePacked\\\", \\\"address\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\")\\n Log(ret) // ret: a614f803b6fd780986a42c78ec9c7f77e6ded13c\\n ```\", \"title\": \"编码/解码\"}, {\"_src_hash\": \"4c59ffba1d303c77c8adea046577ccf7d060bec211549da7aa019aa5e39351c2\", \"desc\": \"切换方式与Web3以太坊交易所对象保持一致。\", \"title\": \"支持切换私钥\"}, {\"_src_hash\": \"12f86a8168a9f49f6f89824be3007ce8272cbc18c2a2bc1120c4c829844b25c0\", \"desc\": \"TRON上智能合约方法的调用与以太坊基本一致，以下是一个具体示例，演示如何：\\n- 调用智能合约方法，在一次请求中调用多个合约方法：\\n ```js\\n function main() {\\n let usdtAddress = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\" // token usdt contract address\\n let data1 = exchange.IO(\\\"encode\\\", usdtAddress, \\\"name\\\") // call function: name\\n let data2 = exchange.IO(\\\"encode\\\", usdtAddress, \\\"decimals\\\") // call function: decimals\\n let data3 = exchange.IO(\\\"encode\\\", usdtAddress, \\\"balanceOf\\\", \\\"TKCG...\\\") // call function: balanceOf\\n\\n var data = []\\n data.push([usdtAddress, data1])\\n data.push([usdtAddress, data2])\\n data.push([usdtAddress, data3])\\n\\n exchange.IO(\\\"abi\\\", \\\"TGXuuKAb4bnrn137u39EKbYzKNXvdCes98\\\", `[{\\\"inputs\\\":[{\\\"components\\\":[{\\\"internalType\\\":\\\"address\\\",\\\"name\\\":\\\"target\\\",\\\"type\\\":\\\"address\\\"},{\\\"internalType\\\":\\\"bytes\\\",\\\"name\\\":\\\"callData\\\",\\\"type\\\":\\\"bytes\\\"}],\\\"internalType\\\":\\\"struct TronMulticall.Call[]\\\",\\\"name\\\":\\\"calls\\\",\\\"type\\\":\\\"tuple[]\\\"}],\\\"name\\\":\\\"aggregate\\\",\\\"outputs\\\":[{\\\"internalType\\\":\\\"uint256\\\",\\\"name\\\":\\\"blockNumber\\\",\\\"type\\\":\\\"uint256\\\"},{\\\"internalType\\\":\\\"bytes[]\\\",\\\"name\\\":\\\"returnData\\\",\\\"type\\\":\\\"bytes[]\\\"}],\\\"stateMutability\\\":\\\"view\\\",\\\"type\\\":\\\"function\\\"}]`)\\n let ret = exchange.IO(\\\"api\\\", \\\"TGXuuKAb4bnrn137u39EKbYzKNXvdCes98\\\", \\\"aggregate\\\", data)\\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 }\\n ```\\n\\n 输出内容：\\n ```log\\n 信息 balanceOf: 6890251\\n 信息 decimals: 6\\n 信息 name: Tether USD\\n ```\", \"title\": \"调用智能合约方法\"}, {\"_src_hash\": \"01b9161aaee875332b2c13f7a2b847ef9284e128a89f1602010173762a4fd858\", \"desc\": \"- 获取交易所对象配置的钱包地址\\n 与以太坊使用方式一致。\\n- 切换区块链RPC节点\\n 与以太坊使用方式一致。\\n- 计算哈希值\\n ```js\\n let algo = \\\"sign\\\" // algo: 使用的算法、方式\\n let inputFormat = \\\"string\\\" // inputFormat: 输入的格式\\n let outputFormat = \\\"hex\\\" // outputFormat: 输出的格式\\n let data = \\\"txHash\\\" // txHash: 具体哈希值\\n let signature = exchange.IO(\\\"hash\\\", algo, inputFormat, outputFormat, data) // 返回签名数据\\n ```\\n\\n 当algo参数设置为```\\\"sign\\\"```时，表示用于计算签名；设置为其他算法参数时（例如：\\\"sha256\\\"），功能等同于```Encode()```函数。\", \"title\": \"其它功能调用\"}], \"desc\": \"在发明者量化交易平台，通过```exchange.IO()```函数可以实现对波场（TRON）链上gRPC方法和智能合约的调用，从而编写相关策略代码。\", \"title\": \"波场\"}], \"desc\": \"发明者量化交易平台支持```Web3```相关功能，可轻松接入加密货币市场的```DeFi```交易所。\", \"title\": \"Web3\"}, {\"_src_hash\": \"f98a07f742afe5ba25417c694ea477f75955cc70f18225dd9981a01c8050201b\", \"children\": [{\"_src_hash\": \"12f4c74690aa56eb750520291cea9323ff12ebffe2f14e06115b639e6e15f919\", \"desc\": \"发明者量化的```TA```指标库优化了常用指标算法，支持```JavaScript```、```Python```、```C++```语言的策略调用。[开源TA库代码](https://www.fmz.com/bbs-topic/409)、[发明者量化交易平台API手册](https://www.fmz.com/syntax-guide)。\\n\\n```js\\nfunction main(){\\n // records的长度，当数据长度不足以满足指标函数的参数计算要求时，将返回无效值\\n var records = exchange.GetRecords()\\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```python\\ndef main():\\n r = exchange.GetRecords()\\n macd = TA.MACD(r)\\n atr = TA.ATR(r, 14)\\n Log(macd[0][-1], macd[1][-1], macd[2][-1])\\n Log(atr[-1])\\n```\\n\\n```cpp\\nvoid main() {\\n auto r = exchange.GetRecords();\\n auto macd = TA.MACD(r);\\n auto atr = TA.ATR(r, 14);\\n Log(macd[0][macd[0].size() - 1], macd[1][macd[1].size() - 1], macd[2][macd[2].size() - 1]);\\n Log(atr[atr.size() - 1]);\\n}\\n```\", \"title\": \"TA指标库\"}, {\"_src_hash\": \"4fc0a10436e42c6e01c767e10334c2e4bde89b07ce1168262f043cf1158a3f40\", \"desc\": \"以下是```CCI```指标调用示例代码，更多talib指标函数请参阅[发明者量化交易平台API手册](https://www.fmz.com/syntax-guide)\\n\\n```js\\nfunction main() {\\n var records = exchange.GetRecords()\\n var cci = talib.CCI(records, 14)\\n Log(cci)\\n}\\n```\\n\\n```python\\n# Python需要单独安装talib库\\n\\nimport talib\\n\\ndef main():\\n records = exchange.GetRecords()\\n # 14这个参数可以缺省\\n cci = talib.CCI(records.High, records.Low, records.Close, 14)\\n Log(cci)\\n```\\n\\n```cpp\\nvoid main() {\\n auto records = exchange.GetRecords();\\n auto cci = talib.CCI(records, 14);\\n Log(cci);\\n}\\n```\", \"title\": \"talib指标库\"}, {\"_src_hash\": \"af19c1f5f189effdfc7009edfea779def06a0234c057a9bc5c9840a93bab1cce\", \"desc\": \"- http://mikemcl.github.io/decimal.js/\\n ```javascript\\n // 解决JavaScript语言数值计算时的精度问题\\n function main() {\\n var x = -1.2\\n var a = Decimal.abs(x)\\n var b = new Decimal(x).abs()\\n Log(a.equals(b)) // true\\n\\n var y = 2.2\\n var sum = Decimal.add(x, y)\\n Log(sum.equals(new Decimal(x).plus(y))) // true\\n }\\n ```\\n- http://underscorejs.org/\\n ```javascript\\n function main() {\\n var sum = _.reduce([1, 2, 3], function(memo, num){return memo + num}, 0)\\n Log(sum)\\n }\\n ```\\n- http://ta-lib.org/\\n ```javascript\\n function main(){\\n var records = exchange.GetRecords()\\n // 打印所有技术指标数据，在发明者量化交易平台上，JavaScript语言策略已内置talib库\\n Log(talib.MACD(records))\\n Log(talib.MACD(records, 12, 26, 9))\\n }\\n ```\\n- 动态加载JavaScript库\\n 如需使用其他第三方JavaScript库，可通过以下方式动态加载：\\n ```javascript\\n function 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\": \"JavaScript库\"}, {\"_src_hash\": \"43734f480864f5eb43bb8fc3f800a17dd3501fe057a01165ebd501d7cdd15264\", \"desc\": \"- https://nlohmann.github.io/json/\\n ```cpp\\n void main() {\\n json table = R\\\"({\\\"type\\\": \\\"table\\\", \\\"title\\\": \\\"Position Info\\\", \\\"cols\\\": [\\\"Column 1\\\", \\\"Column 2\\\"], \\\"rows\\\": [[\\\"abc\\\", \\\"def\\\"], [\\\"ABC\\\", \\\"support color #ff0000\\\"]]})\\\"_json;\\n LogStatus(\\\"`\\\" + table.dump() + \\\"`\\\");\\n LogStatus(\\\"First line message\\\\n`\\\" + table.dump() + \\\"`\\\\nThird line message\\\");\\n json arr = R\\\"([])\\\"_json;\\n arr.push_back(table);\\n arr.push_back(table);\\n LogStatus(\\\"`\\\" + arr.dump() + \\\"`\\\");\\n\\n table = R\\\"({\\n \\\"type\\\" : \\\"table\\\",\\n \\\"title\\\" : \\\"Position Operation\\\",\\n \\\"cols\\\" : [\\\"Column 1\\\", \\\"Column 2\\\", \\\"Action\\\"],\\n \\\"rows\\\" : [\\n [\\\"abc\\\", \\\"def\\\", {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"Close\\\"}]\\n ]\\n })\\\"_json;\\n LogStatus(\\\"`\\\" + table.dump() + \\\"`\\\", \\\"\\\\n`\\\" + R\\\"({\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"Close\\\"})\\\"_json.dump() + \\\"`\\\");\\n }\\n ```\", \"title\": \"C++库\"}], \"desc\": \"发明者量化交易平台内置集成了一些常用库。\", \"title\": \"内置库\"}, {\"_src_hash\": \"357ffb6d90813dd3601239055ba9d792bb37b1a04ddc016c04ea94d350347fdf\", \"children\": [{\"_src_hash\": \"5875cab03b69cce21cc99db88ccc2cf866091febcd4c413c581d5465f35004fd\", \"desc\": \"发明者量化交易平台支持扩展API接口的权限管理，可以设置```API KEY```的权限。在平台[账号设置](https://www.fmz.com/m/account)页面的「API接口」选项中，点击「创建新的ApiKey」按钮即可创建扩展```API KEY```。\\n\\n创建```API KEY```时，可在「API权限」输入框中输入```*```符号以开启所有**扩展API接口**权限。如需指定具体接口权限，请输入对应的扩展API函数名，使用英文逗号分隔，例如：```GetRobotDetail,DeleteRobot```，这将授予该```API KEY```调用**获取实盘详细信息**接口和**删除实盘**接口的权限。\\n\\n在```API KEY```管理页面，您还可以对已创建的```API KEY```进行**修改**、**禁用**、**删除**等操作。\", \"title\": \"创建ApiKey\"}, {\"_src_hash\": \"85009569da7b74122d7cdef212b1450fe0aab02c767cebd8e12923c3024d706f\", \"desc\": \"扩展API接口返回的数据结构示例如下：\\n\\n```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n // ...\\n }\\n}\\n```\\n\\n```code```字段表示扩展API接口调用时返回的状态码。\\n\\n| 描述 | 代码 |\\n| - | - |\\n| 执行成功 | 0 |\\n| 错误的API KEY | 1 |\\n| 错误的签名 | 2 |\\n| Nonce错误 | 3 |\\n| 方法不正确 | 4 |\\n| 参数不正确 | 5 |\\n| 内部未知错误 | 6 |\", \"title\": \"扩展API接口返回码\"}, {\"_src_hash\": \"8b8ed2d79af6d486e83a8209f977049bc1a1aed8f8f404d13d1a8d0312db303d\", \"desc\": \"```GetRobotList```接口、```GetRobotDetail```接口、```GetRobotLogs```接口返回的数据中```status```字段为：实盘状态码。\\n\\n- 正常启动\\n | 状态 | 代码 |\\n | - | - |\\n | 空闲中 | 0 |\\n | 运行中 | 1 |\\n | 停止中 | 2 |\\n | 已退出 | 3 |\\n | 被停止 | 4 |\\n | 策略有错误 | 5 |\\n- 异常\\n | 状态 | 代码 |\\n | - | - |\\n | 策略已过期，请联系作者重新购买 | -1 |\\n | 未找到托管者 | -2 |\\n | 策略编译错误 | -3 |\\n | 实盘已处于运行状态 | -4 |\\n | 余额不足 | -5 |\\n | 策略并发数超限 | -6 |\", \"title\": \"实盘状态码\"}, {\"_src_hash\": \"48badd3c4a451433db2286ec098c63d862f05d127f6527b96036b8fa69f5b14a\", \"children\": [{\"_src_hash\": \"b9285b31c8fc876972178028742c0689efc89eb2964ed8bcc3c1db1d11f58696\", \"desc\": \"使用```md5```加密方式进行验证，以下是```Python```、```Golang```语言的调用示例：\\n\\n```python\\n#!/usr/bin/python\\n# -*- coding: utf-8 -*-\\nimport time\\nimport json\\nimport ssl\\nssl._create_default_https_context = ssl._create_unverified_context\\n\\ntry:\\n import md5\\n import urllib2\\n from urllib import urlencode\\nexcept:\\n import hashlib as md5\\n import urllib.request as urllib2\\n from urllib.parse import urlencode\\n\\naccessKey = '' # your API KEY\\nsecretKey = ''\\n\\ndef api(method, *args):\\n d = {\\n 'version': '1.0',\\n 'access_key': accessKey,\\n 'method': method,\\n 'args': json.dumps(list(args)),\\n 'nonce': int(time.time() * 1000),\\n }\\n\\n d['sign'] = md5.md5(('%s|%s|%s|%d|%s' % (d['version'], d['method'], d['args'], d['nonce'], secretKey)).encode('utf-8')).hexdigest()\\n # 注意：urllib2.urlopen 函数可能存在超时问题，可以设置超时时间，例如：urllib2.urlopen('https://www.fmz.com/api/v1', urlencode(d).encode('utf-8'), timeout=10) 设置超时时间为10秒\\n return json.loads(urllib2.urlopen('https://www.fmz.com/api/v1', urlencode(d).encode('utf-8')).read().decode('utf-8'))\\n\\n# 返回托管者列表\\nprint(api('GetNodeList'))\\n# 返回交易所列表\\nprint(api('GetPlatformList'))\\n# GetRobotList(offset, length, robotStatus, label)，传入-1表示获取全部\\nprint(api('GetRobotList', 0, 5, -1, 'member2'))\\n# CommandRobot(robotId, cmd)向实盘发送命令\\nprint(api('CommandRobot', 123, 'ok'))\\n# StopRobot(robotId)返回实盘状态码\\nprint(api('StopRobot', 123))\\n# RestartRobot(robotId)返回实盘状态码\\nprint(api('RestartRobot', 123))\\n# GetRobotDetail(robotId)返回实盘详细信息\\nprint(api('GetRobotDetail', 123))\\n```\\n\\n```go\\npackage main\\n\\nimport (\\n \\\"fmt\\\"\\n \\\"time\\\"\\n \\\"encoding/json\\\"\\n \\\"crypto/md5\\\"\\n \\\"encoding/hex\\\"\\n \\\"net/http\\\"\\n \\\"io/ioutil\\\"\\n \\\"strconv\\\"\\n \\\"net/url\\\"\\n)\\n\\n// 填写您的FMZ平台API密钥\\nvar apiKey string = \\\"\\\"\\n// 填写您的FMZ平台密钥\\nvar secretKey string = \\\"\\\"\\nvar baseApi string = \\\"https://www.fmz.com/api/v1\\\"\\n\\nfunc api(method string, args ... interface{}) (ret interface{}) {\\n // 处理参数\\n jsonStr, err := json.Marshal(args)\\n if err != nil {\\n panic(err)\\n }\\n\\n params := map[string]string{\\n \\\"version\\\" : \\\"1.0\\\",\\n \\\"access_key\\\" : apiKey,\\n \\\"method\\\" : method,\\n \\\"args\\\" : string(jsonStr),\\n \\\"nonce\\\" : strconv.FormatInt(time.Now().UnixNano() / 1e6, 10),\\n }\\n\\n data := fmt.Sprintf(\\\"%s|%s|%s|%v|%s\\\", params[\\\"version\\\"], params[\\\"method\\\"], params[\\\"args\\\"], params[\\\"nonce\\\"], secretKey)\\n h := md5.New()\\n h.Write([]byte(data))\\n sign := h.Sum(nil)\\n\\n params[\\\"sign\\\"] = hex.EncodeToString(sign)\\n\\n // http request\\n client := &http.Client{}\\n\\n // request\\n urlValue := url.Values{}\\n for k, v := range params {\\n urlValue.Add(k, v)\\n }\\n urlStr := urlValue.Encode()\\n request, err := http.NewRequest(\\\"GET\\\", baseApi + \\\"?\\\" + urlStr, nil)\\n if err != nil {\\n panic(err)\\n }\\n\\n resp, err := client.Do(request)\\n if err != nil {\\n panic(err)\\n }\\n\\n defer resp.Body.Close()\\n\\n b, err := ioutil.ReadAll(resp.Body)\\n if err != nil {\\n panic(err)\\n }\\n\\n ret = string(b)\\n return\\n}\\n\\nfunc main() {\\n settings := map[string]interface{}{\\n \\\"name\\\": \\\"hedge test\\\",\\n \\\"strategy\\\": 104150,\\n // K线周期参数，60表示60秒\\n \\\"period\\\": 60,\\n \\\"node\\\" : 73938,\\n \\\"appid\\\": \\\"member2\\\",\\n \\\"exchanges\\\": []interface{}{\\n map[string]interface{}{\\n \\\"eid\\\": \\\"Exchange\\\",\\n \\\"label\\\" : \\\"test_bjex\\\",\\n \\\"pair\\\": \\\"BTC_USDT\\\",\\n \\\"meta\\\" : map[string]interface{}{\\n // 填写访问密钥\\n \\\"AccessKey\\\": \\\"\\\",\\n // 填写密钥\\n \\\"SecretKey\\\": \\\"\\\",\\n \\\"Front\\\" : \\\"http://127.0.0.1:6666/exchange\\\",\\n },\\n },\\n },\\n }\\n\\n method := \\\"RestartRobot\\\"\\n fmt.Println(\\\"调用接口：\\\", method)\\n ret := api(method, 124577, settings)\\n fmt.Println(\\\"main ret:\\\", ret)\\n}\\n```\", \"title\": \"token验证\"}, {\"_src_hash\": \"79b294ce5d248a892bdd55e5db7c2ce6fbb05af351f441359a08b2f77217c186\", \"desc\": \"支持不使用```token```验证（直接传递```secret_key```验证），可以生成一个用于直接访问的URL。例如直接向实盘发送交互指令的URL，可用于```Trading View```或其他场景的```WebHook```回调。对于扩展API接口```CommandRobot()```函数，不进行```nonce```校验，不限制该接口的访问频率和访问次数。\\n\\n例如：创建的扩展```API KEY```中的```AccessKey```为：```xxx```，```SecretKey```为：```yyy```。访问以下链接即可向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在支持直接验证方式下，可获取请求中的```Body```数据，仅支持```CommandRobot```接口。例如在```Trading View```的```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注意需要按照此格式设置：```%5B186515%2C+%22%22%5D```（编码前为：```[186515, \\\"\\\"]```），其中```186515```是发明者量化交易平台的实盘ID。\\n\\n模拟```Trading View```发送```WebHook URL```警报：\\n```js\\nfunction main() {\\n var options = {\\n method: \\\"POST\\\",\\n body: `{\\\"test\\\": 123}`,\\n headers: {\\\"Content-Type\\\": \\\"application/json\\\"}\\n }\\n\\n // WebHook URL 警报会自动发送POST请求，包含需要的 headers 设置\\n return HttpQuery(\\\"https://www.fmz.com/api/v1?access_key=xxx&secret_key=xxx&method=CommandRobot&args=%5B186515%2C+%22%22%5D\\\", options)\\n}\\n```\\n\\n```Trading View```消息框中设置（要发送的请求中的Body数据）：\\n- JSON格式：\\n\\n https://www.fmz.com/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 https://www.fmz.com/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```、```Golang```语言调用示例：\\n\\n```python\\n#!/usr/bin/python\\n# -*- coding: utf-8 -*-\\n\\nimport json\\nimport ssl\\n\\nssl._create_default_https_context = ssl._create_unverified_context\\n\\ntry:\\n import urllib2\\nexcept:\\n import urllib.request as urllib2\\n\\naccessKey = 'your accessKey'\\nsecretKey = 'your secretKey'\\n\\ndef api(method, *args):\\n return json.loads(urllib2.urlopen(('https://www.fmz.com/api/v1?access_key=%s&secret_key=%s&method=%s&args=%s' % (accessKey, secretKey, method, json.dumps(list(args)))).replace(' ', '')).read().decode('utf-8'))\\n\\n# 如果API KEY没有该接口权限，调用print(api('RestartRobot', 186515)) 会失败，返回数据：{'code': 4, 'data': None}\\n# print(api('RestartRobot', 186515))\\n\\n# 打印Id为：186515的实盘详细信息\\nprint(api('GetRobotDetail', 186515))\\n```\\n\\n```go\\npackage main\\n\\nimport (\\n \\\"fmt\\\"\\n \\\"encoding/json\\\"\\n \\\"net/http\\\"\\n \\\"io/ioutil\\\"\\n \\\"net/url\\\"\\n)\\n\\n// 填写自己的FMZ平台api key\\nvar apiKey string = \\\"your access_key\\\"\\n\\n// 填写自己的FMZ平台secret key\\nvar secretKey string = \\\"your secret_key\\\"\\nvar baseApi string = \\\"https://www.fmz.com/api/v1\\\"\\n\\nfunc api(method string, args ... interface{}) (ret interface{}) {\\n jsonStr, err := json.Marshal(args)\\n if err != nil {\\n panic(err)\\n }\\n\\n params := map[string]string{\\n \\\"access_key\\\" : apiKey,\\n \\\"secret_key\\\" : secretKey,\\n \\\"method\\\" : method,\\n \\\"args\\\" : string(jsonStr),\\n }\\n\\n // http request\\n client := &http.Client{}\\n\\n // request\\n urlValue := url.Values{}\\n for k, v := range params {\\n urlValue.Add(k, v)\\n }\\n urlStr := urlValue.Encode()\\n request, err := http.NewRequest(\\\"GET\\\", baseApi + \\\"?\\\" + urlStr, nil)\\n if err != nil {\\n panic(err)\\n }\\n\\n resp, err := client.Do(request)\\n if err != nil {\\n panic(err)\\n }\\n\\n defer resp.Body.Close()\\n\\n b, err := ioutil.ReadAll(resp.Body)\\n if err != nil {\\n panic(err)\\n }\\n\\n ret = string(b)\\n return\\n}\\n\\nfunc main() {\\n method := \\\"GetRobotDetail\\\"\\n fmt.Println(\\\"调用接口：\\\", method)\\n ret := api(method, 186515)\\n fmt.Println(\\\"main ret:\\\", ret)\\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接口时支持两种验证方式：```token```验证和直接验证。\", \"title\": \"验证方式\"}, {\"_src_hash\": \"ad9e0096dcf9023116e5a6ff409cce99b67d36cd0d8778788e9f061f76e680c7\", \"children\": [{\"_src_hash\": \"95e9a159657a2a301959b892457271e7323baa81dca4a15ab53e01be0e3d1e28\", \"args\": \"无参数\", \"desc\": [\"```GetNodeList```方法用于获取请求中```API KEY```对应的发明者量化交易平台账号下的托管者列表。\"], \"isChildren\": true, \"returns\": \"```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```\\n\\n返回值字段说明（字面意思明显的字段不再赘述）：\\n- all: 当前账户关联的托管者总数。\\n- nodes: 托管者节点的详细信息列表。\\n - build: 版本号。\\n - city: 所在城市。\\n - is_owner: true表示私有托管者，false表示公共托管者。\\n - loaded: 负载量，即当前运行的策略实例数量。\\n - public: 0表示私有托管者，1表示公共托管者。\\n - region: 地理位置。\\n - version: 托管者的详细版本信息。\\n - wd: 离线报警开关，0表示未开启。\\n一键部署的托管者包含额外信息，相关字段以```ecs_```、```unit_```为前缀，记录了一键部署托管者服务器的相关信息（运营商名称、配置、状态等）、计费周期、价格等信息，此处不再详述。\", \"title\": \"GetNodeList\"}, {\"_src_hash\": \"87db7cb356117795639f14aba43830c74f0ed5c8e4145c738afa82ca126289ae\", \"args\": \"无参数\", \"desc\": [\"```GetRobotGroupList```方法用于获取请求中```API KEY```对应的发明者量化交易平台账号下的实盘分组列表。\"], \"isChildren\": true, \"returns\": \"```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```\\n\\n- items: 实盘分组信息。\\n - id: 实盘分组ID。\\n - name: 实盘分组名称。\\n```items```字段仅记录创建的新分组，「默认」分组不包含在```items```中。\", \"title\": \"GetRobotGroupList\"}, {\"_src_hash\": \"672dcb3a434cb9c370792935977e8faf5abb30c76e3d58c4352da7df16a82d28\", \"args\": \"无参数\", \"desc\": [\"```GetPlatformList```方法用于获取请求中```API KEY```对应的发明者量化交易平台账号下已配置的交易所列表。\"], \"isChildren\": true, \"returns\": \"```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\\\", \\\"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```\\n\\n- all: 已配置的交易所对象总数。\\n- platforms: 交易所相关信息。\\n - eid: 发明者量化交易平台上的交易所标识符，在某些配置和参数中需要使用```eid```。\", \"title\": \"GetPlatformList\"}, {\"_src_hash\": \"02c5fdfb88ed577f88eedff98f6bf0f8c60f9a39a4cca5f296d540664b218dee\", \"args\": [{\"info\": \"分页查询的偏移量设置。\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"分页查询的数据长度设置。\", \"name\": \"length\", \"required\": false, \"type\": \"number\"}, {\"info\": \"指定要查询的实盘状态，参考扩展API接口[「实盘状态码」](/user-guide/扩展api接口/实盘状态码)，传入```-1```表示获取全部实盘。\", \"name\": \"robotStatus\", \"required\": false, \"type\": \"number\"}, {\"info\": \"指定要查询的实盘自定义标签，可筛选出包含该标签的所有实盘。\", \"name\": \"label\", \"required\": false, \"type\": \"string\"}, {\"info\": \"查询关键字。\", \"name\": \"keyWord\", \"required\": false, \"type\": \"string\"}], \"desc\": [\"```GetRobotList```方法用于获取请求中```API KEY```对应的发明者量化交易平台账号下的实盘列表。\"], \"isChildren\": true, \"remarks\": [\"以```Python```语言的扩展API接口[「验证方式」](/user-guide/扩展api接口/验证方式)为例：\\n\\n```print(api('GetRobotList'))```：获取全部实盘信息。\\n\\n```print(api('GetRobotList', 'member2'))```：打印所有自定义标签为member2的实盘信息。\\n\\n```print(api('GetRobotList', 0, 5, -1, 'member2'))```：分页查询，从偏移量0开始，最多返回5个标签为member2的实盘。\"], \"returns\": \"```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```\\n\\n- robots: 实盘信息\\n - group_id: 实盘分组ID；如果实盘位于默认分组中，则不包含```group_id```字段。\", \"title\": \"GetRobotList\"}, {\"_src_hash\": \"de594bad5141c1eb9cab82207925759df9b33dc91cfa0250a8ca1bf48bbd2d13\", \"args\": [{\"info\": \"```robotId```参数用于指定接收交互指令的实盘Id。可以使用```GetRobotList```方法获取账号下实盘的信息，其中包含实盘Id。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```cmd```参数是发送给实盘的交互指令。实盘策略中的```GetCommand()```函数会捕获该交互命令，触发策略的交互逻辑。策略代码中的具体交互逻辑实现，请参考[发明者量化交易平台API手册](https://www.fmz.com/syntax-guide#fun_getcommand)中的```GetCommand()```函数说明。\", \"name\": \"cmd\", \"required\": true, \"type\": \"string\"}], \"desc\": [\"```CommandRobot```方法用于向请求中```API KEY```对应的发明者量化交易平台账号下的实盘发送交互命令。接收交互命令的实盘Id由```robotId```参数指定，交互命令由策略中调用的```GetCommand()```函数捕获并返回。\"], \"isChildren\": true, \"remarks\": [\"实盘策略示例（假设该策略实盘正在运行，实盘Id为123）：\\n```js\\nfunction main() {\\n while (true) {\\n var cmd = GetCommand()\\n if (cmd) {\\n Log(cmd)\\n }\\n Sleep(2000)\\n }\\n}\\n```\\n\\n如果使用本章节的Python测试脚本访问发明者量化交易平台的扩展API：```api(\\\"CommandRobot\\\", 123, \\\"test command\\\")```，Id为123的实盘将收到交互指令：```test command```，并通过Log函数输出打印。\"], \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":true,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 交互指令是否发送成功。向未运行的实盘发送指令时，返回数据中的result为false。\", \"title\": \"CommandRobot\"}, {\"_src_hash\": \"47255446ee1a4a6e2ae083c1bf1097334f392c09f713537967a2d91403f47b55\", \"args\": [{\"info\": \"```robotId```参数用于指定要停止的实盘Id。可以通过```GetRobotList```方法获取账号下的实盘信息，其中包含实盘Id。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"```StopRobot```方法用于停止请求中```API KEY```对应的发明者量化交易平台账号下的实盘。停止运行的实盘Id由```robotId```参数指定。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":2,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 实盘状态码，2表示停止中。\", \"title\": \"StopRobot\"}, {\"_src_hash\": \"a2f3156ea44a95c75d1e9f171e712c21ff9e5c979b11dacf4fd0217e55a2e086\", \"args\": [{\"info\": \"```robotId```参数用于指定要重启的实盘ID。可以使用```GetRobotList```方法获取账号下实盘的信息，其中包含实盘ID。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"实盘配置参数，```settings```参数格式如下：\\n\\n```json\\n{\\n \\\"appid\\\":\\\"test\\\",\\n \\\"args\\\":[],\\n \\\"exchanges\\\":[\\n {\\\"pair\\\":\\\"SOL_USDT\\\",\\\"pid\\\":123},\\n {\\\"pair\\\":\\\"ETH_USDT\\\",\\\"pid\\\":456}\\n ],\\n \\\"name\\\":\\\"测试\\\",\\n \\\"node\\\":123,\\n \\\"period\\\":60,\\n \\\"strategy\\\":123\\n}\\n```\\n\\n- appid: 自定义字段\\n 可以定义标签。\\n- args: 策略参数设置\\n 结构为数组，每个元素为一个参数。例如，策略有一个参数```Interval```，重启策略时希望将```Interval```设置为500，则```args```中应包含：```[\\\"Interval\\\", 500]```，即：```\\\"args\\\": [[\\\"Interval\\\", 500]]```。\\n- exchanges: 实盘绑定的交易所对象配置\\n 结构为数组，其中每个元素为一个交易所对象配置。\\n - 可以绑定已在平台配置的交易所对象\\n 使用```pid```配置：```{\\\"pair\\\":\\\"SOL_USDT\\\",\\\"pid\\\":123}```；```pid```可以通过```GetPlatformList```接口查询，返回数据中的```id```字段即为交易所```pid```。\\n - 可以直接传入配置信息，绑定交易所对象\\n 使用```eid```配置：```{\\\"eid\\\":\\\"Huobi\\\",\\\"label\\\":\\\"test Huobi\\\",\\\"meta\\\":{\\\"AccessKey\\\":\\\"123\\\",\\\"SecretKey\\\":\\\"123\\\"},\\\"pair\\\":\\\"BCH_BTC\\\"}```；传入的```API KEY```等敏感信息，发明者量化交易平台不会存储，这些数据将直接转发给托管者程序。如果使用此类配置，每次创建或重启实盘时必须配置该信息。\\n - 可以绑定**通用协议**交易所对象\\n 可以传入配置信息：```{\\\"eid\\\":\\\"Exchange\\\",\\\"label\\\":\\\"test exchange\\\",\\\"pair\\\":\\\"BTC_USDT\\\",\\\"meta\\\":{\\\"AccessKey\\\":\\\"123\\\",\\\"SecretKey\\\":\\\"123\\\",\\\"Front\\\":\\\"http://127.0.0.1:6666/test\\\"}}```。\\n ```label```属性用于为当前**通用协议**接入的交易所对象设置标签，在策略中可以使用```exchange.GetLabel()```函数获取。\\n- name: 策略名称\\n- node: 托管者ID\\n 指定在哪个托管者上运行。如果不设置该属性，系统将自动分配运行。\\n- period: 默认K线周期\\n K线周期参数，60表示60秒。\\n- strategy: 策略ID\\n 可以使用```GetStrategyList```方法获取。\", \"name\": \"settings\", \"required\": false, \"type\": \"JSON对象\"}], \"desc\": [\"```RestartRobot```方法用于重启请求中```API KEY```对应的发明者量化交易平台账号下的实盘。重启的实盘ID由```robotId```参数指定。\"], \"isChildren\": true, \"remarks\": [\"如果实盘是通过扩展API接口创建的，重启时必须使用扩展API接口```RestartRobot```进行重启，并且必须传入```settings```参数。对于在平台页面上创建的实盘，可以通过扩展API接口重启或点击实盘页面上的按钮重启。可以传入```settings```参数或不传入。如果只传入```robotId```参数，则按照实盘的当前设置启动运行。\"], \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":1,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 实盘状态码，1表示运行中。\", \"title\": \"RestartRobot\"}, {\"_src_hash\": \"afc0e3201ac4c1d90575385a280522d5697a6f81c12f1b34b84a77fbede62f34\", \"args\": [{\"info\": \"```robotId```参数用于指定要获取详细信息的实盘ID。可通过```GetRobotList```方法获取账号下的实盘信息，其中包含实盘ID。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"```GetRobotDetail```方法用于获取请求中```API KEY```对应的发明者量化交易平台账号下的实盘详细信息。所要获取的实盘详细信息由```robotId```参数指定。\"], \"isChildren\": true, \"remarks\": [\"```strategy_exchange_pairs```属性说明，以下列数据为例：\\n\\n```plaintext\\n\\\"[60,[44314,42960,15445,14703],[\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\"]]\\\"\\n```\\n\\n其中第一个数据```60```表示实盘设置的默认K线周期为1分钟，即60秒。\\n\\n```[44314,42960,15445,14703]```为实盘配置的交易所对象的```pid```（按添加顺序排列）。\\n\\n```[\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\"]```为实盘配置的交易所对象设置的交易对（按添加顺序与pid一一对应）。\"], \"returns\": \"```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_OKCoin\\\"\\n },\\n \\\"phash\\\": {\\n \\\"123\\\": \\\"ca1aca74b9cf7d8624f2af2dac01e36d\\\"\\n },\\n \\\"plabels\\\": {\\n \\\"123\\\": \\\"OKEX期货 V5\\\"\\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```\\n\\n- charge_time: 下次扣费时间，即当前扣费后的有效截止时间。\\n- charged: 已消耗的时间。\\n- consumed: 已消耗的金额（0.125 USD = 12500000 / 1e8）。\\n- date: 创建日期。\\n- fixed_id: 实盘运行时分配的托管者ID，如果是自动分配，该值为-1。\\n- is_manager: 是否有权限管理该实盘。\\n- is_sandbox: 是否为模拟盘。\\n- name: 实盘名称。\\n- node_id: 托管者ID。\\n- pexchanges: 实盘配置的交易所对象，123为pid，\\\"Futures_OKCoin\\\"为交易所名称。\\n- plabels: 实盘配置的交易所对象的标签信息。\\n- profit: 实盘收益数据。\\n- public: 实盘是否公开。\\n- refresh: 最近活跃时间。\\n- strategy_exchange_pairs: 配置的交易所对象及其交易对信息。\\n- wd: 是否开启离线报警。\", \"title\": \"GetRobotDetail\"}, {\"_src_hash\": \"62917816a6a9e4be397cdaabf008cd4c7f59750d9820a752ee1140a23cd6fee3\", \"desc\": [\"```GetAccount```方法用于获取请求中```API KEY```对应的发明者量化交易平台账号的账户信息。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":{\\n \\\"balance\\\":22944702436,\\n \\\"concurrent\\\":0,\\n \\\"consumed\\\":211092719653,\\n \\\"currency\\\":\\\"USD\\\",\\n \\\"email\\\":\\\"123@qq.com\\\",\\n \\\"openai\\\":false,\\n \\\"settings\\\":null,\\n \\\"sns\\\":{\\\"wechat\\\":true},\\n \\\"uid\\\":\\\"105ea6e51bcc177926a10fdbb7e2a1d6\\\",\\n \\\"username\\\":\\\"abc\\\"\\n },\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- balance: 账户余额\\n 此处的数值采用整数表示以确保精度，实际数值需除以1e8（即10的8次方）进行换算。本例中实际余额为：229.44702436\", \"title\": \"GetAccount\"}, {\"_src_hash\": \"1821f76d0e6eb3e34ea30081406e309834e8db827691a1b21380d46998c368f5\", \"args\": [{\"info\": \"```isSummary```参数用于指定返回的数据是否为摘要信息。\", \"name\": \"isSummary\", \"required\": true, \"type\": \"bool\"}], \"desc\": [\"```GetExchangeList```方法用于获取FMZ量化交易平台支持的交易所列表及其配置信息。\"], \"isChildren\": true, \"returns\": \"```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\\\": \\\"[{\\\\\\\"desc\\\\\\\": \\\\\\\"Access Key\\\\\\\", \\\\\\\"qr\\\\\\\":\\\\\\\"apiKey\\\\\\\",\\\\\\\"required\\\\\\\": true, \\\\\\\"type\\\\\\\": \\\\\\\"string\\\\\\\", \\\\\\\"name\\\\\\\": \\\\\\\"AccessKey\\\\\\\", \\\\\\\"label\\\\\\\": \\\\\\\"Access Key\\\\\\\"}, {\\\\\\\"encrypt\\\\\\\": true, \\\\\\\"qr\\\\\\\":\\\\\\\"secretKey\\\\\\\",\\\\\\\"name\\\\\\\": \\\\\\\"SecretKey\\\\\\\", \\\\\\\"required\\\\\\\": true, \\\\\\\"label\\\\\\\": \\\\\\\"Secret Key\\\\\\\", \\\\\\\"type\\\\\\\": \\\\\\\"password\\\\\\\", \\\\\\\"desc\\\\\\\": \\\\\\\"Secret Key\\\\\\\"}]\\\",\\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```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```\\n\\n- meta: 交易所配置元数据。\", \"title\": \"GetExchangeList\"}, {\"_src_hash\": \"a9522683b8b1a443e9b97a143b75d779f38df4e276e8dc3f26dea4fe33d03ba4\", \"args\": [{\"info\": \"```nid```参数用于指定要删除的托管者ID，可通过```GetNodeList```方法获取账号下托管者的信息。\", \"name\": \"nid\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"```DeleteNode```方法用于删除请求中```API KEY```对应的发明者量化交易平台账号下的托管者节点，删除的托管者节点ID为```nid```参数指定的托管者ID。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":true,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 是否成功删除关联的托管者程序。\", \"title\": \"DeleteNode\"}, {\"_src_hash\": \"af4485e826b58a5e1c1a78c1d018263b0f8f0ff88d06a1f349c44c4bc3484b9c\", \"args\": [{\"info\": \"```robotId```参数用于指定要删除的实盘ID。可以使用```GetRobotList```方法获取账号下实盘的信息，其中包含实盘ID。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```deleteLogs```参数用于设置是否删除实盘日志。如果传入真值（例如：```true```），则删除实盘日志。\", \"name\": \"deleteLogs\", \"required\": true, \"type\": \"bool\"}], \"desc\": [\"```DeleteRobot```方法用于删除请求中```API KEY```对应的发明者量化交易平台账号下的实盘。删除的实盘ID为```robotId```参数指定的实盘ID。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":0,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 实盘删除操作的反馈结果。\\n - 0: 正常删除。\\n - -2: 删除成功，但无法与实盘关联的托管者联系，请手动删除文件 123.db3！\", \"title\": \"DeleteRobot\"}, {\"_src_hash\": \"b716dfc0cbd67e916ba10f8ca1f53ac0a1c5babfd6040140d7e7e810fdfd4033\", \"args\": [{\"info\": \"```offset```参数用于设置查询的偏移量。\", \"name\": \"offset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```length```参数用于设置查询返回的数据条数。\", \"name\": \"length\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```strategyType```参数用于设置要查询的策略类型。\\n\\n- ```strategyType```参数设置为```0```：查询所有策略。\\n\\n- ```strategyType```参数设置为```1```：查询已公开的策略。\\n\\n- ```strategyType```参数设置为```2```：查询待审核的策略。\", \"name\": \"strategyType\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```category```参数用于设置要查询的策略类别。\\n\\n- ```category```参数设置为```-1```：查询所有策略。\\n\\n- ```category```参数设置为```0```：查询通用策略。\", \"name\": \"category\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```needArgs```参数用于设置查询的策略是否需要参数。\\n\\n- ```needArgs```参数设置为```0```：查询所有策略。\", \"name\": \"needArgs\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```language```参数用于设置要查询的策略编程语言。\\n\\n- ```language```参数设置为```0```：JavaScript语言。\\n\\n- ```language```参数设置为```1```：Python语言。\\n\\n- ```language```参数设置为```2```：C++语言。\\n\\n- ```language```参数设置为```3```：可视化策略。\\n\\n- ```language```参数设置为```4```：My语言。\\n\\n- ```language```参数设置为```5```：PINE语言。\", \"name\": \"language\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```kw```参数用于设置查询策略的关键字。\\n\\n- 设置为空字符串表示不使用关键字筛选。\", \"name\": \"kw\", \"required\": true, \"type\": \"string\"}], \"desc\": [\"```GetStrategyList```方法用于获取平台策略信息。\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"all\\\": 123,\\n \\\"strategies\\\": [{\\n \\\"category\\\": 9,\\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\\\": 2,\\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```\\n\\n- all: 符合筛选条件的策略总数。\\n- strategies: 查询返回的策略详细信息。\", \"title\": \"GetStrategyList\"}, {\"_src_hash\": \"80109973f927ea2db77abb665994eb11d75fb5886f90923739e65e908d9992bf\", \"args\": [{\"info\": \"实盘配置参数，```settings```参数格式如下：\\n\\n```json\\n{\\n \\\"appid\\\":\\\"test\\\",\\n \\\"args\\\":[],\\n \\\"exchanges\\\":[\\n {\\\"pair\\\":\\\"SOL_USDT\\\",\\\"pid\\\":123}\\n ],\\n \\\"group\\\":123,\\n \\\"name\\\":\\\"test\\\",\\n \\\"node\\\":123,\\n \\\"period\\\":60,\\n \\\"strategy\\\":123\\n}\\n```\\n\\n- group: 指定实盘分组。\\n- args: 策略参数，如果策略没有参数则为空数组。\\n- exchanges: 交易所对象配置，可参考```RestartRobot```接口。\", \"name\": \"settings\", \"required\": true, \"type\": \"JSON对象\"}], \"desc\": [\"```NewRobot```方法用于创建请求中```API KEY```对应的发明者量化交易平台账号下的实盘。\"], \"isChildren\": true, \"remarks\": [\"```settings```参数中```eid```配置的```\\\"meta\\\":{\\\"AccessKey\\\": \\\"123\\\", \\\"SecretKey\\\": \\\"123\\\"}```等敏感信息，发明者量化交易平台不会存储。这些数据将直接转发给托管者程序，因此每次创建或重启实盘时必须配置此信息。\\n\\n如果创建使用通用协议交易所对象的实盘，在配置```settings```参数时，```exchanges```属性可使用如下设置：\\n```json\\n{\\n \\\"eid\\\": \\\"Exchange\\\",\\n \\\"label\\\": \\\"test\\\",\\n \\\"pair\\\": \\\"ETH_BTC\\\",\\n \\\"meta\\\": {\\n \\\"AccessKey\\\": \\\"123\\\",\\n \\\"SecretKey\\\": \\\"123\\\",\\n \\\"Front\\\": \\\"http://127.0.0.1:6666/test\\\"\\n }\\n}\\n```\\n\\n```label```属性用于为当前通用协议接入的交易所对象设置标签，在策略中可使用```exchange.GetLabel()```函数获取。\"], \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":591988,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: 创建成功，返回实盘ID。\", \"title\": \"NewRobot\"}, {\"_src_hash\": \"37b65858e3a23ad8c80cb491086d8aa179f7820899971f24ea419986536c50dc\", \"args\": [{\"info\": \"调试工具中的设置参数，```settings```配置中包含测试代码，位于```source```属性中。```settings```参数格式如下：\\n\\n```json\\n{\\n \\\"exchanges\\\":[{\\\"pair\\\":\\\"SOL_USDT\\\",\\\"pid\\\":123}],\\n \\\"node\\\":123,\\n \\\"period\\\":60,\\n \\\"source\\\":\\\"function main() {Log(\\\\\\\"Hello FMZ\\\\\\\")}\\\"\\n}\\n```\\n\\n- source: 需要调试的代码。\\n- node: 托管者ID，可指定在哪个托管者上运行实盘。若该值为-1，则表示自动分配。\\n- exchanges: 交易所对象配置，可参考```RestartRobot```接口。\", \"name\": \"settings\", \"required\": true, \"type\": \"JSON对象\"}], \"desc\": [\"```PluginRun```方法用于调用发明者量化交易平台的**调试工具**功能；仅支持JavaScript语言。\"], \"isChildren\": true, \"remarks\": [\"```{\\\"eid\\\": \\\"OKEX\\\", \\\"pair\\\": \\\"ETH_BTC\\\", \\\"meta\\\" :{\\\"AccessKey\\\": \\\"123\\\", \\\"SecretKey\\\": \\\"123\\\"}}```\\n```{\\\"eid\\\": \\\"Huobi\\\", \\\"pair\\\": \\\"BCH_BTC\\\", \\\"meta\\\" :{\\\"AccessKey\\\": \\\"123\\\", \\\"SecretKey\\\": \\\"123\\\"}}```\\n\\n对于```settings```中的```exchanges```属性，调用```PluginRun```方法时只需设置一个（在调试工具页面使用时也仅支持一个交易所对象）。在```settings```中设置2个交易所对象不会引发报错，但在代码中访问第二个交易所对象时将会报错。\"], \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": \\\"{\\\\\\\"logs\\\\\\\":[{\\\\\\\"PlatformId\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"OrderId\\\\\\\":\\\\\\\"0\\\\\\\",\\\\\\\"LogType\\\\\\\":5,\\\\\\\"Price\\\\\\\":0,\\\\\\\"Amount\\\\\\\":0,\\\\\\\"Extra\\\\\\\":\\\\\\\"Hello FMZ\\\\\\\",\\\\\\\"Currency\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Instrument\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Direction\\\\\\\":\\\\\\\"\\\\\\\",\\\\\\\"Time\\\\\\\":1732267473108}],\\\\\\\"result\\\\\\\":\\\\\\\"\\\\\\\"}\\\",\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- result: 调试工具成功执行传入的JavaScript代码后返回的测试结果数据。\", \"title\": \"PluginRun\"}, {\"_src_hash\": \"b267d294391026c7014afa2e5fca5ced5cbcebda2b355c87d9835541e748155f\", \"args\": [{\"info\": \"```robotId```参数用于指定要获取日志信息的实盘ID。可以使用```GetRobotList```方法获取账号下的实盘信息，其中包含实盘ID。\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```logMinId```参数用于指定日志记录的最小ID。\", \"name\": \"logMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```logMaxId```参数用于指定日志记录的最大ID。\", \"name\": \"logMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```logOffset```参数用于设置偏移量。在由```logMinId```和```logMaxId```确定的范围内，根据```logOffset```跳过指定数量的记录，从而确定数据获取的起始位置。\", \"name\": \"logOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```logLimit```参数用于设置从起始位置开始要获取的数据记录条数。\", \"name\": \"logLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```profitMinId```参数用于设置收益日志的最小ID。\", \"name\": \"profitMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```profitMaxId```参数用于设置收益日志的最大ID。\", \"name\": \"profitMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```profitOffset```参数用于设置偏移量，即跳过指定数量的记录作为起始位置。\", \"name\": \"profitOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```profitLimit```参数用于设置从起始位置开始要获取的数据记录条数。\", \"name\": \"profitLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```chartMinId```参数用于设置图表数据记录的最小ID。\", \"name\": \"chartMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```chartMaxId```参数用于设置图表数据记录的最大ID。\", \"name\": \"chartMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```chartOffset```参数用于设置偏移量。\", \"name\": \"chartOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```chartLimit```参数用于设置要获取的记录条数。\", \"name\": \"chartLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```chartUpdateBaseId```参数用于设置查询更新记录的基准ID。\", \"name\": \"chartUpdateBaseId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```chartUpdateDate```参数用于设置数据记录的更新时间戳，系统将筛选出大于此时间戳的记录。\", \"name\": \"chartUpdateDate\", \"required\": true, \"type\": \"number\"}, {\"info\": \"```summaryLimit```参数用于设置要查询的状态栏数据字节数。该参数为整型，用于查询实盘的状态栏数据。\\n\\n设置为0表示不查询状态栏信息；设置为非0值表示要查询的状态栏信息字节数（此接口不限制数据量，可以指定一个较大的summaryLimit参数来获取所有状态栏信息）。状态栏数据存储在返回数据的```summary```字段中。\", \"name\": \"summaryLimit\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"```GetRobotLogs```方法用于获取请求中```API KEY```对应的FMZ量化交易平台账号下的实盘日志信息。要获取日志信息的实盘ID由```robotId```参数指定。\"], \"isChildren\": true, \"remarks\": [\"- 数据库中的策略日志表\\n 返回数据中```logs```的属性值（数组结构）的第一个元素中（日志数据）```Arr```属性值描述如下：\\n\\n ```plaintext\\n \\\"Arr\\\": [\\n [3977, 3, \\\"Futures_OKCoin\\\", \\\"\\\", 0, 0, \\\"Sell(688.9, 2): 20016\\\", 1526954372591, \\\"\\\", \\\"\\\"],\\n [3976, 5, \\\"\\\", \\\"\\\", 0, 0, \\\"OKCoin:this_week 仓位过多, 多: 2\\\", 1526954372410, \\\"\\\", \\\"\\\"]\\n ],\\n ```\\n\\n | id | logType | eid | orderId | price | amount | extra | date | contractType | direction |\\n | - | - | - | - | - | - | - | - | - | - |\\n | 3977 | 3 | \\\"Futures_OKCoin\\\" | \\\"\\\" | 0 | 0 | \\\"Sell(688.9, 2): 20016\\\" | 1526954372591 | \\\"\\\" | \\\"\\\" |\\n | 3976 | 5 | \\\"\\\" | \\\"\\\" | 0 | 0 | \\\"OKCoin:this_week 仓位过多, 多: 2\\\" | 1526954372410 | \\\"\\\" | \\\"\\\" |\\n\\n ```extra```为打印日志的附加信息。\\n\\n ```logType```值对应的日志类型描述如下：\\n\\n | logType: | 0 | 1 | 2 | 3 | 4 | 5 | 6 |\\n | - | - | - | - | - | - | - | - |\\n | logType意义: | BUY | SALE | RETRACT | ERROR | PROFIT | MESSAGE | RESTART |\\n | 中文意义 | 买入订单日志 | 卖出订单日志 | 撤单 | 错误 | 收益 | 消息 | 重启 |\\n\\n- 数据库中的收益图表日志表\\n 该图表日志表数据与策略日志表中的收益日志保持一致。\\n\\n ```plaintext\\n \\\"Arr\\\": [\\n [202, 2515.44, 1575896700315],\\n [201, 1415.44, 1575896341568]\\n ]\\n ```\\n\\n 以其中一条日志数据为例：\\n\\n ```plaintext\\n [202, 2515.44, 1575896700315]\\n ```\\n\\n ```202```为日志ID，```2515.44```为收益数值，```1575896700315```为时间戳。\\n- 数据库中的图表日志表\\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 以其中一条日志数据为例：\\n\\n ```plaintext\\n [23637, 0, \\\"{\\\\\\\"close\\\\\\\":648,\\\\\\\"high\\\\\\\":650.5,\\\\\\\"low\\\\\\\":647,\\\\\\\"open\\\\\\\":650,\\\\\\\"x\\\\\\\":1575960300000}\\\"],\\n ```\\n\\n ```23637```为日志ID，```0```为图表数据系列索引，最后的数据```\\\"{\\\\\\\"close\\\\\\\":648,\\\\\\\"high\\\\\\\":650.5,\\\\\\\"low\\\\\\\":647,\\\\\\\"open\\\\\\\":650,\\\\\\\"x\\\\\\\":1575960300000}\\\"```为日志数据，该条数据为图表上的K线数据。\"], \"returns\": \"```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```\\n\\n- logs: 日志信息；查询出的若干条日志数据存储在Arr字段中。\\n logs中第一个数据结构为实盘数据库中策略日志表的日志记录。\\n logs中第二个数据结构为实盘数据库中收益日志表的日志记录。\\n logs中第三个数据结构为实盘数据库中图表日志表的日志记录。\\n- summary: 实盘状态栏数据。\", \"title\": \"GetRobotLogs\"}], \"desc\": \"- 发明者量化交易平台扩展API接口\\n 在```https://www.fmz.com/api/v1```后直接附加请求的查询参数（以```?```分隔），以下是使用```Python```表达的请求参数：\\n\\n ```json\\n {\\n \\\"version\\\" : \\\"1.0\\\",\\n \\\"access_key\\\": \\\"xxx\\\",\\n \\\"method\\\" : \\\"GetNodeList\\\",\\n \\\"args\\\" : [],\\n \\\"nonce\\\" : 1516292399361,\\n \\\"sign\\\" : \\\"085b63456c93hfb243a757366600f9c2\\\"\\n }\\n ```\\n\\n | 字段 | 说明 |\\n | - | - |\\n | version | 版本号。 |\\n | access_key | AccessKey，在账户管理页面申请。 |\\n | method | 具体调用的方法。 |\\n | args | 调用method方法的参数列表。 |\\n | nonce | 时间戳，单位为毫秒，允许与标准时间戳前后误差1小时，nonce必须大于上一次访问时的nonce值。 |\\n | sign | 签名。 |\\n\\n 各参数以字符```&```分隔，参数名和参数值用符号```=```连接，完整的请求URL（以```method=GetNodeList```为例）：\\n\\n ```plaintext\\n https://www.fmz.com/api/v1?access_key=xxx&nonce=1516292399361&args=%5B%5D&sign=085b63456c93hfb243a757366600f9c2&version=1.0&method=GetNodeList\\n ```\\n\\n 注意：请求参数中不包含```secret_key```参数。\\n- 签名方式\\n 请求参数中```sign```参数的加密方式如下，按照以下格式：\\n\\n ```plaintext\\n version + \\\"|\\\" + method + \\\"|\\\" + args + \\\"|\\\" + nonce + \\\"|\\\" + secretKey\\n ```\\n\\n 拼接字符串后，使用```MD5```加密算法对字符串进行加密，并转换为十六进制字符串，该值作为参数```sign```的值。签名部分可参考```Python```代码扩展API接口[「验证方式」](/user-guide/扩展api接口/验证方式)：\\n\\n ```python\\n # 参数\\n d = {\\n 'version': '1.0',\\n 'access_key': accessKey,\\n 'method': method,\\n 'args': json.dumps(list(args)),\\n 'nonce': int(time.time() * 1000),\\n }\\n\\n # 计算sign签名\\n d['sign'] = md5.md5(('%s|%s|%s|%d|%s' % (d['version'], d['method'], d['args'], d['nonce'], secretKey)).encode('utf-8')).hexdigest()\\n ```\\n- 接口业务错误：\\n - 参数不足：\\n ```json\\n {\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":null,\\n \\\"error\\\":\\\"Params length incorrect\\\"\\n }\\n }\\n ```\", \"title\": \"扩展API接口详解\"}], \"desc\": \"发明者量化平台开放了扩展API接口，支持通过程序化方式调用发明者量化交易平台的各项功能。\", \"title\": \"扩展API接口\"}, {\"_src_hash\": \"0b372586f6cf5e3ba9ba229d7b4b93dbe253d83f88d7c1a3eae84765879d6cc0\", \"children\": [], \"desc\": \"MCP（Model Context Protocol）服务是一个用于模型上下文管理的协议服务，提供统一的接口来管理和交换AI模型的上下文信息。该服务支持多种数据格式和通信协议，确保不同AI系统之间的互操作性和数据一致性。\\n\\n配置及使用场景请参考：\\n\\n[FMZ平台Claude智能交易指南（1）](https://www.fmz.com/digest-topic/10690)\\n\\n[FMZ平台Claude智能交易指南（2）](https://www.fmz.com/digest-topic/10692)\", \"title\": \"MCP 服务\"}, {\"_src_hash\": \"f5a9cbdb8e07871cc1249eb76529e4deea88e17f877806b8800c70e398d78e57\", \"children\": [{\"_src_hash\": \"16ab325cd9ed4aa5fdece2f9cbd6d25bc5d1c55e30be67d1fecc46c725a1a439\", \"desc\": \"原理与**调试工具**相同，将一段代码发送到交易终端页面选定的托管者执行，支持返回图表和表格（调试工具目前也已升级支持此功能）。与**调试工具**功能相同，仅能执行3分钟，该功能不计费。可用于实现辅助手动交易的简单功能，复杂策略仍需运行实盘。\", \"title\": \"插件原理\"}, {\"_src_hash\": \"95e9cb6eb678ef8efb19417588eb41c1a59ea7e5e0ef35a8ffe09b1fd1773df0\", \"desc\": \"创建交易终端插件，可在**新建策略**页面将策略类型设置为「交易插件」。交易插件支持```JavaScript```、```Python```、```C++```、```My语言```。\", \"title\": \"插件编写\"}, {\"_src_hash\": \"670a49f15cd8e5e47d2cbe56b4b45d4344584e3d6bc563a567abdd16dec438d7\", \"desc\": \"插件可以执行代码一段时间，用于执行一些简单的操作，例如冰山委托、挂单、撤单、计算等任务。与调试工具一样使用return返回结果，也可以直接返回图表和表格。以下是几个示例，其他功能可以自行探索。\\n\\n- 返回深度快照\\n ```js\\n // 返回深度的快照\\n function 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 for (var i = 0; i < Math.min(Math.min(d.Asks.length, d.Bids.length), 15); i++) {\\n tbl.rows.push([i, d.Asks[i].Amount, d.Asks[i].Price+'#ff0000', d.Bids[i].Price+'#0000ff', d.Bids[i].Amount])\\n }\\n return tbl\\n }\\n ```\\n\\n ```python\\n def main():\\n tbl = {\\n \\\"type\\\": \\\"table\\\",\\n \\\"title\\\": \\\"深度快照 @ \\\" + _D(),\\n \\\"cols\\\": [\\\"#\\\", \\\"Amount\\\", \\\"Ask\\\", \\\"Bid\\\", \\\"Amount\\\"],\\n \\\"rows\\\": []\\n }\\n d = exchange.GetDepth()\\n for i in range(min(min(len(d[\\\"Asks\\\"]), len(d[\\\"Bids\\\"])), 15)):\\n tbl[\\\"rows\\\"].append([i, d[\\\"Asks\\\"][i][\\\"Amount\\\"], str(d[\\\"Asks\\\"][i][\\\"Price\\\"]) + \\\"#FF0000\\\", str(d[\\\"Bids\\\"][i][\\\"Price\\\"]) + \\\"#0000FF\\\", d[\\\"Bids\\\"][i][\\\"Amount\\\"]])\\n return tbl\\n ```\\n\\n ```cpp\\n void main() {\\n json tbl = R\\\"({\\n \\\"type\\\": \\\"table\\\",\\n \\\"title\\\": \\\"abc\\\",\\n \\\"cols\\\": [\\\"#\\\", \\\"Amount\\\", \\\"Ask\\\", \\\"Bid\\\", \\\"Amount\\\"],\\n \\\"rows\\\": []\\n })\\\"_json;\\n\\n tbl[\\\"title\\\"] = \\\"深度快照 @\\\" + _D();\\n auto d = exchange.GetDepth();\\n for(int i = 0; i < 5; i++) {\\n tbl[\\\"rows\\\"].push_back({format(\\\"%d\\\", i), format(\\\"%f\\\", d.Asks[i].Amount), format(\\\"%f #FF0000\\\", d.Asks[i].Price), format(\\\"%f #0000FF\\\", d.Bids[i].Price), format(\\\"%f\\\", d.Bids[i].Amount)});\\n }\\n\\n LogStatus(\\\"`\\\" + tbl.dump() + \\\"`\\\");\\n // C++ 不支持return json 显示表格，可以创建实盘显示状态栏表格\\n }\\n ```\\n- 绘制跨期价差图\\n ```js\\n // 画跨期差价\\n var 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\\n function 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\\n for(var i = 0; i < Math.min(recordsA.length, recordsB.length); i++){\\n var diff = recordsA[recordsA.length - Math.min(recordsA.length, recordsB.length) + i].Close - recordsB[recordsB.length - Math.min(recordsA.length, recordsB.length) + i].Close\\n chart.series[0].data.push([recordsA[recordsA.length - Math.min(recordsA.length, recordsB.length) + i].Time, diff])\\n }\\n return chart\\n }\\n ```\\n\\n ```python\\n 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\\n def main():\\n exchange.SetContractType(\\\"quarter\\\")\\n recordsA = exchange.GetRecords(PERIOD_M5)\\n exchange.SetContractType(\\\"this_week\\\")\\n recordsB = exchange.GetRecords(PERIOD_M5)\\n\\n for i in range(min(len(recordsA), len(recordsB))):\\n diff = recordsA[len(recordsA) - min(len(recordsA), len(recordsB)) + i].Close - recordsB[len(recordsB) - min(len(recordsA), len(recordsB)) + i].Close\\n chart[\\\"series\\\"][0][\\\"data\\\"].append([recordsA[len(recordsA) - min(len(recordsA), len(recordsB)) + i][\\\"Time\\\"], diff])\\n return chart\\n ```\\n\\n ```cpp\\n // C++ 不支持 return json 结构画图\\n ```\\n\\n**策略广场**中还有其他示例可供参考，例如：逐笔小量买入/卖出。\", \"title\": \"插件用途\"}, {\"_src_hash\": \"15bf48f244d18744f4c3e27ae7351f8d1b836c37967c1cd2276384f3180379c9\", \"desc\": \"- 添加交易终端插件模块\\n 在交易终端页面打开模块添加菜单，当前FMZ账号策略库中的交易终端插件将自动显示在列表中，找到需要添加的插件并点击添加。\\n - 运行插件\\n 点击「执行」按钮，交易终端插件即开始运行。插件不会显示日志信息，但可以返回并显示数据表格。\\n- 插件运行时间\\n 交易终端插件的最长运行时间为3分钟，超过3分钟将自动停止运行。\", \"title\": \"使用方式\"}], \"desc\": \"发明者量化交易平台提供模块化、可定制的[交易终端](https://www.fmz.com/m/trade)页面。用户可以自由添加各种数据模块、交易功能模块，甚至可以编写代码开发自定义模块（交易终端插件）。\\n\\n凭借高度灵活、自由的使用方式，极大地方便了手动交易和半程序化交易用户。交易终端页面上的各种模块均支持拖动、缩放，可以修改模块绑定的交易对、交易所等设置，并可添加多个同类型模块。\\n\\n发明者量化交易平台持续完善交易终端功能，为更好地支持手动交易，推出了交易终端插件功能。\\n\\n交易终端的相关数据存储在托管者程序（robot可执行文件）的运行目录下，具体路径为：```logs/storage/0```。如果交易终端使用的交易所对象采用密钥文件路径方式配置，需要将密钥文件放置在该目录中。\", \"title\": \"交易终端\"}, {\"_src_hash\": \"f9c0cb36aaef36a0897769dfb04a6c331bcc30f1dba65e3ee52701481413ba36\", \"children\": [{\"_src_hash\": \"31099859c85a8c4dac22c478d677c57e7866823d6d71bd676acd8ba82649fc4f\", \"desc\": \"DataData平台提供的数据源实时持续更新，提供多维度、多类型的数据支持。支持使用私有数据作为数据源，支持上传CSV格式文件，并可在「数据探索」页面预览数据。\", \"title\": \"数据源\"}, {\"_src_hash\": \"9964e87b9a34f9992645a83c1e695d256f572ec3d9e4ed2b80c2ba696cce7a9a\", \"desc\": \"支持使用SQL语句查询数据，并可配置查询参数。支持以下数据导出格式：CSV文件、JSON文件。\", \"title\": \"数据查询\"}, {\"_src_hash\": \"e2850bd3285116ef1ba9a0784e1f27834cd6a340217acb580e47d48c5cec157b\", \"desc\": \"如需保存当前数据探索研究的内容，请点击右上角的「保存」按钮，将此SQL查询记录保存至当前FMZ账户「数据探索」的资源列表中（资源列表按钮位于保存按钮左侧）。\", \"title\": \"保存探索研究\"}, {\"_src_hash\": \"3aab7cae94e581bbdd1be5ae612852bc6cb833e077cb3c8a0acdfba5db50af43\", \"desc\": \"分析和查询得出的数据除了可以使用表格形式展示外，还可以适配多种可视化组件，以更加丰富生动的方式展示数据。\", \"title\": \"数据图形化\"}, {\"_src_hash\": \"5c8d7e108fc8680c08a34406afab24ace96e65039514d9e3f4bfc5c3336937f1\", \"desc\": \"支持分享数据探索研究成果，支持多种分享形式：公开链接、嵌入代码（例如在FMZ平台社区帖子中嵌入）、嵌入网页、数据链接、预览图链接。数据探索模块的研究成果除了用于展示外，还可以通过创建的「数据链接」直接为策略提供数据，支持实盘和回测环境。\", \"title\": \"分享研究\"}], \"desc\": \"发明者量化自研的**datadata**平台是一个量化金融数据平台，发明者量化交易平台[数据探索](https://www.fmz.com/m/database)模块已集成**datadata**平台的服务和功能。\\n\\n发明者量化用户无需重新注册**datadata**账号，即可开箱即用。使用户在多维度数据分析、挖掘、数据可视化、交易策略探索等方面更具优势。通过SQL查询分析海量数据，并借助可视化界面进行配置，生成适用于数据分析的多种图表并与团队共享，助您轻松掌握市场动态，精准把握投资机会！使用示例请参考：[数据探索模块专题文章](https://www.fmz.com/digest-topic/10370)。\", \"title\": \"数据探索\"}, {\"_src_hash\": \"271c559898f3b51287c2a05f4a6830095b7faceeaca95b86079a27822da939a5\", \"children\": [{\"_src_hash\": \"ec4b4d56c8254f1061af0497b18469b0e374a9f250d43d61f2728d9aff6c12b1\", \"desc\": \"**下面的\\\"{}\\\"代表占位符，所有表达式大小写不敏感，x代表数据时间序列**\\n\\n- ```abs(x), log(x), sign(x)```字面意思，分别是绝对值、对数、符号函数。\\n\\n以下操作符``` +, -, *, /, >, < ```也符合其标准的含义，```==```：是否相等，```||```：逻辑或，```x ? y : z```：三元条件运算符。\\n\\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,d-2....1(经过归一化处理)。\\n- ```indneutralize(x, g)``` ：针对行业分类g进行中性化处理，目前不支持。\\n- ```ts_{O}(x, d)``` ：对时间序列x的过去d个周期执行O操作(O可具体代表min、max等，详见下文），d会转换为整数。\\n- ```ts_min(x, d)``` ：过去d个周期的最小值。\\n- ```ts_max(x, d)``` ：过去d个周期的最大值。\\n- ```ts_argmax(x, d)``` ： ```ts_max(x, d)```的位置。\\n- ```ts_argmin(x, d)``` ： ```ts_min(x, d)```的位置。\\n- ```ts_rank(x, d)``` ：时间序列x在过去d个周期内的排序（百分位排序）。\\n- ```min(x, d)``` ： ```ts_min(x, d)```。\\n- ```max(x, d)```： ```ts_max(x, d)```。\\n- ```sum(x, d)``` ：过去d个周期的累计和。\\n- ```product(x, d)``` ：过去d个周期的累计积。\\n- ```stddev(x, d)``` ：过去d个周期的标准差。\", \"title\": \"函数和操作符\"}, {\"_src_hash\": \"7902b30b4eaee9530605218d9234abfc242873ba9f689f1ef6fbf4c4682a8796\", \"desc\": \"**输入数据不区分大小写，默认数据为网页上选择的品种，也可直接指定，例如：```binance.ada_bnb```**\\n\\n- ```returns```：收盘价收益率。\\n- ```open, close, high, low, volume```：周期内的开盘价、收盘价、最高价、最低价和成交量。\\n- ```vwap```：成交量加权平均价（暂未实现，当前使用收盘价）。\\n- ```cap```：总市值（暂未实现）。\\n- ```IndClass```：行业分类（暂未实现）。\", \"title\": \"输入数据\"}, {\"_src_hash\": \"76cdb1a745792cdda13efae175370f1396392dbb4d3161a9ec2b543bfe971042\", \"desc\": \"支持一次输出多个结果，使用列表形式表示。例如```[sma(close, 10), sma(high, 30)]```将在图表中绘制两条线。除了输入时间序列数据外，还可以作为简单的计算器使用。\", \"title\": \"其它\"}], \"desc\": \"分析公式参考了```worldquant```公开的[```alpha101```](https://github.com/yli188/WorldQuant_alpha101_code/blob/master/101%20Formulaic%20Alphas.pdf)中的行情计算方法，基本兼容其语法（未实现的功能已说明），并进行了增强。该工具用于快速对时间序列进行运算和验证交易想法。[Alpha因子分析工具页面](https://www.fmz.com/m/alpha)。\", \"title\": \"Alpha因子分析工具\"}, {\"_src_hash\": \"6eaace6109f13f7ef7e2ff3be168f54102a9248dd20504eaad4d35d0474161da\", \"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```FIX```协议插件程序与```REST```协议插件程序的区别仅在于插件程序与交易所接口的交互方式不同。协议插件程序与发明者量化托管者程序的交互方式、数据格式等细节处理完全相同，具体实现可参考上述链接中的示例。\", \"title\": \"通用协议\"}, {\"_src_hash\": \"6266f248a4753affa4904612b653f510bf85992b0e9e6f3540ec23e6b5fceecf\", \"children\": [], \"desc\": \"[调试工具](https://www.fmz.com/m/debug)页面提供了一个用于快速测试实盘代码的免费环境，目前仅支持```JavaScript```语言。\\n\\n![调试工具](/upload/asset/2e48d6d1bc77e46099058.png)\\n\\n使用调试工具测试代码时，代码将直接在指定的托管者上运行，最长运行时间为3分钟。支持调用发明者量化交易平台的所有API函数，但仅支持单个交易所对象。\", \"title\": \"调试工具\"}, {\"_src_hash\": \"8fa1e38256a98cf2047a8353718ceacaa8fd15d2f5645fb172e6f4d083a61737\", \"children\": [], \"desc\": \"![远程编辑截图](/upload/asset/2e4e8975d1e32517fd989.png)\\n\\n支持使用本地编辑器远程同步策略代码至发明者量化交易平台，支持```Sublime Text```/```Atom```/```Vim```/```VSCode```编辑器。\\n\\n![远程编辑支持的编辑器插件](/upload/asset/2e4da2d2a1fc4bc9bbce5.png)\\n\\n在策略编辑页面点击「远程编辑」展开插件下载地址按钮，显示当前策略的远程同步密钥（token）。\\n- 点击「更新密钥」可刷新当前策略的密钥（token）。\\n- 点击「删除密钥」可删除当前策略的密钥（token）。\\n\\n点击页面上的```Sublime Text 3 Plugin```/```Atom Plugin```/```Vim Plugin```/```VSCode Plugin```编辑器插件下载按钮即可跳转至对应的插件项目，不同编辑器的插件安装方式略有差异。\", \"title\": \"远程编辑\"}, {\"_src_hash\": \"5dfc1e4a0c584c9f6eaace703fb5a1ba08aa221a27edc943b5330d4c51d5ee1a\", \"children\": [], \"desc\": \"![策略导入导出截图](/upload/asset/2e52ccf44526f396fb795.png)\\n\\n- 下载源码\\n 导出策略源代码，导出的文件类型取决于策略所使用的编程语言。```JavaScript```策略导出为扩展名为```js```的文件；Python策略导出为扩展名为```py```的文件；C++策略导出为扩展名为```cpp```的文件；My语言（麦语言）策略导出为扩展名为```txt```的文件。\\n 注意：仅导出策略源代码，不包含策略参数、模板引用等配置信息。\\n\\n- 导出策略\\n 导出完整的策略配置，包含策略源代码、参数设置等所有策略相关信息，导出的文件格式为```xml```。\\n\\n- 导入策略\\n 使用「导出策略」功能导出的```xml```文件，在策略编辑页面点击「导入策略」按钮，选择需要导入的```xml```文件即可导入完整的策略配置。\\n 导入完成后需要点击「保存」按钮以保存策略。\", \"title\": \"完整策略的导入与导出\"}, {\"_src_hash\": \"0b569a2015a7de5e1a2f90c42f94c5dac5759c69c403e78fe82af1a0332dc2b4\", \"children\": [], \"desc\": \"策略名称、策略参数的描述都可以使用```中文|英文```的格式编写，让网页自动识别并显示相应语言。在其他使用位置，例如：**策略描述**、**使用说明**等```Markdown```格式的文本中，使用```[trans]中文|英文[/trans]```或```[trans]中文||英文[/trans]```也可以实现自动语言识别效果。切换语言后，需要刷新网页才能生效。在策略代码中，支持字符串输入的函数也支持语言切换，例如```Log()```函数、```LogStatus()```函数等。\\n\\n```js\\nfunction main() {\\n Log(\\\"[trans]日志|log[/trans]\\\")\\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]\\\", {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"平仓|cover\\\", \\\"description\\\": \\\"描述|description\\\"}] // 注意：按钮中不需要添加[trans]标签\\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 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]\\\", {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"平仓|cover\\\", \\\"description\\\": \\\"描述|description\\\"}]\\n ]\\n }\\n LogStatus(\\\"[trans]信息|message[/trans]\\\", \\\"\\\\n`\\\" + json.dumps(table) + \\\"`\\\")\\n raise Exception(\\\"[trans]错误|error[/trans]\\\")\\n```\\n\\n```cpp\\nvoid main() {\\n Log(\\\"[trans]日志|log[/trans]\\\");\\n json 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]\\\", {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"平仓|cover\\\", \\\"description\\\": \\\"描述|description\\\"}]\\n ]\\n })\\\"_json;\\n LogStatus(\\\"[trans]信息|message[/trans]\\\", \\\"\\\\n`\\\" + table.dump() + \\\"`\\\");\\n Panic(\\\"[trans]错误|error[/trans]\\\");\\n}\\n```\", \"title\": \"多语言支持\"}, {\"_src_hash\": \"c12604a532d45d6f9e25024d697be836c231f32ad947295427b9a08aa66840ac\", \"children\": [], \"desc\": \"在发明者量化交易平台的「实盘」页面和「策略库」页面，可以点击右侧的**分组管理**按钮，对策略和实盘进行分组管理。\\n例如，在进行策略分组管理时，可以将**模板类库**归为一组、**JavaScript语言的策略**归为一组、**测试用策略**归为一组。\\n\\n- 策略分组\\n ![策略分组](/upload/asset/2e482ba9b9aa272085d00.png)\\n\\n- 实盘分组\\n ![实盘分组](/upload/asset/2e577d050e817837bbfdf.png)\", \"title\": \"实盘、策略分组\"}, {\"_src_hash\": \"0a8a697808314515d630f706bb58292eb235d0d5aca207c87d928239cd5b1a5d\", \"children\": [{\"_src_hash\": \"027b524e85e5f89d5ec40d2d8f5e64b3f7f3292861475b9bf3c3f64a3218d9f9\", \"desc\": \"登录平台后，点击「控制中心」、「账号设置」跳转到FMZ账户[管理页面](https://www.fmz.com/m/account)。点击「子账户组」可以看到子账户创建页面，在**操作权限**控件中选择所创建子账号可以访问的实盘，在**用户信息**控件中设置子账号的**用户名**和**子账号登录密码**。点击「创建子账户」按钮即可创建一个子账号。创建后的子账号会在当前页面显示，并且可以进行「修改」、「锁定/解锁」、「删除」操作。\\n\\n 子账号仅拥有有限权限，只能查看**操作权限**设置中授权的实盘。对于已授权的实盘，子账号拥有修改参数、停止实盘、重启实盘的权限，但无法修改实盘配置的交易所对象。\\n\\n ![子账号设置](/upload/asset/2e46d725dbe6b471f1b33.png)\\n\\n 子账号的使用场景通常包括：\\n - 1、量化团队管理多个实盘策略时，便于登录和管理。\\n - 2、策略出租时，用于用户的实盘调试工作。\", \"title\": \"子账号\"}, {\"_src_hash\": \"40243e33ec9a3613c27c9be64528aa59de1d453affb62d2f4e36426d66552b94\", \"desc\": \"在发明者量化交易平台[实盘页面](https://www.fmz.com/m/robots)的实盘列表中点击「公开」按钮即可公开展示当前行的实盘。\\n\\n实盘围观目前支持两种方式：\\n- 1、在发明者量化交易平台的[实盘围观](https://www.fmz.com/live)页面公开展示实盘。点击「公开」按钮后选择**公开分享**即可。\\n- 2、创建实盘围观私有链接。\\n 点击「公开」按钮后选择**内部分享**，设置有效期后即可生成私有链接，用于访问该策略实盘的私有围观页面。\", \"title\": \"实盘围观\"}], \"desc\": \"发明者量化交易平台提供多种展示策略实盘运行状态的方式。\", \"title\": \"实盘展示\"}, {\"_src_hash\": \"e5dd4ffa20fe8115b70e53639d11d1698cd833dcb0746c6bc4b1bb890ea67e81\", \"children\": [{\"_src_hash\": \"99af998f1251eb783cef1c4beb761798d2a3a21ce629948a92c33b357a0fb68f\", \"desc\": \"![策略分享](/upload/asset/2e593d57dc36afc004ef6.png)\\n\\n- 公开分享\\n 点击「分享」按钮后会弹出对话框，可以选择「公开分享」。策略将完整地分享到平台的策略广场，任何用户都可以复制该策略。\\n\\n- 内部分享\\n 点击「分享」按钮后会弹出对话框，可以选择「内部分享」。选择分享有效期、分享次数后会生成该策略的**复制页面地址**和**复制码**。可以分发给指定的FMZ平台用户，需要该策略的用户只需使用**复制页面地址**链接，登录**复制页面**后输入复制码即可获取该策略，获取后策略会自动出现在策略库中。\", \"title\": \"策略分享\"}, {\"_src_hash\": \"04d980c301163f82edbfa285fdb4ff044e939a90313749011708d6279d7218d0\", \"desc\": \"![策略出租](/upload/asset/2e4e78f6c46c9dde1ce90.png)\\n\\n- 公开出售\\n 点击「出租」按钮后会弹出对话框，可以选择「公开出售」。策略即可申请上架（需要通过审核）。\\n\\n- 内部出售\\n 点击「出租」按钮后会弹出对话框，可以选择「内部出售」。选择使用天数、最大并发数、注册码数量后，系统会生成该策略的**注册页面地址**和**注册码**。您可以将其分发给指定的FMZ平台用户，需要该策略的用户只需访问**注册页面地址**链接，登录**注册页面**后输入注册码即可获取策略的使用权。策略也会出现在策略库中，但用户只有回测和实盘使用权限，无法查看策略源码等信息。并发实盘个数设置为0时表示不限制并发数量，允许无限制地创建实盘。\", \"title\": \"策略出租\"}], \"desc\": \"在[策略库](https://www.fmz.com/m/strategies)页面，点击策略右侧的「操作项」按钮后，弹出菜单中包含分享和出租操作选项。\\n\\n重要提示：创建和分发策略**注册码**时，请务必仔细确认是「注册码」还是「复制码」，以免误将策略泄露。\", \"title\": \"策略分享与出租\"}, {\"_src_hash\": \"31c0468ded1c36226c9c8e7d3e024bf14b617c6ebb6ae045f569a9f0305e8eb1\", \"children\": [], \"desc\": \"[推送设置页面](https://www.fmz.com/m/account#push)，可以设置开启消息推送。\\n\\n![推送设置](/upload/asset/2e4ad17706aa842c914ce.png)\\n\\n- 移动端（App）\\n 开启移动端 App 推送后，实盘程序发出的推送消息会推送到发明者量化移动端 App。\\n- 邮箱\\n 开启邮箱推送需要验证邮箱，验证通过后即可接收实盘程序发出的推送消息。\\n- WebHook\\n 开启 WebHook 推送，例如设置推送地址为：```http://abc.com/push.php?data={body}```。\\n 当实盘程序发出推送消息时，会向设置的地址```http://abc.com/push.php?data={body}```发送一个请求（仅支持```GET```方法），推送的消息将替换```{body}```占位符。\\n\\n策略中推送消息\\n- JavaScript/TypeScript/Python/C++ 语言\\n 在策略代码中使用```Log()```函数以及其他可以在日志区域输出日志信息的函数，例如：```exchange.CreateOrder()```、```exchange.CancelOrder()```等。\\n 给这些函数传入一个附带参数```\\\"@\\\"```（即：除了必要参数外再增加一个附带参数），例如：```Log(\\\"This is a push message\\\", \\\"@\\\")```，即可将这条输出的日志信息进行推送，平台会根据「推送设置」进行消息推送。\\n- PINE 语言/My 语言\\n 在 PINE 语言/My 语言策略集成的「交易类库」参数中可以开启交易日志推送，触发交易动作后会自动进行推送。\\n- Blockly 可视化\\n 在「工具」一栏中选择**消息推送**模块即可实现指定信息的推送。\\n\\n消息推送有频率限制，具体限制规则如下：在一个实盘 20 秒周期内，只有最后一条推送消息会被保留并进行推送，其他消息将被过滤，不进行推送。\", \"title\": \"实盘消息推送\"}, {\"_src_hash\": \"20784afb4a561cbee7085329d556259b70992e6d8a1cc029a295d8343ba07951\", \"children\": [], \"desc\": \"- 策略静态语法错误\\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 常见的有```Decrypt: Secret key decrypt failed```错误，该错误会导致实盘无法启动。错误原因是修改了发明者量化交易平台的账号密码，导致所有已配置的```API KEY```失效，需要重新配置```API KEY```并重启托管者即可。\\n- Python策略加密问题\\n Python策略出租时，由于平台加密策略的Python版本与策略运行时的Python版本不兼容导致的报错：```ValueError: bad marshal data (unknown type code) ```，将策略运行的Python环境升级或安装为```Python 2.7```、```Python 3.5```、```Python 3.6```中任一策略支持的版本即可。\\n- ```interrupt```错误\\n 该错误是由于程序在执行某个操作（例如访问交易所接口）时，用户点击了实盘页面上的**停止实盘按钮**，实盘停止中断了当前操作而打印的报错信息。该报错不会产生实质影响，仅是一条日志记录。\\n\\n[常见问题汇总](https://www.fmz.com/bbs-topic/1427)。\", \"title\": \"实盘报错、异常退出的常见原因\"}, {\"_src_hash\": \"421d640901ff6b419f8d99cfec350beff66d18c29b07a6b905bfc9ae8aa58b6c\", \"children\": [], \"desc\": \"- 富途证券\\n 支持富途牛牛实盘交易、模拟盘交易，需要下载[```FutuOpenD```](https://www.futunn.com/download/OpenAPI?lang=zh-CN)软件。\\n 使用```FutuOpenD```接入模拟交易时，部分股票代码不支持，因此无法交易，但富途牛牛手机APP可以进行模拟交易。\\n 在发明者量化平台配置交易所对象、运行```FutuOpenD```软件等操作，请参阅[富途证券配置说明文档](https://www.fmz.com/bbs-topic/10185)。\\n\\n - 接口调用频率\\n 对于```GetOrder```、```GetOrders```、```GetPositions```、```GetAccount```函数，默认使用**缓存数据**，因此不限制调用频率。\\n 当有新数据时，```FutuOpenD```会自动更新数据，**缓存数据**也会同步更新。\\n\\n 调用```exchange.IO(\\\"refresh\\\", true)```函数可以禁用缓存。如果**禁用缓存**，则调用频率限制为**每30秒内最多请求10次查询**，超过频率限制会报错。\\n\\n - 股票代码\\n 例如：```600519.SH```\\n - HK 港股\\n - US 美股\\n - SH 沪股\\n - SZ 深股\\n\\n 策略代码中使用```exchange.SetContractType()```函数设置股票代码，例如：\\n\\n ```js\\n function main() {\\n var info = exchange.SetContractType(\\\"600519.SH\\\") // Set to stock 600519.SH (Moutai), account switches to mainland market\\n Log(info)\\n Log(exchange.GetAccount()) // Current stock is Moutai, calling GetAccount function gets account assets for mainland market\\n Log(exchange.GetTicker()) // Get current price information for Moutai stock\\n }\\n ```\\n\\n ```python\\n def main():\\n info = exchange.SetContractType(\\\"600519.SH\\\")\\n Log(info)\\n Log(exchange.GetAccount())\\n Log(exchange.GetTicker())\\n ```\\n\\n ```cpp\\n void main() {\\n auto info = exchange.SetContractType(\\\"600519.SH\\\");\\n Log(info);\\n Log(exchange.GetAccount());\\n Log(exchange.GetTicker());\\n }\\n ```\\n\\n 设置交易方向的函数```exchange.SetDirection```、下单函数```exchange.Buy```/```exchange.Sell```、撤单函数```exchange.CancelOrder```、查询订单函数```exchange.GetOrder```等使用方法均与期货市场相同。\\n\\n - 账户信息数据格式：\\n 使用```TrdMarket```定义市场，用于区分```香港市场```、```美国市场```、```大陆市场```。\\n\\n 摘录自[```Futu API```文档](https://openapi.futunn.com/futu-api-doc/):\\n ```\\n const (\\n TrdMarket_TrdMarket_Unknown TrdMarket = 0 //Unknown market\\n TrdMarket_TrdMarket_HK TrdMarket = 1 //Hong Kong market\\n TrdMarket_TrdMarket_US TrdMarket = 2 //US market\\n TrdMarket_TrdMarket_CN TrdMarket = 3 //Mainland market\\n TrdMarket_TrdMarket_HKCC TrdMarket = 4 //Hong Kong Stock Connect market\\n TrdMarket_TrdMarket_Futures TrdMarket = 5 //Futures market\\n )\\n ```\\n\\n 获取账户信息数据时，```exchange.GetAccount()```函数返回：\\n ```json\\n {\\n \\\"Info\\\": [{\\n \\\"Header\\\": {\\n ... // Omitted\\n \\\"TrdMarket\\\": 1 // Market ID in Info raw data, indicates account assets for Hong Kong market trading\\n },\\n \\\"Funds\\\": { // Account asset information in this market\\n ...\\n }\\n }, ...],\\n \\\"Stocks\\\": 0,\\n \\\"FrozenStocks\\\": 0,\\n \\\"Balance\\\": 1000000, // Asset value in current market\\n \\\"FrozenBalance\\\": 0\\n }\\n ```\\n\\n - ```FutuOpenD```根据登录的**IP**地址进行地区区分\\n 对于非大陆IP地址登录的账户，在获取行情数据时有所限制，具体请查阅```FutuOpenD```（富途）官方文档。\\n- 盈透证券\\n 配置交易所：\\n 使用盈透证券需要在托管者所在系统环境运行「IB Gateway」或「TWS (Trader Workstation)」软件。以「TWS」软件为例，运行「TWS」并登录后，在软件右上角点击配置按钮打开软件配置界面。\\n - 选择：「配置」->「API」->「设置」，不要勾选「只读API」选项，需要勾选「启用ActiveX和套接字客户端」选项，注意配置中的「套接字端口」（TWS默认端口为7496实盘/7497模拟盘）。\\n - 在平台的添加交易所页面「https://www.fmz.com/m/platforms/add」选择**盈透证券(Interactive Brokers)**，配置参数。在「服务器地址」配置项中填写「TWS」软件对应的地址（如127.0.0.1或localhost）和端口即可，例如：```localhost:7496```。\\n\\n 支持市场：\\n - 目前仅支持美股市场，暂不支持其他期货、外汇等市场。\\n - 美股市场股票代码格式示例：\\n 苹果公司(Apple Inc.)在纳斯达克(NASDAQ)交易所的股票代码：```AAPL.US```。\\n 特斯拉公司(Tesla, Inc.)在纳斯达克(NASDAQ)交易所的股票代码：```TSLA.US```。\\n- Futures_Binance\\n 支持币安的中文交易对：\\n\\n ```js\\n function main() {\\n let ticker = exchange.GetTicker(\\\"币安人生_USDT.swap\\\")\\n Log(\\\"ticker:\\\", ticker) // {\\\"Info\\\":{...},\\\"Symbol\\\":\\\"币安人生_USDT.swap\\\",\\\"Open\\\":0.29622,\\\"High\\\":0.31661, ...}\\n }\\n ```\\n\\n 关于币安期货的```exchange.IO()```切换功能（双向持仓、逐仓/全仓、统一账户、STP模式等），请参考{@fun/Trade/exchange.IO exchange.IO}函数文档。\\n- Futures_HuobiDM\\n - 切换地址：\\n 使用```exchange.IO(\\\"base\\\", \\\"https://xxx.xxx.xxx\\\")```或```exchange.SetBase(\\\"https://xxx.xxx.xxx\\\")```切换交易所接口的基地址。\\n\\n 支持火币的中文交易对：\\n\\n ```js\\n function main() {\\n let ticker = exchange.GetTicker(\\\"币安人生_USDT.swap\\\")\\n Log(\\\"ticker:\\\", ticker) // {\\\"Info\\\":{...},\\\"Symbol\\\":\\\"币安人生_USDT.swap\\\",\\\"Open\\\":0.29622,\\\"High\\\":0.31661, ...}\\n }\\n ```\\n\\n 关于火币期货的```exchange.IO()```切换功能（signHost、逐仓/全仓、持仓单向/双向、统一账户等），请参考{@fun/Trade/exchange.IO exchange.IO}函数文档。\\n- Huobi\\n - 切换特殊交易对：\\n 支持火币现货杠杆代币，例如：```LINK*(-3)```，交易所定义的代码为：```link3susdt```，在发明者量化交易平台设置该交易对时写作```LINK3S_USDT```。\\n 也可以在策略中切换交易对：\\n\\n ```js\\n function main() {\\n exchange.SetCurrency(\\\"LINK3S_USDT\\\")\\n Log(exchange.GetTicker())\\n }\\n ```\\n\\n ```python\\n def main():\\n exchange.SetCurrency(\\\"LINK3S_USDT\\\")\\n Log(exchange.GetTicker())\\n ```\\n\\n ```cpp\\n void main() {\\n exchange.SetCurrency(\\\"LINK3S_USDT\\\");\\n Log(exchange.GetTicker());\\n }\\n ```\\n\\n 支持火币的中文交易对：\\n\\n ```js\\n function main() {\\n let ticker = exchange.GetTicker(\\\"币安人生_USDT\\\")\\n Log(\\\"ticker:\\\", ticker) // {\\\"Info\\\":{...},\\\"Symbol\\\":\\\"币安人生_USDT\\\",\\\"Open\\\":0.29622,\\\"High\\\":0.31661, ...}\\n }\\n ```\\n\\n- Futures_Bibox\\n - 不支持的接口：\\n 交易所不支持查询当前挂单，不支持查询市场历史成交记录的接口，因此不支持```GetOrders```、```GetTrades```函数。\\n- BitMEX\\n - 市价单买单\\n BitMEX现货交易下单接口中，市价单买单的下单量不是金额，而是交易币数。\\n- Bitfinex\\n - 市价单买单\\n Bitfinex现货交易下单接口中，市价单买单的下单量不是金额，而是交易币数。\\n- AscendEx\\n - 市价单买单\\n AscendEx现货交易下单接口中，市价单买单的下单量不是金额，而是交易币数。\\n- Futures_Phemex\\n - K线接口\\n 该交易所K线接口响应的数据不包含当前Bar数据。\\n - 切换逐仓/全仓：\\n 该交易所未提供切换全仓/逐仓的接口，需要在交易所端设置。\\n- Futures_Aevo\\n - 订单```Id```说明：\\n 该交易所订单```Id```由实际```Id```和订单时间戳组成，时间戳和实际订单```Id```使用英文逗号间隔。目的是为了支持```exchange.GetOrder(Id)```函数查询订单。由于交易所返回的数据中订单时间戳会随订单状态变化，如果本地需要记录订单```Id```等信息，请分离出实际订单```Id```进行记录。\\n- Futures_dYdX\\n 目前支持的是dYdX v4版本，请参考[dYdX v4 使用指南](https://www.fmz.com/digest-topic/10564)。\\n- Futures_Hyperliquid\\n 请参考[Hyperliquid 使用指南](https://www.fmz.com/digest-topic/10574)。\\n\\n 关于Hyperliquid期货的```exchange.IO()```切换功能（逐仓/全仓、主网/测试网、vaultAddress、walletAddress、expiresAfter等），请参考{@fun/Trade/exchange.IO exchange.IO}函数文档。\\n- Futures_Lighter\\n - 切换测试环境：\\n 测试环境可以在配置交易所对象时勾选设置，也可以使用```exchange.SetBase()```函数修改REST API端点切换到测试环境。\\n\\n 关于Futures_Lighter的```exchange.IO()```切换功能（逐仓/全仓、订单过期时间等），请参考{@fun/Trade/exchange.IO exchange.IO}函数文档。\", \"title\": \"交易所特殊说明\"}]","language","zh-CN","languageMode","system","sessionData",{"_373":25,"_374":25,"_375":240,"_376":240,"_232":233,"_377":25,"_170":25,"_378":25,"_379":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",[355,356,357,358,359],"nav",[322,323,324,325,326,327,328,329],"ad",[318],"ad1",[306,307,308],"embedx",[287,288],"payments",[242,243,244,245,246],"strategy",[220,221,222,223,224,225],"sso",[202,203,204],"update",{"_145":184,"_147":185,"_186":187},"redirect",{"_182":183},"openai",true,"ui",{"_180":171,"_181":171},"datadata_snapshot","https://www.datadata.com/web/resources/{{uuid}}/screenshot.png","chart","https://www.fmz.com/app/chart","timeout",15000,"show_prop_strategies","aiguide","/strategy/268542","/strategy/520271",{"_188":189,"_195":196,"_190":200,"_192":201,"_186":193,"_197":198,"_34":199},{"_190":194,"_188":189,"_195":196,"_192":148,"_197":198,"_34":199},"web",{"_188":189,"_190":191,"_192":193},"version","v2.2.26","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",{"_205":216,"_207":217,"_47":218,"_210":219},{"_205":212,"_207":213,"_47":214,"_210":215},{"_205":206,"_207":208,"_47":209,"_210":211},"source","web3","logo","/upload/asset/ee79a670efe19d2365.svg","MetaMask","platform",[186],"apple","/upload/asset/4416f8d6618c84681e.png","Apple 登录|Apple",[186,147],"google","/upload/asset/102992e886fb7a2fc67.png","Google 登录|Google",[186,147,145],{"_226":240,"_197":241},{"_226":238,"_232":236,"_197":239},{"_226":235,"_232":236,"_197":237},{"_226":231,"_232":233,"_197":234},{"_226":229,"_197":230},{"_226":227,"_197":228},"id",21,"交易插件|Plugin",20,"模板类库|Template",9,"currency","USD","加密货币|Cryptocurrency",2,"CNY","股票证券|Stocks",1,"商品期货|Futures",0,"通用策略|Common",{"_226":235,"_197":285,"_261":247,"_249":262,"_232":233,"_252":286},{"_226":264,"_197":265,"_261":240,"_266":264,"_249":256,"_232":233,"_267":268,"_269":270,"_252":271},{"_226":259,"_197":260,"_261":247,"_249":262,"_232":233,"_252":263},{"_226":254,"_197":255,"_249":256,"_257":200,"_252":258},{"_226":247,"_197":248,"_249":250,"_232":251,"_252":253},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",[272,273,274],"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",{"_275":282,"_197":283,"_269":284},{"_275":279,"_197":280,"_269":281},{"_275":276,"_197":277,"_269":278},"symbol","BNB","BSC","Binance Smart Chain","ETH","ERC20","Ethereum Network","TRX","TRC20","Tron Network","Paypal","https://www.fmz.com/upload/asset/297a3cb96cf4d1e7736.png",{"_289":303,"_291":304},{"_289":290,"_291":292},"path","/square_bak","banners",[293,294],{"_252":298,"_299":298,"_300":301,"_192":302},{"_295":296,"_192":297},"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",[305],{"_252":298,"_299":298,"_192":302},{"_252":315,"_299":316,"_192":317},{"_252":312,"_299":313,"_192":314},{"_252":309,"_299":310,"_192":311},"/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",{"_252":319,"_299":320,"_192":321},"/upload/asset/2c2c9521b3a6d0ee73b.png","/upload/asset/2c77ab5db219dc3e78f.png","/bbs-topic/4145",{"_197":352,"_252":353,"_192":354},{"_197":347,"_348":349,"_252":350,"_192":351},{"_197":345,"_252":346,"_192":303},{"_197":342,"_252":343,"_192":344},{"_197":339,"_252":340,"_192":341},{"_197":336,"_252":337,"_192":338},{"_197":333,"_252":334,"_192":335},{"_197":330,"_252":331,"_192":332},"消息中心|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",{"_252":298,"_299":298,"_192":302},{"_252":370,"_299":371,"_192":372},{"_252":365,"_299":366,"_367":368,"_192":369},{"_252":363,"_299":364,"_192":183},{"_252":360,"_299":361,"_192":362},"/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"]

函数名称	简介
exchange.IO("abi", ...)	注册ABI接口
exchange.IO("api", "eth", ...)	调用以太坊RPC方法
exchange.IO("encode", ...)	对函数调用进行编码
exchange.IO("encodePacked", ...)	执行encodePacked编码
exchange.IO("decode", ...)	对数据进行解码
exchange.IO("key", ...)	切换私钥
exchange.IO("api", ...)	调用智能合约方法
exchange.IO("address")	获取当前配置的钱包地址
exchange.IO("base", ...)	设置RPC节点地址