[{"_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\": \"7162dbcc22b2aac7d305ff403ffe19580e849ba726edea2f04004185f7035f1f\", \"children\": [{\"_src_hash\": \"3ef6f61641e672143ce8e5d223cc859f715d5db5707f639a855b3389bfabe97e\", \"children\": [], \"desc\": \"FMZ Quant is a quantitative trading platform: write strategies in the browser, backtest them online, then run them as live robots on a docker you deploy yourself or rent. You can also learn from, share and rent out strategies in the strategy square, or show your own live robots publicly.\\n\\n**Supported markets**\\n- Crypto: spot, futures and perpetual contracts on the major centralized exchanges, plus some on-chain exchanges.\\n- Securities and futures: Futu Securities, Interactive Brokers and others.\\n- Exchanges the platform has not integrated yet can be connected yourself through the general protocol (see Platform Basics → Exchange → General Protocol).\\n\\n**Strategy languages**\\nJavaScript, TypeScript, Python, Rust, PINE, MyLanguage, Blockly visual programming and Workflow; see Writing Strategies → Programming Languages.\\n\\n**AI assistance**\\n- The strategy editor has a built-in AI assistant that generates, explains and edits strategy code and analyzes backtest results (see Development Tools → Strategy Editor → AI Assistant).\\n- You can also connect the external AI assistant you already use to the platform and manage strategies, backtests and live robots through conversation (see Integrations → AI Integration).\\n\\n**Dashboard**\\nAfter signing up and logging in, open the [dashboard](https://www.fmz.com/m):\\n\\n![Dashboard overview](/upload/asset/2e4e636a6fe51c8f620e8.png)\\n\\n- [Control Center](https://www.fmz.com/m/dashboard): account overview and shortcuts. Running a live robot takes three things: an online docker, a strategy and a configured exchange account.\\n- [Live Trading](https://www.fmz.com/m/robots): create, manage and control live robots. A live robot is a running instance of a strategy program.\\n- [Strategy Library](https://www.fmz.com/m/strategies): write, save and group strategies in any supported language.\\n- [Docker](https://www.fmz.com/m/nodes): deploy and manage the docker programs that run strategies.\\n- [Exchange](https://www.fmz.com/m/platforms): add and manage exchange accounts.\\n\\n**Public resources**\\n- [Strategy Square](https://www.fmz.com/square): strategies shared publicly or listed for rent, good for learning and reference.\\n- [Live](https://www.fmz.com/live): live robots that users show publicly.\\n- [Digest](https://www.fmz.com/digest): original articles by the platform.\\n- [Community](https://www.fmz.com/bbs): the forum for discussing quantitative trading.\\n- [Crowdsourcing](https://www.fmz.com/markets): post and take on strategy development requests.\\n- [Classes](https://www.fmz.com/class): video tutorials.\\n- [API Docs](https://www.fmz.com/api): the API syntax manual for writing strategies.\\n\\n**Getting help**\\nPost in the community, submit a ticket from the dashboard, or contact the administrators in the [Telegram](https://t.me/fmzquant_cn) group.\", \"title\": \"Welcome to FMZ Quant Trading Platform\"}, {\"_src_hash\": \"83cd038239fa9dbefac1e25aeeb1bcd4b6eae8fb60e07444c63bd99bda231769\", \"desc\": [\"Five steps take you from adding an exchange to running your first live robot; each step names the chapter with the details.\\n\\n**1. Add an exchange account**\\n\\nAdd the exchange's API key on the Exchange page of the dashboard. Enable only read and trade permissions, never withdrawal; for a first try, use the exchange's demo trading or a small sub-account. See \\\"Platform Basics → Exchange\\\" and \\\"Getting Started → Key Security\\\".\\n\\n**2. Deploy a docker**\\n\\nThe docker is the program that runs strategies; every live robot runs on one. Rent a docker provided by the platform with one click, or deploy it on your own server. See \\\"Platform Basics → Docker\\\".\\n\\n**3. Write a strategy**\\n\\nCreate a strategy in the Strategy Library and pick a programming language. A strategy is an entry function ```main()``` with a main loop: each round fetches market data, computes signals, places orders and sleeps until the next round. See \\\"Writing Strategies\\\"; its \\\"Strategy Structure\\\" chapter has main-loop templates for every language and a quick reference of all API functions. You can also start from a public strategy in the strategy square.\\n\\n**4. Backtest**\\n\\nOn the strategy editing page, choose the exchange, trading pair, time range and K-line period, then start a backtest and check the profit curve, trades and logs. Go live only after the backtest looks right. See \\\"Backtesting System\\\".\\n\\n**5. Create a live robot**\\n\\nOn the Live Trading page of the dashboard, create a robot with the strategy, a docker and the exchange account, set the strategy parameters and start it. Live robots are billed by the hour, so the account needs a balance before you start; see \\\"Platform Basics → Account and Billing → Live Robot Billing and Top-up\\\". Its status, logs and profit are on the robot page, and errors can be pushed to your phone. See \\\"Platform Basics → Live Trading\\\".\\n\\nRead on as needed: \\\"Development Tools\\\" covers editing and debugging, \\\"Advanced Topics\\\" covers rate limiting, communication between robots, multi-threading and on-chain trading, and \\\"Integrations\\\" covers driving the platform from programs or AI assistants.\"], \"title\": \"Quick Start\"}, {\"_src_hash\": \"7fa17de84cd668050bc16fe3df2eac85da33091051bf2c600d8fb4ed77e105fc\", \"children\": [], \"desc\": \"A leaked exchange key costs you the assets in that exchange account. Before configuring an exchange account, go through this checklist:\\n\\n- **Trade permission only**: enable only read and trade permissions for the API key, and **never enable withdrawal**.\\n- **Bind an IP whitelist**: on the exchange, bind the API key to the outbound IP of the server running your docker. If the server has several IPs, pin the outbound IP with the docker's ```-I``` option (see Platform Basics → Docker → Command-Line Options).\\n- **Keep private keys local**: if the exchange supports asymmetric keys such as RSA, prefer them, and keep the private key as a credential file on the docker's machine so that the platform stores only the file path (see Platform Basics → Exchange → Local Credential Files).\\n- **Start small**: run a new strategy against the exchange's demo trading or a small sub-account first.\\n- **Do not publish secrets**: if the strategy code, parameters or description contain keys, account names or similar information, do not publish or sell the strategy.\\n\\nHow the platform stores keys: encrypted fields such as keys on the exchange configuration page are encrypted in the browser with your platform account password before upload, so the platform never stores them in plain text; only a docker started with that account password can decrypt them locally. Changing the platform account password therefore invalidates existing exchange configurations; see Platform Basics → Live Trading → Common Causes of Live Trading Errors and Abnormal Exits for what to do.\", \"title\": \"Key Security\"}], \"desc\": \"Start here: what the platform is, the five steps from adding an exchange to running a live robot, and keeping API keys safe.\", \"title\": \"Getting Started\"}, {\"_src_hash\": \"6225a664f37b8f24c6b5de49be1f35fed4bf5afa4f02b04bdc6ba9691e8c1b99\", \"children\": [{\"_src_hash\": \"88d3987d19eb9dcf585de4c3fcae1249e4ed59a119cc6ce1e5419b7360e976c0\", \"children\": [{\"_src_hash\": \"b764ee5fb44f9801157f9e44937371750c63663ce0934b33ec060423d8caf8ae\", \"desc\": \"**Billing**\\n- Live robots are billed by the hour at 0.05 USD per robot per hour; a partial hour counts as a full hour.\\n- Billing starts when the robot is created, and starting it prepays the first hour, so a robot cannot start if the account balance is insufficient. Stopping or restarting a robot does not bill it twice.\\n- If the balance runs out while a robot is running, the platform stops the robot; when a rented strategy expires, the robots using it are stopped as well.\\n- Servers rented with one-click docker rental are billed separately from live robots (see Platform Basics → Docker → Deploy Docker → One-Click Docker Rental).\\n\\n**Bills and balance alerts**\\n- The [billing page](https://www.fmz.com/m/billing) shows the balance, top-up records and every billing item.\\n- Under [balance alert in account settings](https://www.fmz.com/m/account#alertthreshold), set an alert threshold: when the available balance drops below it you get an email and WeChat notification (at most once every 24 hours unless you top up or change the setting); 0 turns the alert off.\\n\\n**Top-up**\\nChoose the payment method and amount on the [billing page](https://www.fmz.com/m/billing). When topping up with ```USDT```, check carefully:\\n- The transfer network must match the network selected on the billing page; TRC20, ERC20 and BSC are supported. ERC20 and BSC addresses both start with ```0x``` and look the same, which makes them the easiest to mix up.\\n- The asset is ```USDT```.\\n- The destination address is the one shown on the billing page.\", \"title\": \"Live Robot Billing and Top-up\"}, {\"_src_hash\": \"90a760361f505c39904442e2d304353865eeac9a48df3eed34e58c4e6327d404\", \"desc\": \"A sub-account lets other people view and operate some of your live robots without giving them the main account.\\n\\n**Create a sub-account**\\nOn the [account settings page](https://www.fmz.com/m/account#shadowmember), open the sub-account tab, select the live robots the sub-account may access under operation permissions, enter its username and login password, and create it. Sub-accounts are listed on the same page, where you can edit, lock/unlock or delete them.\\n\\n![Sub-account settings](/upload/asset/2e46d725dbe6b471f1b33.png)\\n\\n**Permissions**\\nA sub-account sees only the live robots authorized to it. On those robots it can change parameters, stop and restart, but it cannot change the exchange objects configured for the robot.\\n\\n**Typical uses**\\n- A quant team sharing the management of several live robots.\\n- Letting the renter of a strategy help debug a live robot.\", \"title\": \"Sub-accounts\"}], \"desc\": \"How live robots are billed, how to top up, and how to hand some live robots to other people with sub-accounts. Other account settings (push notifications, two-factor authentication, API keys, etc.) are on the [account settings page](https://www.fmz.com/m/account).\", \"title\": \"Account and Billing\"}, {\"_src_hash\": \"9dfb9ca3945e3681944bc6ef85d101c759fd3e876fbe0f58d07c1d6f275cd6d1\", \"children\": [{\"_src_hash\": \"af037528eb78beb398789ada24b8dab5184b15cc74d494fc3c0bfbf79b7c9ee0\", \"children\": [], \"desc\": \"For exchange API interfaces that have not yet been encapsulated and integrated by the FMZ Quant Trading Platform, you can access them by writing general protocol plugin programs.\\n\\n![General Protocol Configuration Screenshot](/upload/asset/2e43b059b3ec9f42ded6e.png)\\n\\nThis general protocol can be used to access any exchange that provides API interfaces, supporting the following two protocols:\\n- ```REST``` Protocol: [Reference Documentation](https://www.fmz.com/digest-topic/10518).\\n- ```FIX``` Protocol: [Reference Project](https://github.com/fmzquant/fixc).\\n\\nThe difference between ```FIX``` protocol plugin programs and ```REST``` protocol plugin programs lies only in the interaction method between the plugin program and the exchange interface. The interaction method, data format, and other implementation details between the protocol plugin program and the FMZ Quant docker program are exactly the same. For specific implementation, please refer to the examples in the above links.\", \"title\": \"General Protocol\"}, {\"_src_hash\": \"d86def8cbead5db631c9471a9ff50663b1325be3ba7108340d28009ff61d4cec\", \"desc\": \"When configuring an exchange, every masked encrypted input (Secret Key, private key, password, etc.) can hold a credential file path ```file:///name.txt``` instead of the secret itself. When the live robot runs, the docker reads that file on its own machine and uses the content as the value. The private key then exists only on the docker's machine, and the platform stores nothing but a path.\\n\\n**Path rules**\\n- The path is resolved relative to **this robot's directory** ```logs/storage//``` (```logs``` is under the docker's working directory). For robot ID ```123456```, ```file:///rsaKey.txt``` means ```logs/storage/123456/rsaKey.txt```.\\n- Subdirectories are allowed, e.g. ```file:///keys/rsaKey.txt```.\\n- Only the ```.txt``` suffix is recognized; with any other suffix the text is not read as a file but used literally as the configuration value.\\n- The path cannot be absolute, cannot contain ```..```, and after resolution cannot leave the robot directory (symbolic links pointing outside are rejected too).\\n- Credential files are read from each robot's own directory, so when several robots use the same exchange configuration, every robot directory needs its own copy.\\n- If the file cannot be read, the robot fails to start with an error containing ```read key file```; an invalid path fails with ```key file path must be relative and cannot contain '..'``` or ```key file path escapes the robot directory```.\\n\\n**Example: an RSA key**\\nFor an exchange that supports ```RSA KEY``` authentication:\\n1. Generate an RSA public/private key pair, e.g. a PKCS#8 pair with ```openssl```.\\n2. Create an ```RSA KEY``` on the exchange and upload the public key from step 1.\\n3. Configure the exchange on the platform: put the exchange's ```RSA KEY``` in ```Access Key``` and ```file:///rsaKey.txt``` in ```Secret Key```.\\n4. Create the live robot and note its ID (e.g. ```123456```).\\n5. Save the private key from step 1 as ```logs/storage/123456/rsaKey.txt```, then start (or restart) the robot.\\n\\nSee the [video walkthrough](https://www.bilibili.com/video/BV1UM41147Jj/) (Chinese) for the full process.\", \"title\": \"Local Credential Files\"}, {\"_src_hash\": \"b833097ce6331381104b2a51a860095935a7edd61e5a45d0fe84ec1b646bbb71\", \"children\": [{\"_src_hash\": \"aab381d8f248c69ad3716adbbe2199a6740abfba767e28c54e9560d11134956c\", \"desc\": \"**Futu Securities**\\n\\nFutu NiuNiu live trading and paper trading are supported. [```FutuOpenD```](https://www.futunn.com/download/OpenAPI?lang=zh-CN) must run on the docker's machine. For configuring the exchange object and running ```FutuOpenD```, see the [Futu Securities configuration guide](https://www.fmz.com/bbs-topic/10185).\\n\\nWhen ```FutuOpenD``` is used for paper trading, some stock codes are not supported and cannot be traded (paper trading works in the Futu NiuNiu mobile app).\\n\\n- Call frequency\\n ```GetOrder```, ```GetOrders```, ```GetPositions``` and ```GetAccount``` use **cached data** by default, so their call frequency is not limited; ```FutuOpenD``` updates the cache automatically when new data arrives.\\n ```exchange.IO(\\\"refresh\\\", true)``` disables the cache; without the cache the limit is **at most 10 queries every 30 seconds**, and exceeding it returns an error.\\n\\n- Stock codes\\n The format is ```code.market```, e.g. ```600519.SH```. Market suffixes:\\n - HK: Hong Kong stocks\\n - US: US stocks\\n - SH: Shanghai\\n - SZ: Shenzhen\\n - SG: Singapore futures\\n - JP: Japan futures\\n\\n Set the stock code with ```exchange.SetContractType()``` in the strategy, for example:\\n\\n ```js\\n function main() {\\n var info = exchange.SetContractType(\\\"600519.SH\\\") // set the stock 600519.SH (Moutai); the account switches to the mainland market\\n Log(info)\\n Log(exchange.GetAccount()) // the current stock is Moutai, so GetAccount returns the mainland market assets\\n Log(exchange.GetTicker()) // current quote of Moutai\\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 ```rust\\n fn main() {\\n let info = exchange.SetContractType(\\\"600519.SH\\\"); // set the stock 600519.SH (Moutai); the account switches to the mainland market\\n Log!(info);\\n Log!(exchange.GetAccount()); // the current stock is Moutai, so GetAccount returns the mainland market assets\\n Log!(exchange.GetTicker(None)); // current quote of Moutai\\n }\\n ```\\n\\n ```exchange.SetDirection``` (trade direction), ```exchange.Buy```/```exchange.Sell``` (orders), ```exchange.CancelOrder``` (cancellation), ```exchange.GetOrder``` (order query) and the like are used the same way as in futures markets.\\n\\n- Account information\\n Futu uses ```TrdMarket``` to tell the Hong Kong, US, mainland and other markets apart. From the [```Futu API``` documentation](https://openapi.futunn.com/futu-api-doc/):\\n\\n ```go\\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 Data returned by ```exchange.GetAccount()```:\\n\\n ```json\\n {\\n \\\"Info\\\": [{\\n \\\"Header\\\": {\\n ... // omitted\\n \\\"TrdMarket\\\": 1 // market ID in the raw Info data: assets of the Hong Kong market\\n },\\n \\\"Funds\\\": { // account assets in this market\\n ...\\n }\\n }, ...],\\n \\\"Stocks\\\": 0,\\n \\\"FrozenStocks\\\": 0,\\n \\\"Balance\\\": 1000000, // assets in the current market\\n \\\"FrozenBalance\\\": 0\\n }\\n ```\\n\\n- ```FutuOpenD``` decides the region by the **IP** address it logs in from; accounts logged in from outside mainland China have some market data restrictions. See the official ```FutuOpenD``` (Futu) documentation.\\n\\n**Interactive Brokers**\\n\\n- Configure the exchange\\n Run \\\"IB Gateway\\\" or \\\"TWS (Trader Workstation)\\\" on the docker's machine. With TWS: after logging in, click the configuration button at the top right, open \\\"Configure\\\" → \\\"API\\\" → \\\"Settings\\\", **uncheck** \\\"Read-Only API\\\", check \\\"Enable ActiveX and Socket Clients\\\", and note the \\\"Socket port\\\" (TWS defaults to 7496 for live and 7497 for paper; IB Gateway to 4001 for live and 4002 for paper).\\n Then choose **Interactive Brokers** on the platform's [add exchange page](https://www.fmz.com/m/add-platform):\\n - Server address: the address and port of TWS or IB Gateway, e.g. ```localhost:7496```.\\n - Market data type: realtime, frozen, delayed or delayed frozen. Accounts without a realtime market data subscription can choose delayed data. It can also be switched at run time with ```exchange.IO(\\\"marketDataType\\\", n)``` (```n``` from 1 to 4, in the order above).\\n\\n- Contract codes\\n Set with ```exchange.SetContractType()``` in the form ```symbol.currency[.type[.exchange]]```; the type defaults to stock ```STK``` and the exchange to ```SMART```:\\n - US stocks: ```AAPL.US```, ```TSLA.US``` (```US``` means priced in USD).\\n - Hong Kong stocks: ```symbol.HK``` (```HK``` means priced in HKD).\\n - Futures (```FUT```): ```symbol-expiry[-multiplier].currency.FUT.exchange```, with the expiry month written as ```YYYYMM``` and the exchange as IB's exchange code.\\n - Options (```OPT```) and futures options (```FOP```): ```symbol-expiry-C or P-strike×100[-multiplier].currency.OPT or FOP.exchange```, with the strike multiplied by 100 and written as an integer.\\n - A plain number: used directly as the IB contract ID (conId).\\n\\n- Other notes\\n - The docker connects to TWS with the live trading ID as its client ID (clientId), so the client ID stays the same across restarts and orders placed earlier can still be cancelled or modified. TWS only lets the client ID that placed an order (or the master client) modify or cancel it.\\n - ```Symbol``` in positions and orders is the short form (e.g. ```Z74.SGD```); ```exchange.GetPositions()``` and ```exchange.GetOrders()``` accept either the short form or the full code used when ordering (e.g. ```Z74.SGD.STK.SGX```).\\n - When the gateway rejects an order, the ```Reject``` field in the order's ```Info``` holds the reason.\\n - After ```exchange.IO(\\\"debug\\\", true)```, every frame sent to or received from TWS is logged in the TWS API log format, so it can be matched against the gateway's own log.\", \"title\": \"Securities and Futures\"}, {\"_src_hash\": \"d5a9c56da9a44d86e6a21a635f2b3c664fef9da68c1fd2241c057dc9e8252f06\", \"desc\": \"- Futures_Binance\\n Binance trading pairs with Chinese names are supported:\\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 For the ```exchange.IO()``` switches of Binance Futures (dual-side position mode, isolated/cross margin, unified account, STP mode, etc.), see {@fun/IO/exchange.IO exchange.IO}.\\n- Futures_HuobiDM\\n Use ```exchange.IO(\\\"base\\\", \\\"https://xxx.xxx.xxx\\\")``` or ```exchange.SetBase(\\\"https://xxx.xxx.xxx\\\")``` to switch the base address of the exchange API.\\n\\n For the ```exchange.IO()``` switches of Huobi Futures (signHost, isolated/cross margin, one-way/two-way position mode, unified account, etc.), see {@fun/IO/exchange.IO exchange.IO}.\\n\\n Condition orders of the OCO type (```ORDER_CONDITION_TYPE_OCO```) are not supported; condition orders also work in multi-asset margin mode.\\n- Huobi\\n Huobi trading pairs with Chinese names are supported:\\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- Bitfinex\\n The amount of a spot market buy order is the quantity of the traded coin, not the quote amount.\\n- AscendEx\\n The amount of a spot market buy order is the quantity of the traded coin, not the quote amount.\\n- Futures_Hyperliquid\\n See the [Hyperliquid guide](https://www.fmz.com/digest-topic/10574).\\n\\n For the ```exchange.IO()``` switches of Hyperliquid Futures (isolated/cross margin, mainnet/testnet, vaultAddress, walletAddress, expiresAfter, etc.), see {@fun/IO/exchange.IO exchange.IO}.\\n- Futures_Lighter\\n The test environment can be selected when configuring the exchange object, or reached by changing the REST API endpoint with ```exchange.SetBase()```.\\n\\n For the ```exchange.IO()``` switches of Futures_Lighter (isolated/cross margin, order expiry, etc.), see {@fun/IO/exchange.IO exchange.IO}.\\n\\n ```Buy``` and ```Sell``` returned by ```exchange.GetTickers()``` are each instrument's last trade price (the exchange has no batch order book endpoint); use ```exchange.GetTicker()``` or ```exchange.GetDepth()``` when you need the best bid and ask.\\n- Futures_edgeX\\n All edgeX perpetuals are quoted in USDC: write the trading pair as ```BTC_USDC``` and so on, with full symbols such as ```BTC_USDC.swap```; ```BTC_USDT``` or ```BTC_USD``` is reported as a contract that does not exist.\\n- Poloniex\\n Spot condition orders support stop-loss only (```ORDER_CONDITION_TYPE_SL```): a buy triggers when the price rises to the trigger price, a sell when it falls to the trigger price. Take-profit (```ORDER_CONDITION_TYPE_TP```) and OCO condition orders return an error and no order is placed.\", \"title\": \"Crypto\"}], \"desc\": \"Configuration steps of individual exchanges and the places where they behave differently from the general API. Exchanges not listed here follow the general descriptions in the syntax manual; the switches each exchange supports through ```exchange.IO()``` are listed under {@fun/IO/exchange.IO exchange.IO}.\", \"title\": \"Exchange-Specific Notes\"}], \"desc\": \"The [Exchange](https://www.fmz.com/m/platforms) page manages the exchange accounts you have configured. On FMZ, an \\\"exchange\\\" is an account a strategy program can operate: it holds the keys of the funding account together with the protocol and API wrapper used to talk to that exchange.\\n\\nClick \\\"Add Exchange\\\" on the exchange management page to open the [add exchange page](https://www.fmz.com/m/add-platform), then choose the exchange and fill in its configuration. Encrypted fields such as keys are encrypted in the browser before being saved to the platform, so the platform never stores them in plain text (see Getting Started → Key Security).\\n\\n**Exchange objects**\\nIn strategy code a configured exchange is the exchange object {@var/EXCHANGE/exchange exchange}. A backtest or live robot can be configured with several exchanges; in code they form the exchange object array {@var/EXCHANGE/exchanges exchanges}.\\n\\n**Using an exchange object**\\nStrategy code reads the account and market data, places orders and cancels them through the exchange object. In ```JavaScript```:\\n\\n```js\\nfunction main() {\\n let account = exchange.GetAccount() // query account information\\n let ticker = exchange.GetTicker() // get the ticker\\n let id = exchange.Buy(1000, 1) // price 1000, amount 1\\n if (id) {\\n exchange.CancelOrder(id) // an order Id exists only if the order was placed; cancel it if still open\\n }\\n}\\n```\\n\\nThe rest of this chapter:\\n- General Protocol: connect an exchange the platform has not integrated yet.\\n- Local Credential Files: keep private keys and other secrets only on the docker's machine.\\n- Exchange-Specific Notes: configuration steps and behavior differences of individual exchanges.\", \"title\": \"Exchange\"}, {\"_src_hash\": \"bc4853141a2f0ff40439f5883c23c8f2f36688363c559aadc6729099a27a3266\", \"children\": [{\"_src_hash\": \"e9b9ee2b500025633a2a4ec0c496f886a5e409c0274abfff771d705e92ff3e39\", \"children\": [{\"_src_hash\": \"84eb7387f5acda70a20f1476b9982121a2fac37d9f53d7853f1dba32508e5954\", \"desc\": \"On the [Docker Deployment Page](https://www.fmz.com/m/add-node), click the **One-Click Docker Rental** tab and select the server to deploy based on your configuration requirements and server location preferences.\\n\\nClick \\\"Buy Now\\\" and enter your FMZ Quant Trading Platform account credentials for verification. After successful verification, the docker program will be deployed automatically. The entire deployment process takes a few minutes, and the system will automatically install commonly used Python libraries.\\n\\nAfter clicking \\\"Buy Now\\\", the rented server is provisioned through the platform on your behalf and has limited system permissions, with no support for remote login. If you need to use third-party Python libraries that are not pre-installed, it is recommended to use a private server for manual deployment.\\n\\nServers rented through the **One-Click Docker Rental** feature use independent billing, which is separate from live trading billing.\\n\\nClicking the \\\"Redeploy\\\" button will not delete the live trading logs and data files in the logs directory under the docker directory.\", \"title\": \"One-Click Docker Rental\"}, {\"_src_hash\": \"0ff04ef2b5a299f15b931d78dcb10b48706e47d1f7757c12f7e2b870cd125c9b\", \"desc\": \"The docker can run on a PC, a server, a Raspberry Pi (64-bit OS) and similar devices. Only 64-bit builds are released:\\n- Linux command line: x86_64 (amd64), ARM64 (aarch64)\\n- macOS command line: Intel, Apple Silicon\\n- Windows: x64 and ARM64, each with a command-line and a GUI version\\n\\nOn the [docker deployment page](https://www.fmz.com/m/add-node), click **Manual Deployment**, download the build for your system and unpack it; the executable ```robot``` is the docker program. The same page shows the two pieces of information needed:\\n\\n![Manual docker deployment page](/upload/asset/2e460507bc21582ba1448.png)\\n\\n1. Communication address: contains your account UID, like ```node.fmz.com/123456```.\\n2. Password: the password of the FMZ account that owns the UID.\\n\\n**Windows GUI version**\\nRun ```robot.exe```, enter the communication address and password, and click start.\\n\\n**Command-line version**\\n```bash\\nchmod +x robot # Linux/macOS: make it executable before the first run\\n./robot -s node.fmz.com/123456 # prompts for the password, which is not echoed\\n```\\n\\n```123456``` is only an example; the real address is on the docker deployment page. Do not pass the password in plain text with ```-p```: it stays in the shell history and the process list. For unattended start-up, put the address and password in a configuration file ```robot.conf``` that only you can read:\\n\\n```bash\\ncat > robot.conf <<'EOF'\\ns=node.fmz.com/123456\\np=your-password\\nEOF\\nchmod 600 robot.conf\\n./robot -c robot.conf # with robot.conf in the startup directory, plain ./robot loads it too\\n```\\n\\nAll options and the configuration file format are described in Platform Basics → Docker → Command-Line Options.\\n\\n**Running in the background**\\nThe docker ignores the terminal hang-up signal: start it in the foreground over SSH and simply disconnect, and it keeps running, with its log also written to ```logs/docker.log```. To start at boot or restart after a crash, run it under a service manager such as systemd, e.g. ```/etc/systemd/system/robot.service```:\\n\\n```ini\\n[Unit]\\nDescription=FMZ robot\\nAfter=network-online.target\\nWants=network-online.target\\n\\n[Service]\\nWorkingDirectory=/opt/robot\\nExecStart=/opt/robot/robot -c /opt/robot/robot.conf\\nRestart=on-failure\\nTimeoutStopSec=90\\n\\n[Install]\\nWantedBy=multi-user.target\\n```\\n\\n```bash\\nsudo systemctl daemon-reload\\nsudo systemctl enable --now robot\\n```\\n\\nThe ```SIGTERM``` sent by ```systemctl stop robot``` makes the docker shut down gracefully: it stops all its live robots, reports their state and then logs out of the platform. ```TimeoutStopSec``` leaves enough time so that it is not killed before finishing.\\n\\n**Upgrading the docker**\\nThe strategy runtime and the exchange connectors are delivered by the platform when needed and need no manual updates. To upgrade the docker program itself, stop the docker (see Docker Operation Precautions), replace the ```robot``` executable with the new version and start it in the **same working directory**. The ```logs``` directory there keeps the docker identity and the robot data, so the docker comes back with its old ID.\\n\\n**Isolating strategy processes in Docker containers**\\nOn Linux and macOS, the command-line version can run each strategy process in its own Docker container with the ```-i``` option (Docker must be installed and running on the machine). This isolates strategy processes; it is not a Docker image of the docker program itself. See Command-Line Options for the parameters.\", \"title\": \"Manual Deployment of Docker\"}, {\"_src_hash\": \"98ef7baf0e428ce1686765ebd45dde53b71ae2afab550d3dcb29bc6f09abecf9\", \"desc\": \"**Stop the robots first, then the docker**\\nBefore deleting a docker or stopping its process, make sure no live robot is running on it.\\n\\n**Stopping the docker normally**\\n- Command-line version: press ```Ctrl+C``` once in the terminal, or send ```SIGTERM``` to the process (```kill ```, ```systemctl stop```).\\n- Windows GUI version: click the stop button.\\n\\nOn a stop request the docker shuts down gracefully: it stops all its live robots, reports their final state and then logs out of the platform. Pressing ```Ctrl+C``` again during this shutdown skips the reporting and logout and exits at once; normally do not do that.\\n\\n**Avoid forced termination**\\nDo not end the docker with ```kill -9```, cut the power or force a shutdown. The docker then has no chance to log out, and its live robots may still show as running on the platform and keep being billed; in that case the offline docker has to be deleted before those robots can be stopped. Stop the docker before rebooting the server; when it runs under a service manager such as systemd, a system shutdown sends ```SIGTERM``` automatically.\", \"title\": \"Docker Operation Precautions\"}], \"desc\": \"The [docker management page](https://www.fmz.com/m/nodes) lists the dockers of your account, as a list or with details, including each docker's IP address, version and build time. Click **Deploy Docker** to open the [docker deployment page](https://www.fmz.com/m/add-node), which offers two ways: one-click docker rental and manual deployment.\\n\\n![Docker deployment page](/upload/asset/2e527e497b3fa27ba497b.png)\", \"title\": \"Deploy Docker\"}, {\"_src_hash\": \"97578eb6b2349d9d2d2161be5b56441b49d99f678069af82eded35a07955d9a5\", \"desc\": \"Starting the command-line docker program ```robot```:\\n\\n```bash\\n./robot -s node.fmz.com/123456 # prompts for the password (not echoed)\\n./robot node.fmz.com/123456 # short form: robot address [password]\\n./robot -c robot.conf # read options from a configuration file\\n./robot -v # show the version\\n```\\n\\n**Options**\\n\\n| Option | Description |\\n| --- | --- |\\n| ```-s address``` | Address for talking to the platform, like ```node.fmz.com/123456``` (```123456``` is the account UID); a ```ws://``` or ```wss://``` prefix is allowed. Shown on the [docker deployment page](https://www.fmz.com/m/add-node). |\\n| ```-p password``` | Account password. Not recommended: a plain-text password stays in the shell history and the process list. Without it the password is prompted for, or read from the configuration file. |\\n| ```-n name``` | Docker name, shown on the platform's docker page. |\\n| ```-w dir``` | Working directory. ```logs``` (robot data, docker log, identity file) lives under it. |\\n| ```-c file``` | Configuration file; format below. |\\n| ```-u user``` | Linux/macOS only: run strategy processes as this system user; the docker itself must run as root. Ignored with ```-i```. |\\n| ```-I IP``` | Local outbound IP: the connection to the platform and the strategies' connections to exchanges are bound to this address; see below. |\\n| ```-i image``` | Linux/macOS only: run each strategy process in its own container created from this Docker image; Docker must be installed and running. |\\n| ```-e path``` | With ```-i```: path of the executable inside the container. |\\n| ```-f JSON``` | With ```-i```: Docker container settings, as inline JSON or ```@path``` to read them from a file. |\\n| ```-H address``` | With ```-i```: address the container uses to connect back to the host. |\\n| ```-vv``` | Verbose log (including the messages exchanged with the platform); off by default to keep logs small. |\\n| ```-d DNS``` | The old custom DNS option; still accepted but ignored, as the docker always uses the system resolver. |\\n| ```-v```, ```-V```, ```--version``` | Print version and build information and exit. |\\n| ```-h```, ```--help``` | Print usage. |\\n| ```--ctl-stdin``` | Read control commands from standard input (the first line is the password when ```-p``` is not given); ```stop``` or end of input triggers a graceful shutdown. Meant for programs that wrap the docker as a service. |\\n\\nOptions that take a value can also be written as ```-option=value```, e.g. ```-n=server01```. An invalid option prints the usage and exits.\\n\\n**Configuration file robot.conf**\\nOne ```key=value``` per line; the key is the option name without ```-``` (```s p n w u I d i e f H vv```), and lines starting with ```#``` are comments:\\n\\n```ini\\n# robot.conf\\ns=node.fmz.com/123456\\np=your-password\\nn=server01\\nvv=true\\n```\\n\\n- Give the file with ```-c```; without ```-c``` and without an address, ```robot.conf``` in the startup directory is loaded automatically if present.\\n- When an option is given both on the command line and in the file, the command line wins.\\n- Keys are case-sensitive: ```I``` is the outbound IP and ```i``` the Docker image.\\n- The configuration file path and ```-f @file``` are resolved relative to the startup directory (before ```-w``` changes directory).\\n- The file holds your password, so make it readable only by you (```chmod 600 robot.conf```).\\n\\n**Pinning the outbound IP (-I)**\\nWhen the server has several IP addresses and the exchange API key is whitelisted for one of them, pin the outbound IP with ```-I```, e.g. ```./robot -s node.fmz.com/123456 -I 192.168.1.100```. The connection to the platform and the strategies' connections to exchanges then leave from that address. With ```-i``` container isolation the container's network may not have that address; in that case let the container use the host network.\\n\\nThe Windows GUI version has no IP setting; use the command-line version when you need to pin the outbound IP. The GUI version accepts only ```-s```, ```-p``` and ```-n```, which prefill the window; when both ```-s``` and ```-p``` are given it starts automatically.\", \"title\": \"Command-Line Options\"}, {\"_src_hash\": \"b2dca0be6da90267676a266efa14fc936b034cdad9299d93984d3ef693d073a1\", \"desc\": \"Each live robot's data is in ```logs/storage//``` under the docker's working directory (the database ```.db3```, ```stdout.log```, ```stderr.log``` and so on). The logs, profit and charts the platform shows for a robot are read from the docker that runs it.\\n\\n**Moving one robot to a docker on another machine**\\n1. Stop the robot.\\n2. Copy the whole ```logs/storage//``` directory to the same place under the new docker's working directory, keeping the robot ID as the directory name.\\n3. Switch the robot's docker to the new one in the robot configuration and start the robot.\\n\\nThe robot's existing logs, profit and other data are then kept on the new machine.\\n\\n**Moving a whole docker**\\n1. Stop the robots on the old docker, then stop the old docker.\\n2. Copy the entire ```logs``` directory from the old docker's working directory to the working directory on the new machine.\\n3. Start the docker on the new machine.\\n\\n```logs/docker.pid``` holds the docker's identity: with the old docker offline, the docker on the new machine gets the old docker ID back, so robot configurations need no change. Never run dockers on two machines with the same ```logs``` directory at the same time.\", \"title\": \"Live Trading Data Migration\"}, {\"_src_hash\": \"5ca888ba06422961d44a545736d40a3b73c1f80bf8ed66a659defe184517ca02\", \"desc\": \"On the [docker management page](https://www.fmz.com/m/nodes), **Docker Monitor** can be enabled from the actions of the docker list or of the docker details. Once enabled, the platform emails the address bound to your account when the docker goes offline abnormally.\", \"title\": \"Docker Monitor\"}], \"desc\": \"The [docker](https://www.fmz.com/m/nodes) is the program that runs strategies: live strategies run on a docker, not on the FMZ website. The docker talks to the platform, starts and stops strategy processes and sends logs back; every request a strategy makes to an exchange also leaves from the docker's machine. The docker runs on your own server (or a server rented with one click), so a network failure of the platform website does not affect the live robots already running on it.\\n\\n**Supported systems**\\nOnly 64-bit builds are released: Linux (x86_64, ARM64), macOS (Intel, Apple Silicon) and Windows (x64, ARM64, plus a GUI version). 32-bit systems are not supported.\\n\\n**Data directory**\\nAll docker data is in the ```logs``` directory under the working directory (the startup directory by default, or the one given with ```-w```):\\n- ```logs/storage//.db3```: the robot database (```SQLite```) holding logs, profit, charts, the status bar and ```_G()``` data; it can be opened with any ```SQLite``` tool.\\n- ```logs/storage//stdout.log```, ```stderr.log```: standard output and standard error of the strategy process.\\n- ```logs/docker.log```: the docker's own log.\\n- ```logs/docker.pid```: the docker's identity; keep it and the platform gives the docker its old ID back after a restart.\\n\\n**Network proxy**\\nThe docker does not read the system proxy settings or environment variables such as ```HTTP_PROXY```. To reach an exchange through a proxy:\\n- set a proxy on the exchange object in the strategy with {@fun/Exchange/exchange.SetProxy exchange.SetProxy};\\n- or use a transparent proxy that takes over traffic at the network layer (such as Clash in TUN mode), which needs no docker configuration.\\n\\nThis chapter covers deploying the docker (manual deployment, one-click rental, operation precautions), command-line options, migrating live robot data and docker monitoring.\", \"title\": \"Docker\"}, {\"_src_hash\": \"7501db47f0aadcfa10afbb5b38058e5423eafcdf2b44ed326e08cbee23e2e28e\", \"children\": [{\"_src_hash\": \"75549cfd63949cfd3cd6a0c07393e3a2815e3467e06e005437575ecee7e2f83b\", \"children\": [], \"desc\": \"Copying the source code is not enough to move a strategy: the parameter design, interaction design, template references and more are not in the source. \\\"Export Strategy\\\" and \\\"Import Strategy\\\" on the strategy editing page move a strategy completely.\\n\\n![Strategy import/export screenshot](/upload/asset/2e52ccf44526f396fb795.png)\\n\\n- Export Strategy\\n Exports one ```xml``` file, for strategies in every programming language. When exporting you can choose what to include: name, source code, notes, description, manual, template references, strategy parameters, interactive controls and backtest settings.\\n\\n- Import Strategy\\n Click \\\"Import Strategy\\\" on the strategy editing page, choose an ```xml``` file produced by \\\"Export Strategy\\\", and select what to import. Click \\\"Save\\\" afterwards to save the strategy.\", \"title\": \"Import and Export of Complete Strategies\"}, {\"_src_hash\": \"71c1a09c40a782bb7ee3823cf1a23e7cf05e7bae176e6119265c3c2194f08cd8\", \"children\": [{\"_src_hash\": \"7edc7ab9bead8cea0f828cf19ea5f3166c8ea3774f6d0d787dd85160e391da6d\", \"desc\": \"![Strategy Sharing](/upload/asset/2e593d57dc36afc004ef6.png)\\n\\n- Public Sharing\\n After clicking the \\\"Share\\\" button, a dialog box will pop up where you can select \\\"Public Sharing\\\". The strategy will be fully shared to the platform's Strategy Square, where any user can copy the strategy.\\n\\n- Private Sharing\\n After clicking the \\\"Share\\\" button, a dialog box will pop up where you can select \\\"Private Sharing\\\". After selecting the sharing validity period and sharing limit, a **copy page URL** and **copy code** for the strategy will be generated. These can be distributed to designated FMZ platform users. Users who need the strategy can simply use the **copy page URL** link, log in to the **copy page** and enter the copy code to obtain the strategy. Once obtained, the strategy will automatically appear in their strategy library.\", \"title\": \"Strategy Sharing\"}, {\"_src_hash\": \"3f50643e4769bab1191582e3303591987b3ad3dbc25e42f765b998e50971c72c\", \"desc\": \"![Strategy Rental](/upload/asset/2e4e78f6c46c9dde1ce90.png)\\n\\n- Public Sale\\n After clicking the \\\"Rent\\\" button, a dialog box will pop up where you can select \\\"Public Sale\\\". The strategy can then be submitted for listing (requires approval).\\n\\n- Internal Sale\\n After clicking the \\\"Rent\\\" button, a dialog box will pop up where you can select \\\"Internal Sale\\\". After selecting the number of days, maximum concurrent instances, and number of registration codes, the system will generate a **registration page URL** and **registration codes** for this strategy. You can distribute these to designated FMZ platform users. Users who need this strategy only need to visit the **registration page URL** link, log in to the **registration page**, and enter the registration code to obtain access to the strategy. The strategy will also appear in the strategy library, but users will only have backtesting and live trading permissions, and cannot view the strategy source code or other information. When the number of concurrent live trading instances is set to 0, it means there is no limit on concurrent instances, allowing unlimited creation of live trading bots.\", \"title\": \"Strategy Rental\"}], \"desc\": \"On the [Strategy Library](https://www.fmz.com/m/strategies) page, click the \\\"Actions\\\" button on the right side of a strategy to display a menu containing sharing and renting options.\\n\\nImportant Notice: When creating and distributing strategy **registration codes**, please carefully confirm whether it is a \\\"Registration Code\\\" or \\\"Copy Code\\\" to avoid accidentally leaking your strategy.\", \"title\": \"Strategy Sharing and Renting\"}], \"desc\": \"The [Strategy Library](https://www.fmz.com/m/strategies) page holds all strategies of the current account, written in any of the programming languages or visually.\\n\\n- Grouping: strategies can be grouped just like robots (see Platform Basics → Live Trading → Grouping).\\n- Import and export: besides the source code, a complete strategy includes its parameters, interactions, description, notes, manual, template references and more, so move a strategy by exporting and importing the complete strategy (see Import and Export of Complete Strategies).\\n- Sharing and renting: generate a \\\"copy code\\\" to share a strategy or a \\\"registration code\\\" to rent it out (see Strategy Sharing and Renting).\", \"title\": \"Strategy Library\"}, {\"_src_hash\": \"78b87c183d37a5fbf6275f985668e46fadbea6b98a87f1dfb54a9fa1c64bc839\", \"children\": [{\"_src_hash\": \"c8bc86ea2e0297eadabb90915f67fd91d69a794da353abe0cea1eb09ab9e3e78\", \"children\": [], \"desc\": \"Click the **Group Management** button on the right of the \\\"Live Trading\\\" page or the \\\"Strategy Library\\\" page to group robots or strategies; group names are up to you.\\nFor strategies, for example, you can put **template libraries** in one group, **JavaScript strategies** in another and **test strategies** in a third.\\n\\n- Strategy groups\\n ![Strategy groups](/upload/asset/2e482ba9b9aa272085d00.png)\\n\\n- Robot groups\\n ![Robot groups](/upload/asset/2e577d050e817837bbfdf.png)\", \"title\": \"Grouping\"}, {\"_src_hash\": \"45ebe50ea25355b7088390c6a4bd600e0b1c2093d4682a3da9756bdc50e49988\", \"desc\": \"Click the \\\"Public\\\" button in the live trading list on the [Live Trading Page](https://www.fmz.com/m/robots) of FMZ Quant Trading Platform to publicly display the current live trading instance.\\n\\nLive trading observation currently supports two methods:\\n- 1. Publicly display live trading on the [Live Trading Observation](https://www.fmz.com/live) page of FMZ Quant Trading Platform. Click the \\\"Public\\\" button and select **Public Sharing**.\\n- 2. Create a private link for live trading observation.\\n Click the \\\"Public\\\" button and select **Internal Sharing**, set the validity period to generate a private link for accessing the private observation page of this strategy's live trading.\", \"title\": \"Live Trading Observation\"}, {\"_src_hash\": \"a088268017c19b152a1d5899dc8e7870c85f4f5381ba6af68044b3b3f8293da4\", \"children\": [], \"desc\": \"You can enable the message push feature on the [Push Settings page](https://www.fmz.com/m/account#push).\\n\\n![Push Settings](/upload/asset/2e4ad17706aa842c914ce.png)\\n\\n- Mobile (App)\\n After enabling mobile App push, push messages sent by the live trading program will be delivered to the FMZ Quant mobile App.\\n- Email\\n To enable email push, you must first verify your email address. Once verified, you can receive push messages sent by the live trading program.\\n- WebHook\\n After enabling WebHook push, you can customize the push address, for example: ```http://abc.com/push.php?data={body}```.\\n When the live trading program sends a push message, the platform will send a request to the configured address ```http://abc.com/push.php?data={body}``` (only the ```GET``` method is supported), and the pushed message content will replace the ```{body}``` placeholder.\\n\\nPushing Messages in Strategies\\n- JavaScript/TypeScript/Python/Rust Languages\\n In the strategy code, you can use the ```Log()``` function as well as other functions that output log information in the log area, such as ```exchange.CreateOrder()```, ```exchange.CancelOrder()```, etc.\\n By passing an additional parameter ```\\\"@\\\"``` to these functions (i.e., adding an extra parameter beyond the required ones), for example ```Log(\\\"This is a push message\\\", \\\"@\\\")```, the output log information will be pushed, and the platform will push the message according to the \\\"Push Settings\\\". In the Rust language, the corresponding ```Log!``` macro is used the same way: ```Log!(\\\"This is a push message\\\", \\\"@\\\");```.\\n- PINE Language/My Language\\n In the \\\"Trading Library\\\" parameters integrated into PINE Language/My Language strategies, you can enable trading log push, which will automatically push messages after a trading action is triggered.\\n- Blockly Visual\\n In the \\\"Tools\\\" section, select the **Message Push** module to push specified information.\\n\\nMessage push is subject to a frequency limit, with the following rule: within each 20-second cycle of live trading, only the last message is retained and pushed, while all other messages are filtered out and not pushed.\", \"title\": \"Live Trading Message Push\"}, {\"_src_hash\": \"fa0a0729594ca951563e82b535ae1bf0914413852b6376b77138366878fccc1d\", \"children\": [], \"desc\": \"**The robot cannot start**\\n- No online docker\\n A robot cannot start while its docker is offline. Check on the [docker page](https://www.fmz.com/m/nodes) that the docker is online, or pick another online docker.\\n- Insufficient balance\\n Starting a robot prepays its first hour, so it cannot start without enough balance; if the balance runs out while it runs, the platform stops it. Top up and start it again (see Platform Basics → Account and Billing → Live Robot Billing and Top-up).\\n- Rented strategy expired or concurrency limit reached\\n When a rented strategy expires, robots using it are stopped and cannot be started again; once the rental's maximum number of concurrent robots is reached, no further robot can start.\\n- Key decryption failed\\n The error contains ```secret key decrypt failed (wrong password)```. The FMZ account password was changed, so the exchange keys configured earlier can no longer be decrypted. To fix it:\\n 1. Re-enter the exchange keys, passwords and similar fields on the [Exchange management page](https://www.fmz.com/m/platforms).\\n 2. Stop all dockers and start them again with the new password.\\n- Credential file not found\\n The exchange configuration uses a ```file:///xxx.txt``` credential file that is missing from the robot directory; the error contains ```read key file```. An invalid path fails with ```key file path must be relative and cannot contain '..'``` or ```key file path escapes the robot directory```. See Platform Basics → Exchange → Local Credential Files.\\n\\n**Errors caused by strategy code**\\n- Static syntax errors\\n\\n ![Syntax error in editor](/upload/asset/2e4daebbb80548adf3927.png)\\n\\n These are obvious: the strategy editing page usually marks them, and a backtest reveals them too.\\n- Runtime errors\\n The most common one is using a function's return value without checking that it is valid.\\n- Excessive memory usage\\n Keeping too much data that cannot be garbage-collected in global variables.\\n- Improper use of ```exchange.Go``` for concurrent requests\\n Calling the asynchronous ```exchange.Go``` without calling ```wait``` for the results in time, so that too many concurrent tasks pile up.\\n- Recursion too deep\\n Too many levels of recursion exceed the call stack size.\\n\\n**Other errors**\\n- API business errors and network request errors\\n These show the exchange object name, the function name, the error message and the reason, and do not stop the robot by themselves. They are usually the trigger rather than the direct cause, which is typically **a program exception from using an API return value without checking it**.\\n- ```interrupt``` error\\n Logged when the user clicks the **Stop** button on the robot page while the program is in the middle of an operation (such as an exchange API call) and the stop interrupts it. It is harmless, just a log entry.\\n\\nSee the [FAQ collection](https://www.fmz.com/bbs-topic/1427) for more.\", \"title\": \"Common Causes of Live Trading Errors and Abnormal Exits\"}], \"desc\": \"As opposed to a backtest, a live robot is a strategy program instance that really interacts with an exchange (fetching market data, querying positions, placing and canceling orders, etc.). An instance connected to the exchange's production environment is a live robot, and so is one connected to the exchange's simulation environment (many exchanges offer a test environment).\\n\\n**Creating a live robot**\\nOn the [robot creation page](https://www.fmz.com/m/add-robot), choose the strategy, the docker host and the exchanges, then create the robot. Three things must be ready beforehand:\\n- A strategy: click \\\"New Strategy\\\" in the [Strategy Library](https://www.fmz.com/m/strategies), write it and save it.\\n- An online docker: click \\\"Deploy Docker\\\" on the [Docker page](https://www.fmz.com/m/nodes) (see Platform Basics → Docker).\\n- An exchange account: click \\\"Add Exchange\\\" on the [Exchange page](https://www.fmz.com/m/platforms) and configure it (see Platform Basics → Exchange).\\n\\nLive robots are billed by the hour and cannot start without enough balance (see Platform Basics → Account and Billing → Live Robot Billing and Top-up).\\n\\n**Robot monitoring**\\nOn the [live trading page](https://www.fmz.com/m/robots), click \\\"Monitor\\\" in the actions column of a running robot to enable monitoring. Once enabled, the platform emails the address bound to your account when the robot exits for any reason other than a manual operation.\\n\\n**Robot database**\\nFor robot ID ```123456```, the database file is ```logs/storage/123456/123456.db3``` (```SQLite```) under the working directory of the docker running it, with these tables:\\n- chart: chart data.\\n- cfg: the latest state such as the status bar content and the chart configuration.\\n- kvdb: data persisted with the ```_G()``` function.\\n- log: robot logs.\\n- profit: profit data.\\n\\nThe same directory also holds the strategy process's standard output ```stdout.log``` and standard error ```stderr.log```.\\n\\n**In this chapter**\\n- Grouping: group management of robots and strategies.\\n- Live Trading Observation: show a robot publicly or create a private viewing link.\\n- Live Trading Message Push: push logs to the mobile app, email or a WebHook.\\n- Common Causes of Live Trading Errors and Abnormal Exits.\\n\\nTo let other people view and operate some of your robots, use sub-accounts (see Platform Basics → Account and Billing → Sub-accounts).\", \"title\": \"Live Trading\"}], \"desc\": \"The basic objects of the platform: account and billing, exchange accounts, the docker that runs strategies, the strategy library and live robots.\", \"title\": \"Platform Basics\"}, {\"_src_hash\": \"9bd1c3b66d296af2a8a0be425e2ce0320a5500f4c0502db2bf9632998304745f\", \"children\": [{\"_src_hash\": \"da09a45a5ad07a74e262294e64380fc901b1ed8d491289625d8e9a8f64b79bbf\", \"children\": [{\"_src_hash\": \"7a59706442772b7d9269eb058ebb26c33ac4d5bc18d8b6c14ab1ac312795d730\", \"desc\": \"Strategies can be written in ```JavaScript```. The runtime is based on the QuickJS engine and supports modern syntax such as ```async```/```await```, ```class``` and ```BigInt```. In live trading the strategy runs on the docker; in backtesting it runs in the browser-side backtesting system. Adding ```// @ts-check``` to the code switches to TypeScript (see Programming Languages → TypeScript).\\n\\n**Structure and parameters**\\n\\nThe entry point is ```function main()```. The optional ```init()```, ```onexit()``` and ```onerror(msg)``` are called automatically by the docker (see Writing Strategies → Strategy Structure). Interface parameters are global variables with the same names; they can be read directly and also modified in code (see Writing Strategies → Strategy Parameters).\\n\\n**Errors and return values**\\n\\nWhen an API call fails (the exchange returns an error, a network problem, etc.) it returns ```null``` and writes the error to the log. Check the return value before using it, or retry with {@fun/Global/_C _C}:\\n\\n```js\\nfunction main() {\\n var ticker = exchange.GetTicker()\\n // null when the call fails\\n if (ticker) {\\n Log(ticker)\\n }\\n\\n // retry until valid data is returned\\n var account = _C(exchange.GetAccount)\\n Log(account)\\n}\\n```\\n\\nFor program exceptions (for example reading a property of ```undefined```) and API business errors, the log shows the line number in the strategy code where the error occurred, which makes debugging easier.\\n\\n**Strings and ArrayBuffer**\\n\\nJavaScript strings are UTF-16. If text returned by a platform API is not a valid UTF-8 byte sequence, an ```ArrayBuffer``` (the raw bytes) is returned instead so that no data is lost. Every API parameter that accepts a string also accepts an ```ArrayBuffer```.\\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 // the code point of \\\"𠮷\\\" exceeds 16 bits; it takes two UTF-16 code units in a JavaScript string\\n const inputString = \\\"abc𠮷123\\\"\\n\\n // Encode outputs the UTF-8 bytes as hex\\n const encodedHex = Encode(\\\"raw\\\", \\\"string\\\", \\\"hex\\\", inputString)\\n Log(encodedHex) // 616263f0a0aeb7313233\\n\\n // charCodeAt returns UTF-16 code units, so \\\"𠮷\\\" becomes d842, dfb7 - not UTF-8\\n const manuallyEncodedHex = stringToHex(inputString)\\n Log(manuallyEncodedHex) // 616263d842dfb7313233\\n\\n // valid UTF-8 bytes decode back to a string\\n const decodedString = Encode(\\\"raw\\\", \\\"hex\\\", \\\"string\\\", encodedHex)\\n Log(decodedString) // abc𠮷123\\n\\n // bytes that are not valid UTF-8 come back as an ArrayBuffer\\n // (with inputString = \\\"abcG123\\\" both encodings are identical and this is a string)\\n const outputD = Encode(\\\"raw\\\", \\\"hex\\\", \\\"string\\\", manuallyEncodedHex)\\n Log(outputD instanceof ArrayBuffer) // true\\n\\n // inspect the raw bytes in the ArrayBuffer\\n const bufferD = new Uint8Array(outputD)\\n let hexBufferD = ''\\n for (let i = 0; i < bufferD.length; i++) {\\n hexBufferD += bufferD[i].toString(16).padStart(2, '0')\\n }\\n Log(hexBufferD) // 616263d842dfb7313233\\n}\\n```\\n\\n**Asynchrony and threads**\\n\\n- ```setTimeout```/```clearTimeout```: callbacks run while the main thread is waiting in ```Sleep()```. When ```main()``` returns, timers that have not fired yet run first, then ```onexit()``` is called.\\n- ```fetch(url)```: returns a ```Promise``` that resolves to a response object (```ok```, ```status```, ```headers```; ```text()``` and ```json()``` return the content directly). On the docker, ```fetch``` completes the request synchronously when called and returns an already settled ```Promise```, so combining several ```fetch``` calls with ```Promise.all``` does not make them concurrent.\\n- Exchange APIs (such as ```exchange.GetTicker()```) are synchronous blocking calls; wrapping them in a ```Promise``` or an ```async``` function does not make them concurrent either.\\n- For concurrency use {@fun/Threads/exchange.Go exchange.Go}, {@fun/Network/HttpQuery_Go HttpQuery_Go}, or create threads with {@fun/Threads/threading/Thread Thread} (see Advanced Topics → JavaScript Multithreading).\\n\\n```js\\nasync function main() {\\n let resp = await fetch(\\\"https://www.okx.com/api/v5/market/books?instId=BTC-USDT\\\")\\n if (resp.ok) {\\n Log(resp.json())\\n } else {\\n Log(\\\"status:\\\", resp.status)\\n }\\n}\\n```\\n\\n**Libraries and dependencies**\\n\\nJavaScript strategies can use the built-in ```TA``` and ```talib``` indicator libraries directly; see Writing Strategies → Built-in Libraries for what each language provides. Other third-party JavaScript libraries can be downloaded at run time and loaded with ```eval```; the same page has an example.\", \"title\": \"JavaScript\"}, {\"_src_hash\": \"ae30a75bf07b2e4a539e1e09487af17cde7771209aab25466afb6c50574f53a1\", \"desc\": \"TypeScript is not a separate language option. Create the strategy as ```JavaScript``` and add a ```// @ts-check``` line to the code (or click the \\\"TypeScript\\\" button at the top right of the editor); the platform then treats it as TypeScript and compiles it to JavaScript before backtesting or live trading. When a strategy is saved through the AI/MCP tools, the language can be given as ```typescript```: the platform saves it as a JavaScript strategy and adds ```//@ts-check``` at the top automatically (see External Interfaces → AI Access).\\n\\nStatic type checking catches mistakes such as wrong argument counts, property names or types while you write, and makes editor completion more accurate.\\n\\nA minimal example:\\n\\n```ts\\n// @ts-check\\ninterface Signal {\\n side: \\\"buy\\\" | \\\"sell\\\"\\n price: number\\n}\\n\\nfunction getSignal(ticker: ITicker, ma: number): Signal | null {\\n if (ticker.Last > ma) {\\n return {side: \\\"buy\\\", price: ticker.Last}\\n }\\n if (ticker.Last < ma) {\\n return {side: \\\"sell\\\", price: ticker.Last}\\n }\\n return null\\n}\\n\\nfunction main() {\\n while (true) {\\n const records = exchange.GetRecords()\\n const ticker = exchange.GetTicker()\\n if (records && ticker && records.length > 20) {\\n const ma = TA.MA(records, 20)\\n const signal = getSignal(ticker, ma[ma.length - 1])\\n if (signal) {\\n Log(signal.side, signal.price)\\n }\\n }\\n Sleep(60 * 1000)\\n }\\n}\\n```\\n\\nType declarations for the platform API are built into the strategy editor; nothing needs to be referenced in the code. They cover the global functions, the ```exchange``` object, data structure interfaces such as ```ITicker```, ```IRecord```, ```IOrder``` and ```IPosition```, and ```TA```, ```talib``` and so on. Language features, APIs and libraries at run time are the same as for JavaScript strategies (see Programming Languages → JavaScript).\", \"title\": \"TypeScript\"}, {\"_src_hash\": \"ea17b42609d0fc36aac0af41d4a3e8dd366ccee15e011cb47fe73d7a909ef420\", \"desc\": \"Strategies can be written in ```Python 3```; Python 2 is not supported. Live trading, and backtests that run on a docker, use the Python interpreter installed on the docker's machine.\\n\\n**Interpreter**\\n\\nThe docker looks for an interpreter in this order and uses the first program that starts and is Python 3:\\n1. the interpreter given by the environment variable ```PYTHON_BIN```;\\n2. ```python3```;\\n3. ```python```.\\n\\nTo use a specific interpreter (for example the Python of a virtual environment), set the environment variable before starting the docker:\\n\\n```bash\\nexport PYTHON_BIN=/opt/venv/bin/python3\\n```\\n\\nA first line such as ```#!python3``` or ```#!python2``` in the strategy is no longer used to choose the interpreter.\\n\\n**Structure and parameters**\\n\\nThe entry point is ```def main()```. The optional ```init()``` and ```onexit()``` are called automatically by the docker (Python does not support ```onerror()```); see Writing Strategies → Strategy Structure. Interface parameters are global variables with the same names; to assign a new value to one inside a function, declare it with ```global``` first.\\n\\n**Errors and return values**\\n\\nWhen an API call fails it returns ```None``` and writes the error to the log. Check the return value before using it, or retry with ```_C()```. An uncaught exception ends the strategy, and the error is recorded in the log.\\n\\n**Output**\\n\\nThe output of ```print()``` goes to the docker process's standard output and does not appear in the live trading log. Use {@fun/Log/Log Log} for anything that should show up in the log.\\n\\n**Third-party packages**\\n\\nA strategy can import any package installed in the interpreter. Install packages with the same interpreter the docker uses, for example:\\n\\n```bash\\npython3 -m pip install numpy\\n# when PYTHON_BIN is set\\n$PYTHON_BIN -m pip install numpy\\n```\\n\\nTo use ```talib```, install TA-Lib (the ```talib``` package) and ```numpy``` on the docker's machine.\\n\\n**Your own modules**\\n\\nWhile a strategy runs, its current directory and ```PYTHONPATH``` are a temporary directory created by the docker for that run and deleted afterwards; ```.py``` files placed under the docker's directory (for example ```logs/storage//```) are not found automatically. There are two ways to import your own modules:\\n- install the module into the interpreter's ```site-packages``` (for example package it and install it with ```pip install```, or copy it into the ```site-packages``` directory);\\n- in the strategy, append the absolute path of the module's directory to ```sys.path```, then import it.\\n\\nFor example, with the module file ```/home/user/fmz_modules/mymath.py```:\\n\\n```python\\n# mymath.py\\ndef add(a, b):\\n return a + b\\n```\\n\\nthe strategy code is:\\n\\n```python\\nimport sys\\nsys.path.append(\\\"/home/user/fmz_modules\\\") # absolute path of the module's directory\\n\\nimport mymath\\n\\ndef main():\\n Log(\\\"mymath.add(1, 2):\\\", mymath.add(1, 2))\\n```\\n\\nKeeping the core logic in a module on your own docker, with only the calling code in the strategy, is also a way to avoid uploading that logic to the platform.\", \"title\": \"Python\"}, {\"_src_hash\": \"bd217346b3a5f58defb5137cb132a32280695d65b3387e0711924ce9a409e038\", \"desc\": \"Strategies can be written in ```Rust```. Rust strategies are compiled before they run: for backtesting the platform server compiles them and they run in the browser-side backtesting system; in live trading they run on the docker once compiled. The strategy editor integrates ```rust-analyzer``` for Rust, with code completion and live diagnostics.\\n\\n**Structure**\\n\\nA strategy only needs a ```fn main()```. The platform API (```exchange```, ```exchanges```, ```TA```, ```Log!```, ```_C!``` and so on) is imported automatically; no ```use``` or ```mod``` declarations are needed.\\n\\nThe optional ```fn init()``` and ```fn onexit()``` are called automatically by the docker; just define them, no registration is needed. ```init()``` runs before ```main()```; ```onexit()``` runs when ```main()``` returns normally, when the live trading is stopped, and when the strategy panics. Rust does not support ```onerror()```. See Writing Strategies → Strategy Structure.\\n\\n```rust\\nfn init() {\\n Log!(\\\"initializing\\\");\\n}\\n\\nfn main() {\\n // APIs that can fail return Result; the _C! macro retries until the call succeeds\\n let ticker = _C!(exchange.GetTicker(None));\\n Log!(\\\"Last:\\\", ticker.Last);\\n}\\n\\nfn onexit() {\\n Log!(\\\"strategy exiting, cleaning up\\\");\\n}\\n```\\n\\nSome functions are macros (note the exclamation mark): ```Log!()```, ```LogStatus!()```, ```Panic!()```, ```_G!()```, ```_C!()```. ```LogProfit()```, ```Sleep()```, ```_D()```, ```_N()```, ```HttpQuery()``` and others are ordinary functions.\\n\\n**Parameter types**\\n\\nInterface parameters are injected as global constants with the same names. They can only be read, not modified in code (copy a value into a local variable if it needs to change). The type depends on the kind of parameter:\\n\\n| Parameter kind | Rust type |\\n| - | - |\\n| Number | ```f64``` |\\n| Boolean | ```bool``` |\\n| String | ```&str``` |\\n| Dropdown (single choice) | ```f64``` (option index); ```&str``` when the options are bound to string data |\\n| Dropdown (multiple choice) | ```&[i64]```, ```&[f64]``` or ```&[&str]```; JSON text as ```&str``` when the option values have mixed types |\\n| Encrypted string | ```&str``` or ```Decrypted``` (dereferences to ```str```) |\\n\\n- Convert explicitly where an integer is needed, for example ```let n = Period as usize;```.\\n- An optional parameter that is left empty has the zero value of its type: ```0.0```, ```\\\"\\\"```, ```false```, or an empty list for a multiple-choice dropdown.\\n- When the server cannot decrypt an encrypted-string parameter in advance (for example on a private docker), it is injected as a ```static``` of type ```Decrypted``` and decrypted on first use. It implements ```Display```, so it can be used directly with ```format!```; when passing it to ```Log!``` or anywhere a ```&str``` is needed, write ```&*ParamName``` (this also works for ```&str``` parameters):\\n\\n```rust\\nfn main() {\\n let key: &str = &*ApiKey; // ApiKey is an encrypted-string parameter\\n Log!(\\\"key length:\\\", key.len());\\n}\\n```\\n\\n- If a parameter name clashes with another name in the code, refer to the parameter as ```args::ParamName```.\\n\\n**Errors and return values**\\n\\nAPI calls that can fail return ```Result```; handle it the usual Rust way (in JavaScript a failed call returns ```null```):\\n\\n```rust\\nfn main() {\\n // option 1: pattern matching\\n if let Ok(ticker) = exchange.GetTicker(None) {\\n Log!(ticker);\\n }\\n\\n // option 2: the _C! macro retries until the call succeeds\\n let ticker = _C!(exchange.GetTicker(None));\\n Log!(ticker);\\n}\\n```\\n\\nOptional arguments (such as the ```symbol``` argument of ```GetTicker```) are passed as ```None``` when omitted, or given directly, for example ```exchange.GetTicker(\\\"BTC_USDT\\\")```.\\n\\n**JSON**\\n\\nRaw JSON text returned by the platform API (for example the return value of ```exchange.IO()``` or the ```Info``` field of each structure) is parsed with the built-in ```JSONParse()```, which returns an ```Option```. Navigate with ```v[\\\"key\\\"]``` and ```v[0]``` and read values with methods such as ```as_f64()```, ```as_str()``` and ```as_bool()```. ```JsonValue``` implements ```Display```, so ```v.to_string()``` or ```format!(\\\"{}\\\", v)``` gives compact JSON text. The SDK has no convenient API for building JSON; build JSON text with ```format!```, or use ```serde_json```.\\n\\n**Third-party crates**\\n\\nThe strategy source is the only code file (there is no separate ```Cargo.toml```). Declare dependencies in a frontmatter block wrapped in ```---``` at the very top of the source; it is merged into ```Cargo.toml``` at build time:\\n\\n```rust\\n---\\n[dependencies]\\nserde_json = \\\"1\\\"\\n---\\n/*backtest\\nstart: 2024-01-01 00:00:00\\nend: 2024-02-01 00:00:00\\nperiod: 1h\\n*/\\nfn main() {\\n let v: serde_json::Value = serde_json::from_str(r#\\\"{\\\"a\\\": 1}\\\"#).unwrap();\\n Log!(\\\"a:\\\", v[\\\"a\\\"].to_string());\\n}\\n```\\n\\n- The frontmatter must be at the start of the source, with only blank lines before it; the ```/*backtest ... */``` backtest configuration block goes after the closing ```---```. If the strategy has no backtest configuration block yet, \\\"Save Backtest Settings\\\" inserts one at the very top of the source; move it below the frontmatter (later saves update it in place).\\n- Between a strategy and the template libraries it references, the dependency block may appear in only one place; declaring it in both fails the build.\\n- The build environment has no system OpenSSL. For crates that need TLS (HTTP/WebSocket clients and the like), choose the pure-Rust ```rustls``` implementation (for example ```tokio-tungstenite``` with the ```rustls-tls-webpki-roots``` feature) and avoid ```native-tls```/```openssl-sys```. For WebSocket connections prefer the built-in {@fun/Network/Dial Dial} function, which needs no third-party crate.\\n\\n**Built-in libraries**\\n\\nRust strategies can use the ```TA``` indicator library; ```talib``` is not supported. See Writing Strategies → Built-in Libraries.\", \"title\": \"Rust\"}, {\"_src_hash\": \"222455c71c9ad6a58c1e0a52001bd741c110cafa9e97abf65eb24d720b3cf5af\", \"desc\": \"The platform supports MyLanguage for writing and designing strategies, compatible with most syntax, instructions and functions of Wenhua MyLanguage. MyLanguage encourages modular programming, breaking down complex algorithms into function modules. Through concise syntax, dedicated data structures and powerful financial function libraries, it supports the implementation of complex financial logic. Building applications in a modular way improves development efficiency and code maintainability.\\n\\nMyLanguage Strategy Example: System Based on Displaced Bollinger Bands\\n\\n```My\\nM := 12; // Parameter range 1, 20\\nN := 3; // Parameter range 1, 10\\nSDEV := 2; // Parameter range 1, 10\\nP := 16; // Parameter range 1, 20\\n\\n// This strategy is a trend-following trading strategy, suitable for larger timeframes such as daily charts.\\n// This model is only used as a model development case. Trading based on this carries your own risk.\\n\\n////////////////////////////////////////////////////////\\n\\n// Displaced BOLL channel calculation\\nMID:=MA(C,N); // Calculate middle band\\nTMP:=STD(C,M)*SDEV; // Calculate standard deviation\\nDISPTOP:=REF(MID,P)+TMP; // Displaced BOLL channel upper band\\nDISPBOTTOM:=REF(MID,P)-TMP; // Displaced BOLL channel lower band\\n\\n// System entry\\nH>=DISPTOP,BPK;\\nL<=DISPBOTTOM,SPK;\\nAUTOFILTER;\\n```\\n\\n- [FMZ Quant MyLanguage Documentation](https://www.fmz.com/bbs-topic/2569)\\n- [FMZ Quant MyLanguage--MyLanguage Trading Library Parameters](https://www.fmz.com/bbs-topic/5768)\", \"title\": \"MyLanguage\"}, {\"_src_hash\": \"9ad8eef5ba706db50a9a0ac3b465da6ca127d318c38f09a5ce0ef1d98d3e672a\", \"desc\": \"The platform supports and is compatible with ```Trading View```'s PINE language scripts. PINE is a lightweight yet powerful strategy programming language for creating technical indicators and strategies that can be backtested and traded live. The active community has created over 100,000 PINE scripts.\\nUsers can easily access and apply various technical analysis tools and trading strategies; leverage community scripts to quickly implement trading ideas without writing code from scratch, significantly reducing development cycles; help both beginners and experienced traders learn and understand different technical indicators, strategies, and programming concepts.\\n\\nPINE Language Strategy Example: Supertrend Strategy\\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 Documentation](https://www.fmz.com/bbs-topic/9315)\", \"title\": \"PINE Language\"}, {\"_src_hash\": \"d7f65ede4d3182836b689956aa5f69d83fd849d206b0e0e280f01acad7ce4f86\", \"desc\": \"The platform supports Blockly visual programming. With the Blockly editor, users can express code concepts such as variables, logical expressions, and loops by connecting graphical blocks (similar to building blocks). This approach allows the programming process to focus less on tedious syntax details and instead operate directly according to programming principles. Through the arrangement and combination of graphical blocks, users can easily understand programming logic and implement creative ideas, making it ideal for cultivating interest in strategy design and quickly getting started with programmatic and quantitative trading.\\n\\n - [Building Trading Strategies with Visual Modules - Introduction](https://www.fmz.com/digest-topic/4016)\\n\\n - [Building Trading Strategies with Visual Modules - Advanced](https://www.fmz.com/digest-topic/4046)\\n\\n - [Building Trading Strategies with Visual Modules - In-depth](https://www.fmz.com/digest-topic/4086)\\n\\n - [Building Trading Strategies with Visual Modules - Simplified](https://www.fmz.com/digest-topic/4107)\", \"title\": \"Blockly Visual Programming\"}, {\"_src_hash\": \"29a050e485d3a2db949fe4b78ed47c4f841742ce00c69216948b062f5cba846b\", \"desc\": \"The platform supports writing strategies using the Workflow approach. Workflow is a visual strategy design method that builds trading logic through node connections and configurations, enabling strategy implementation without writing code.\\n\\n**Workflow Features**:\\n- Visual drag-and-drop design, WYSIWYG\\n- Rich preset functional nodes (data retrieval, indicator calculation, conditional judgment, trade execution, etc.)\\n- Lower programming barrier, suitable for rapid strategy building and validation\\n- Supports backtesting functionality with visual node execution status viewing\\n\\n**Learning Resources**:\\n- [Workflow Video Tutorial Series](https://www.fmz.com/class/workflow)\", \"title\": \"Workflow\"}], \"desc\": \"**What programming languages can I use to write my strategies on the FMZ Quant trading platform?**\\n\\n\\n ![Supported Programming Languages](/upload/asset/2e52c7501f57044f7f0ef.png)\\n\\n\\n The FMZ Quant trading platform supports writing and designing trading strategies using ```JavaScript```, ```TypeScript```, ```Python```, ```Rust```, [```PINE```](https://www.fmz.com/bbs-topic/9315), [```My Language```](https://www.fmz.com/bbs-topic/2569), ```Blockly``` visual programming, and the ```Workflow``` workflow tool.\", \"title\": \"Programming Languages\"}, {\"_src_hash\": \"e82a93791633e6173c3896b2a45896047412cab2ce37f3d120ba33b7561cbf22\", \"children\": [{\"_src_hash\": \"2f9bd5d5c113779418e5c247ae1a8cdbd3a69f93fe089d3f821cd9d5f61bd2de\", \"desc\": \"```init()``` is the initialization function implemented by the user. When a strategy starts running, the ```init()``` function is automatically executed first to complete the initialization tasks designed within the strategy.\", \"examples\": [{\"examples\": [{\"code\": \"function main(){\\n Log(\\\"First line of code executed!\\\", \\\"#FF0000\\\")\\n Log(\\\"Exiting!\\\")\\n}\\n\\n// Initialization function\\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\": \"fn main() {\\n Log!(\\\"First line of code executed!\\\", \\\"#FF0000\\\");\\n Log!(\\\"Exiting!\\\");\\n}\\n\\n// Initialization function\\nfn init() {\\n Log!(\\\"Initializing!\\\");\\n}\", \"lang\": \"rust\"}]}], \"title\": \"init()\"}, {\"_src_hash\": \"0d5a56c059c9f3e258b6c7c49047e9298758d3ebdc7dfbf9fcc53af264e7fa52\", \"desc\": \"```onexit()``` is implemented by the user to clean up when the strategy exits; it is optional. It may run for at most 5 minutes and is terminated when it exceeds that. For when each language calls ```onexit()```, see Writing Strategies → Strategy Structure.\", \"examples\": [{\"examples\": [{\"code\": \"function main(){\\n Log(\\\"Starting, will stop after 5 seconds and execute cleanup function!\\\")\\n Sleep(1000 * 5)\\n}\\n\\n// cleanup function\\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\": \"fn main() {\\n Log!(\\\"Starting, will stop after 5 seconds and execute cleanup function!\\\");\\n Sleep(1000 * 5);\\n}\\n\\n// cleanup function\\nfn onexit() {\\n let beginTime = Unix() * 1000;\\n loop {\\n let nowTime = Unix() * 1000;\\n Log!(\\\"Program stop countdown..cleanup started, elapsed time:\\\", (nowTime - beginTime) / 1000, \\\"seconds!\\\");\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"Testing the ```onexit()``` function:\"}, {\"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\": \"fn onTick() {\\n loop {\\n match exchange.GetTicker(None) {\\n Ok(ticker) => LogStatus!(_D(None), ticker.Last),\\n Err(e) => {\\n // API calls return Err when the backtest ends; leaving the loop lets main return, which triggers onexit()\\n Log!(\\\"error:\\\", e);\\n break;\\n }\\n }\\n Sleep(500);\\n }\\n}\\n\\nfn main() {\\n if exchange.GetName().starts_with(\\\"Futures_\\\") {\\n Log!(\\\"Exchange is futures\\\");\\n let _ = exchange.SetContractType(\\\"swap\\\");\\n } else {\\n Log!(\\\"Exchange is spot\\\");\\n }\\n\\n onTick();\\n}\\n\\nfn onexit() {\\n Log!(\\\"Executing cleanup function\\\");\\n}\", \"lang\": \"rust\"}], \"value\": \"In the backtesting system a strategy is usually an endless polling loop, so ```main()``` has not returned normally when the backtest data ends, and ```JavaScript``` and ```Python``` strategies therefore do not run ```onexit()```. In a backtest (```IsVirtual()``` is true) you can catch the exception (EOF) thrown when the backtest ends so that ```main()``` returns and ```onexit()``` runs. In ```Rust``` the API calls return ```Err``` when the backtest ends, so just leave the loop.\"}], \"title\": \"onexit()\"}, {\"_src_hash\": \"8f8db57471be4325895c388110988cca3c94e8dabb6fb9c9e62ffcd1916b9a54\", \"desc\": \"```onerror(msg)``` is supported only by ```JavaScript``` (including TypeScript) strategies. It is called when ```main()``` ends with an uncaught exception; the argument ```msg``` is the error message. When ```onerror()``` is called, ```onexit()``` is not. It may run for at most 5 minutes and is terminated when it exceeds that. The backtesting system does not support this function.\\n\\n```Python``` and ```Rust``` strategies do not support ```onerror()```.\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var arr = []\\n Log(arr[6].Close) // deliberately raise an exception here\\n}\\n\\nfunction onerror(msg) {\\n Log(\\\"Error:\\\", msg)\\n}\", \"lang\": \"javascript\"}, {\"code\": \"# Not supported in Python\", \"lang\": \"python\"}, {\"code\": \"// Not supported in Rust\", \"lang\": \"rust\"}]}], \"title\": \"onerror()\"}, {\"_src_hash\": \"6aed994ddacb3408f322560420cff1909b0c6823c79c76c3d4d7ce4d0256b02c\", \"desc\": \"A strategy usually runs a loop in ```main()```: each round fetches market data, computes signals, places orders, then calls {@fun/Global/Sleep Sleep} to wait for the next round. In backtesting ```Sleep()``` advances backtest time and controls the replay speed; in live trading it controls the polling interval and therefore how often the exchange API is called. A loop without ```Sleep()``` calls the exchange API as fast as it can and easily hits the exchange's rate limits. To limit the API call rate on the docker, see Advanced Topics → API Rate Limit Control.\", \"examples\": [{\"examples\": [{\"code\": \"function onTick(){\\n // strategy logic goes here and is called repeatedly, e.g. print market data\\n Log(exchange.GetTicker())\\n}\\n\\nfunction main(){\\n while(true){\\n onTick()\\n // Sleep controls the polling frequency so the exchange API is not called too often\\n Sleep(60000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def onTick():\\n Log(exchange.GetTicker())\\n\\ndef main():\\n while True:\\n onTick()\\n Sleep(60000)\", \"lang\": \"python\"}, {\"code\": \"fn onTick() {\\n // strategy logic goes here and is called repeatedly, e.g. print market data\\n Log!(exchange.GetTicker(None));\\n}\\n\\nfn main() {\\n loop {\\n onTick();\\n // Sleep controls the polling frequency so the exchange API is not called too often\\n Sleep(60000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"Basic framework:\"}, {\"examples\": [{\"code\": \"function onTick(){\\n // only an example: it quickly spends all funds on orders, do not run it live\\n exchange.Buy(100, 1)\\n}\\n\\nfunction main(){\\n while(true){\\n onTick()\\n // the pause is in milliseconds; 1 second = 1000 milliseconds\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def onTick():\\n exchange.Buy(100, 1)\\n\\ndef main():\\n while True:\\n onTick()\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn onTick() {\\n // only an example: it quickly spends all funds on orders, do not run it live\\n let _ = exchange.Buy(100, 1);\\n}\\n\\nfn main() {\\n loop {\\n onTick();\\n // the pause is in milliseconds; 1 second = 1000 milliseconds\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"The simplest example: place a buy order at price 100 for amount 1 every second:\"}, {\"examples\": [{\"code\": \"function onTick() {\\n Log(\\\"K-line updated, new BAR generated\\\")\\n}\\n\\nfunction main() {\\n var exName = exchange.GetName()\\n if (exName.includes(\\\"Futures_\\\")) {\\n exchange.SetContractType(\\\"swap\\\")\\n }\\n\\n var lastTs = 0\\n while (true) {\\n var r = _C(exchange.GetRecords)\\n if (r.length > 0 && r[r.length - 1].Time != lastTs) {\\n onTick()\\n lastTs = r[r.length - 1].Time\\n }\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def onTick():\\n Log(\\\"K-line updated, new BAR generated\\\")\\n\\ndef main():\\n exName = exchange.GetName()\\n if \\\"Futures_\\\" in exName:\\n exchange.SetContractType(\\\"swap\\\")\\n\\n lastTs = 0\\n while True:\\n r = _C(exchange.GetRecords)\\n if len(r) > 0 and r[-1][\\\"Time\\\"] != lastTs:\\n onTick()\\n lastTs = r[-1][\\\"Time\\\"]\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn onTick() {\\n Log!(\\\"K-line updated, new BAR generated\\\");\\n}\\n\\nfn main() {\\n let exName = exchange.GetName();\\n if exName.contains(\\\"Futures_\\\") {\\n let _ = exchange.SetContractType(\\\"swap\\\");\\n }\\n\\n let mut lastTs = 0;\\n loop {\\n let r = _C!(exchange.GetRecords(None, None, None));\\n if r.len() > 0 && r[r.len() - 1].Time != lastTs {\\n onTick();\\n lastTs = r[r.len() - 1].Time;\\n }\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"A strategy that acts on K-line updates (On Bar): ```onTick()``` runs only when the time of the latest K-line changes:\"}], \"title\": \"Main Loop\"}, {\"_src_hash\": \"8cc0fa8a167ab65432ee570f121da32982a16656a9578169a951c4aa81232258\", \"desc\": \"Besides polling at a fixed interval, a strategy can wait for events and handle them as they arrive, which avoids useless requests and reacts faster to market changes.\\n\\n**EventLoop**\\n\\n{@fun/Threads/EventLoop EventLoop} waits for events such as the completion of concurrent tasks started with ```exchange.Go()``` or ```HttpQuery_Go()```, readable data on a WebSocket connection, or thread messages; when one occurs it returns the event information and the strategy then reads the corresponding data. Events are recorded only from the first call of ```EventLoop()```, so call ```EventLoop(-1)``` once before starting concurrent tasks:\\n\\n```js\\nfunction main() {\\n EventLoop(-1) // start recording events so none are missed\\n var r1 = exchange.Go(\\\"GetTicker\\\")\\n var r2 = exchange.Go(\\\"GetDepth\\\")\\n var ev = EventLoop(1000) // wait up to 1 second for either task to finish\\n Log(\\\"event:\\\", ev)\\n Log(\\\"ticker:\\\", r1.wait(), \\\"depth:\\\", r2.wait())\\n}\\n```\\n\\n**ctx.subscribe / ctx.poll**\\n\\n```JavaScript``` and ```Rust``` strategies can also use the docker's event subscription interface: ```ctx.subscribe()``` subscribes to market data or order updates for an account and symbol and returns a stream ID; ```ctx.poll()``` takes the next event (optionally with a timeout), and the strategy handles it according to its ```kind```. ```Python``` strategies do not support it.\\n\\n```js\\nfunction main() {\\n ctx.subscribe(0, \\\"BTC_USDT\\\", {channel: \\\"ticker\\\"}) // the first argument is the account's index in exchanges\\n ctx.subscribe(0, \\\"\\\", {channel: \\\"orders\\\"}) // order updates\\n while (true) {\\n const ev = ctx.poll([], 1000) // [] means all subscriptions; wait up to 1 second\\n if (!ev) {\\n continue\\n }\\n if (ev.kind === 1) {\\n Log(\\\"ticker:\\\", ev.symbol, ev.bid, ev.ask, ev.last)\\n } else if (ev.kind === 16) {\\n Log(\\\"order:\\\", ev.id, ev.state, ev.filledQty)\\n }\\n }\\n}\\n```\\n\\n- ```channel``` can be ```\\\"ticker\\\"```, ```\\\"bbo\\\"```, ```\\\"depth\\\"```, ```\\\"trade\\\"```, ```\\\"kline\\\"``` (```interval``` is the period in seconds) or ```\\\"orders\\\"```.\\n- Event ```kind```: 1 ticker, 3 depth (the event only signals that the order book changed; read the levels with ```ctx.book(ev.ex, ev.symbol, n)```), 4 trade, 5 K-line, 16 order update.\\n- If market data subscriptions are not consumed in time, only the latest data is kept or the oldest is dropped; order updates are never dropped, so the strategy must keep calling ```ctx.poll()```.\\n\\nIn ```Rust``` the calls are ```ctx::subscribe()``` and ```ctx::poll()```; events are raw structures whose prices and quantities are fixed-point integers:\\n\\n```rust\\nfn main() {\\n let s = ctx::subscribe(0, \\\"BTC_USDT\\\", ctx::SubOpts::ticker()).unwrap();\\n loop {\\n match ctx::poll(&[s], Some(1000)) {\\n ctx::Polled::Event(ev) => Log!(\\\"event kind:\\\", ev.kind),\\n ctx::Polled::Stopped => break,\\n _ => {}\\n }\\n }\\n}\\n```\", \"title\": \"Event-Driven\"}, {\"_src_hash\": \"4dcc455703f8f18b2c3de75fe9b8d87ec961a775be8c8b80935d80afcc3b346f\", \"desc\": [\"Every function, structure and constant of the API reference, grouped by its category, with a one-line description; click a name for the full page. This page is generated from the reference by ```doc_tools/gen_api_index.py```.\\n\\n## Built-in Functions\\n\\n### Global\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Global/Version Version} | Returns the current system version number. |\\n| {@fun/Global/IsVirtual IsVirtual} | Used to determine whether the strategy's runtime environment is the backtesting system. |\\n| {@fun/Global/GetOS GetOS} | Retrieves the operating system information of the device hosting the bot. |\\n| {@fun/Global/GetPid GetPid} | Get the ID of the live trading process. |\\n| {@fun/Global/GetMeta GetMeta} | Get the ```Meta``` value written when generating the strategy registration code. |\\n| {@fun/Global/Sleep Sleep} | The sleep function pauses program execution for a specified period of time. |\\n| {@fun/Global/Unix Unix} | Get the second-level timestamp of the current moment. |\\n| {@fun/Global/UnixNano UnixNano} | Get the nanosecond-level timestamp of the current moment. |\\n| {@fun/Global/_D _D} | Convert a millisecond-level timestamp or a ```Date``` object into a time string. |\\n| {@fun/Global/GetCommand GetCommand} | Get the strategy's interactive command. |\\n| {@fun/Global/GetLastError GetLastError} | Retrieves the most recent error message. |\\n| {@fun/Global/SetErrorFilter SetErrorFilter} | Filters error logs. |\\n| {@fun/Global/_N _N} | Format a floating-point number. |\\n| {@fun/Global/_C _C} | A retry function used for fault-tolerant handling of interface calls. |\\n| {@fun/Global/_Cross _Cross} | Returns the number of crossover periods between array ```arr1``` and array ```arr2```. |\\n| {@fun/Global/JSON.parse JSON.parse} | The ```JSON.parse``` function is a method of the **ECMAScript** standard built-in object ```JSON```, used to decode (parse) a JSON string. |\\n| {@fun/Global/JSON.stringify JSON.stringify} | The ```JSON.stringify``` function is a method of the **ECMAScript** standard built-in object ```JSON```, used to convert JavaScript values to JSON strings. |\\n| {@fun/Global/Encode Encode} | This function encodes data according to the parameters passed in. |\\n| {@fun/Global/MD5 MD5} | Calculate the MD5 hash of the parameter ```data```. |\\n| {@fun/Global/UUID UUID} | Create a UUID. |\\n\\n### Log\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Log/Log Log} | The ```Log()``` function is used to output logs. |\\n| {@fun/Log/LogStatus LogStatus} | Outputs information to the status bar on the backtesting system or the live trading page. |\\n| {@fun/Log/LogProfit LogProfit} | Records and prints the profit/loss value, and plots the equity curve based on the profit/loss value. |\\n| {@fun/Log/LogProfitReset LogProfitReset} | Clear all profit logs and the profit chart. |\\n| {@fun/Log/LogReset LogReset} | Clear the logs. |\\n| {@fun/Log/LogVacuum LogVacuum} | Used to reclaim the storage space occupied by deleted data in **SQLite** after clearing logs with the ```LogReset()``` function. |\\n| {@fun/Log/EnableLog EnableLog} | Enable or disable logging of order information. |\\n| {@fun/Log/Chart Chart} | Custom chart plotting function. |\\n| {@fun/Log/KLineChart KLineChart} | This function is used to perform custom drawing while a strategy is running, using a drawing approach similar to the ```Pine``` language. |\\n| {@fun/Log/console.log console.log} | Used to output debug information in the \\\"Debug Info\\\" section of the live trading page. |\\n| {@fun/Log/console.error console.error} | Used to output error messages in the \\\"Debug Information\\\" section of the live trading page. |\\n| {@fun/Log/exchange.Log exchange.Log} | The ```exchange.Log()``` function is used to output order placement and cancellation logs in the log column area. |\\n\\n### Market\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Market/exchange.GetTicker exchange.GetTicker} | Retrieves the Ticker structure (i.e., the market data) corresponding to the spot or contract of the currently configured trading pair and contract code. |\\n| {@fun/Market/exchange.GetTickers exchange.GetTickers} | The ```exchange.GetTickers()``` function is used to retrieve aggregated market data from the exchange (an array of Ticker structures). |\\n| {@fun/Market/exchange.GetDepth exchange.GetDepth} | Gets the Depth structure, i.e. |\\n| {@fun/Market/exchange.GetTrades exchange.GetTrades} | Gets the Trade structure array of the spot or futures corresponding to the currently set trading pair and contract code, i.e. |\\n| {@fun/Market/exchange.GetRecords exchange.GetRecords} | Get the Record structure array (i.e. |\\n| {@fun/Market/exchange.GetMarkets exchange.GetMarkets} | The ```exchange.GetMarkets()``` function is used to retrieve market information from the exchange. |\\n| {@fun/Market/exchange.GetRawJSON exchange.GetRawJSON} | Get the raw content returned by the most recent ```rest``` request from the current exchange object (exchange, exchanges). |\\n| {@fun/Market/exchange.SetData exchange.SetData} | The ```exchange.SetData()``` function is used to set the data loaded when the strategy is running. |\\n| {@fun/Market/exchange.GetData exchange.GetData} | The ```exchange.GetData()``` function is used to retrieve data loaded by the ```exchange.SetData()``` function, or data provided by an external link. |\\n\\n### Trade\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Trade/exchange.Buy exchange.Buy} | The ```exchange.Buy()``` function is used to place a buy order. |\\n| {@fun/Trade/exchange.Sell exchange.Sell} | The ```exchange.Sell()``` function is used to place a sell order. |\\n| {@fun/Trade/exchange.CreateOrder exchange.CreateOrder} | ```exchange.CreateOrder()``` function is used to place orders. |\\n| {@fun/Trade/exchange.ModifyOrder exchange.ModifyOrder} | The ```exchange.ModifyOrder()``` function is used to modify an existing regular order, allowing you to modify the order's price and quantity. |\\n| {@fun/Trade/exchange.CancelOrder exchange.CancelOrder} | The ```exchange.CancelOrder()``` function is used to cancel an order. |\\n| {@fun/Trade/exchange.GetOrder exchange.GetOrder} | The ```exchange.GetOrder()``` function is used to obtain order information. |\\n| {@fun/Trade/exchange.GetOrders exchange.GetOrders} | The ```exchange.GetOrders()``` function is used to obtain the current unfilled orders. |\\n| {@fun/Trade/exchange.GetHistoryOrders exchange.GetHistoryOrders} | ```exchange.GetHistoryOrders()``` function is used to retrieve the historical orders of the current trading pair or contract, and supports specifying a parti... |\\n| {@fun/Trade/exchange.CreateConditionOrder exchange.CreateConditionOrder} | The ```exchange.CreateConditionOrder()``` function is used to create a conditional order. |\\n| {@fun/Trade/exchange.ModifyConditionOrder exchange.ModifyConditionOrder} | The ```exchange.ModifyConditionOrder()``` function is used to modify an existing conditional order, allowing modification of the order amount, trigger condit... |\\n| {@fun/Trade/exchange.CancelConditionOrder exchange.CancelConditionOrder} | ```exchange.CancelConditionOrder()``` function is used to cancel a conditional order. |\\n| {@fun/Trade/exchange.GetConditionOrder exchange.GetConditionOrder} | The ```exchange.GetConditionOrder()``` function is used to retrieve information about a specified conditional order. |\\n| {@fun/Trade/exchange.GetConditionOrders exchange.GetConditionOrders} | ```exchange.GetConditionOrders()``` function is used to obtain unfinished conditional orders (conditional orders that have not yet been triggered or canceled). |\\n| {@fun/Trade/exchange.GetHistoryConditionOrders exchange.GetHistoryConditionOrders} | The ```exchange.GetHistoryConditionOrders()``` function is used to retrieve the historical conditional orders (including triggered, canceled, and expired con... |\\n\\n### Account\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Account/exchange.GetAccount exchange.GetAccount} | The ```exchange.GetAccount()``` function is used to request the exchange account information. |\\n| {@fun/Account/exchange.GetAssets exchange.GetAssets} | The ```exchange.GetAssets``` function is used to request the asset information of the exchange account. |\\n\\n### Futures\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Futures/exchange.SetContractType exchange.SetContractType} | The ```exchange.SetContractType()``` function is used to set the current contract code of the exchange exchange object. |\\n| {@fun/Futures/exchange.GetContractType exchange.GetContractType} | The ```exchange.GetContractType()``` function is used to get the contract code currently set for the exchange exchange object. |\\n| {@fun/Futures/exchange.SetDirection exchange.SetDirection} | The ```exchange.SetDirection()``` function is used to set the order direction when calling the exchange.Buy function or exchange.Sell function to place futur... |\\n| {@fun/Futures/exchange.SetMarginLevel exchange.SetMarginLevel} | The ```exchange.SetMarginLevel()``` function is used to set the leverage value for the trading pair or contract specified by the ```symbol``` parameter. |\\n| {@fun/Futures/exchange.GetPositions exchange.GetPositions} | ```exchange.GetPositions()``` function is used to get position information; the ```GetPositions()``` function is a member function of the exchange object exc... |\\n| {@fun/Futures/exchange.GetFundings exchange.GetFundings} | The ```exchange.GetFundings()``` function is used to obtain the funding rate data for the current period. |\\n\\n### Exchange\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Exchange/exchange.GetName exchange.GetName} | The ```exchange.GetName()``` function is used to get the name of the exchange bound to the current exchange object. |\\n| {@fun/Exchange/exchange.GetLabel exchange.GetLabel} | The ```exchange.GetLabel()``` function is used to obtain the custom label set when configuring the exchange object. |\\n| {@fun/Exchange/exchange.GetCurrency exchange.GetCurrency} | The ```exchange.GetCurrency()``` function is used to get the currently set trading pair. |\\n| {@fun/Exchange/exchange.SetCurrency exchange.SetCurrency} | The ```exchange.SetCurrency()``` function is used to switch the current trading pair of the exchange object exchange. |\\n| {@fun/Exchange/exchange.GetQuoteCurrency exchange.GetQuoteCurrency} | The ```exchange.GetQuoteCurrency()``` function is used to get the name of the quote currency of the current trading pair, i.e. |\\n| {@fun/Exchange/exchange.GetPeriod exchange.GetPeriod} | Retrieves the K-line period configured on the FMZ Quant Trading platform website page when running a strategy in backtesting or live trading, i.e., the defau... |\\n| {@fun/Exchange/exchange.SetMaxBarLen exchange.SetMaxBarLen} | Set the maximum length of the K-line (candlestick chart). |\\n| {@fun/Exchange/exchange.SetPrecision exchange.SetPrecision} | The ```exchange.SetPrecision()``` function is used to set the precision of the **price** and **order amount** for the ```exchange``` exchange object. |\\n| {@fun/Exchange/exchange.GetRate exchange.GetRate} | Get the exchange rate currently set for the exchange object. |\\n| {@fun/Exchange/exchange.SetRate exchange.SetRate} | Sets the current exchange rate for the exchange object. |\\n| {@fun/Exchange/exchange.SetBase exchange.SetBase} | The ```exchange.SetBase()``` function is used to set the base URL of the exchange API interface used by the exchange exchange object. |\\n| {@fun/Exchange/exchange.GetBase exchange.GetBase} | The ```exchange.GetBase()``` function is used to get the base address of the current exchange API interface. |\\n| {@fun/Exchange/exchange.SetProxy exchange.SetProxy} | The ```exchange.SetProxy()``` function is used to configure the proxy settings of the exchange exchange object. |\\n| {@fun/Exchange/exchange.SetTimeout exchange.SetTimeout} | The ```exchange.SetTimeout()``` function is used to set the timeout for ```rest``` requests of the exchange exchange object. |\\n| {@fun/Exchange/exchange.Encode exchange.Encode} | The ```exchange.Encode()``` function is used to perform signature and encryption computations. |\\n\\n### IO\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/IO/exchange.IO exchange.IO} | ```exchange.IO()``` function is used to call other interfaces related to the exchange object. |\\n| ```exchange.IO(\\\"api\\\", ...)``` | ```exchange.IO(\\\"api\\\", ...)``` calls a raw REST endpoint of the exchange that has no wrapper function; the platform signs the request. |\\n| ```exchange.IO(\\\"currency\\\", ...)``` | ```exchange.IO(\\\"currency\\\", ...)``` switches the current trading pair of the exchange object at runtime. |\\n| ```exchange.IO(\\\"base\\\", ...)``` | ```exchange.IO(\\\"base\\\", ...)``` switches the base address of the trading API, and ```exchange.IO(\\\"mbase\\\", ...)``` that of the market data API. |\\n| ```exchange.IO(mode, value)``` | ```exchange.IO(mode, value)``` switches trading modes of the exchange: simulated or live, cross or isolated margin, hedge or one-way positions, unified accou... |\\n| ```exchange.IO(\\\"rate\\\", ...)``` | ```exchange.IO(\\\"rate\\\", ...)``` and ```exchange.IO(\\\"quota\\\", ...)``` limit how often API functions are called. |\\n\\n### Network\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Network/HttpQuery HttpQuery} | Sends an HTTP request. |\\n| {@fun/Network/HttpQuery_Go HttpQuery_Go} | Sends an Http request. |\\n| {@fun/Network/Dial Dial} | Used for raw ```Socket``` access, supporting the ```tcp```, ```udp```, ```tls```, and ```unix``` protocols. |\\n| {@fun/Network/Mail Mail} | Send an email. |\\n| {@fun/Network/Mail_Go Mail_Go} | Asynchronous version of the ```Mail``` function. |\\n\\n### Storage\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Storage/_G _G} | Persistently store data. |\\n| {@fun/Storage/DBExec DBExec} | Database interface function. |\\n| {@fun/Storage/SetChannelData SetChannelData} | Publishes the latest status data to a channel. |\\n| {@fun/Storage/GetChannelData GetChannelData} | Subscribes to the channel data of a specified live trading bot. |\\n\\n### Threads\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/exchange.Go exchange.Go} | Multi-threaded asynchronous support function that can convert the operations of all supported functions into asynchronous concurrent execution. |\\n| {@fun/Threads/EventLoop EventLoop} | Listens for events and returns when any ```WebSocket``` has readable data, or when concurrent tasks such as ```exchange.Go()``` or ```HttpQuery_Go()``` compl... |\\n\\n#### Threads/threading\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/threading/Thread Thread} | The ```Thread()``` function is used to create concurrent threads. |\\n| {@fun/Threads/threading/getThread getThread} | The ```getThread()``` function is used to get a thread object based on the specified thread ID. |\\n| {@fun/Threads/threading/mainThread mainThread} | The ```mainThread()``` function is used to get the thread object of the main thread, which is the thread where the ```main()``` function in the strategy is l... |\\n| {@fun/Threads/threading/currentThread currentThread} | The ```currentThread()``` function is used to get the thread object of the current thread. |\\n| {@fun/Threads/threading/Lock Lock} | The ```Lock()``` function is used to create a thread lock object. |\\n| {@fun/Threads/threading/Condition Condition} | The ```Condition()``` function is used to create a condition variable object, which is used to implement synchronization and communication between threads in... |\\n| {@fun/Threads/threading/Event Event} | The ```Event()``` function is used to create a *thread event* object, which is used for synchronization between threads, allowing one thread to wait for noti... |\\n| {@fun/Threads/threading/Dict Dict} | The ```Dict()``` function is used to create a dictionary object for passing and sharing data between concurrent threads. |\\n| {@fun/Threads/threading/Serve Serve} | The ```Serve()``` function starts an HTTP, TCP or WebSocket (over HTTP) service inside the strategy process and returns a Server object. |\\n| {@fun/Threads/threading/pending pending} | The ```pending``` function is used to get the number of concurrent threads currently running in the strategy program. |\\n\\n#### Threads/Thread\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/Thread/peekMessage peekMessage} | The ```peekMessage()``` function is used to receive messages from a thread. |\\n| {@fun/Threads/Thread/postMessage postMessage} | The ```postMessage()``` function is used to send messages to a thread. |\\n| {@fun/Threads/Thread/join join} | The ```join()``` function is used to wait for a thread to exit and reclaim system resources. |\\n| {@fun/Threads/Thread/terminate terminate} | The ```terminate()``` function is used to forcibly terminate a thread and release the hardware resources occupied when the thread was created. |\\n| {@fun/Threads/Thread/getData getData} | The ```getData()``` function is used to access variables recorded in the thread environment. |\\n| {@fun/Threads/Thread/setData setData} | The ```setData()``` function is used to store variables in the thread environment. |\\n| {@fun/Threads/Thread/id id} | The ```id()``` function is used to return the ```threadId``` of the current multi-threaded object instance. |\\n| {@fun/Threads/Thread/name name} | The ```name()``` function is used to return the name of the current multi-threaded object instance. |\\n| {@fun/Threads/Thread/eventLoop eventLoop} | The ```eventLoop()``` function is used to listen for events received by the current thread. |\\n\\n#### Threads/ThreadLock\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/ThreadLock/acquire acquire} | The ```acquire()``` function is used to request a thread lock (acquire lock). |\\n| {@fun/Threads/ThreadLock/release release} | The ```release()``` function is used to release a thread lock (unlock). |\\n\\n#### Threads/ThreadEvent\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/ThreadEvent/set set} | The ```set()``` function is used to set an event signal. |\\n| {@fun/Threads/ThreadEvent/clear clear} | The ```clear()``` function is used to clear the signal. |\\n| {@fun/Threads/ThreadEvent/wait wait} | The ```wait()``` function is used to set event (signal) waiting, which will block until the event (signal) is set; supports setting timeout parameters. |\\n| {@fun/Threads/ThreadEvent/isSet isSet} | The ```isSet()``` function is used to determine whether an event (signal) has been set. |\\n\\n#### Threads/ThreadCondition\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/ThreadCondition/notify notify} | The ```notify()``` function is used to wake up one waiting thread (if any exists). |\\n| {@fun/Threads/ThreadCondition/notifyAll notifyAll} | The ```notifyAll()``` function is used to wake up all waiting threads. |\\n| {@fun/Threads/ThreadCondition/wait wait} | The ```wait()``` function is used to put a thread into a waiting state under specific conditions. |\\n| {@fun/Threads/ThreadCondition/acquire acquire} | The ```acquire()``` function is used to request a thread lock (acquire lock). |\\n| {@fun/Threads/ThreadCondition/release release} | The ```release()``` function is used to release the thread lock (unlock). |\\n\\n#### Threads/ThreadDict\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/ThreadDict/get get} | The ```get()``` function is used to retrieve the value of a key recorded in a dictionary object. |\\n| {@fun/Threads/ThreadDict/set set} | The ```set()``` function is used to set key-value pairs. |\\n\\n#### Threads/Server\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Threads/Server/addr addr} | The ```addr()``` function returns the address and port the service actually listens on. |\\n| {@fun/Threads/Server/close close} | The ```close()``` function stops accepting new connections; handlers already running finish normally (graceful shutdown). |\\n| {@fun/Threads/Server/stop stop} | The ```stop()``` function closes the service (as ```close()```) and then terminates every handler thread that is still running. |\\n| {@fun/Threads/Server/join join} | The ```join()``` function waits until the service is closed and no handler is running. |\\n| {@fun/Threads/Server/pending pending} | The ```pending()``` function returns the number of handlers currently running, i.e. |\\n\\n### Web3\\n\\n| Name | Description |\\n| - | - |\\n| ```exchange.IO(\\\"abi\\\", ...)``` | On the FMZ Quant Trading Platform, various blockchain-related functions and calls are mainly implemented through the ```exchange.IO()``` function. |\\n| ```exchange.IO(\\\"api\\\", blockChain, ...)``` | The ```exchange.IO(\\\"api\\\", \\\"eth\\\", ...)``` calling method is used to call Ethereum RPC methods (select eth when configuring the Web3 exchange object). |\\n| ```exchange.IO(\\\"encode\\\", ...)``` | The ```exchange.IO(\\\"encode\\\", ...)``` function is called in this way for data encoding. |\\n| ```exchange.IO(\\\"encodePacked\\\", ...)``` | The ```exchange.IO(\\\"encodePacked\\\", ...)``` function is used to perform ```encodePacked``` encoding operations. |\\n| ```exchange.IO(\\\"decode\\\", ...)``` | The ```exchange.IO(\\\"decode\\\", ...)``` calling method is used to decode data. |\\n| ```exchange.IO(\\\"hash\\\", ...)``` | The ```exchange.IO(\\\"hash\\\", ...)``` call computes hash digests and HMACs, signs with the private key configured on the exchange object, and so on. |\\n| ```exchange.IO(\\\"key\\\", ...)``` | The ```exchange.IO(\\\"key\\\", ...)``` function is used to switch the private key calling method. |\\n| ```exchange.IO(\\\"sign\\\", ...)``` | The ```exchange.IO(\\\"sign\\\", ...)``` calling method is used to sign a 32-byte hash with a secp256k1 private key and returns signature data such as r, s, and v. |\\n| ```exchange.IO(\\\"signTypedData\\\", ...)``` | The ```exchange.IO(\\\"signTypedData\\\", ...)``` calling method is used to sign structured data according to the EIP-712 standard. |\\n| ```exchange.IO(\\\"signMessage\\\", ...)``` | The ```exchange.IO(\\\"signMessage\\\", ...)``` calling method is used to sign messages according to the EIP-191 standard (```personal_sign```). |\\n| ```exchange.IO(\\\"api\\\", ...)``` | The ```exchange.IO(\\\"api\\\", ...)``` calling method is used to call methods of smart contracts. |\\n| ```exchange.IO(\\\"call\\\", ...)``` | The ```exchange.IO(\\\"call\\\", ...)``` calling method simulates the execution of any smart contract method (including write methods that modify on-chain state) v... |\\n| ```exchange.IO(\\\"multicall\\\", ...)``` | The ```exchange.IO(\\\"multicall\\\", ...)``` calling method is used to batch-read the results of multiple contract calls in a single request through the Multicall... |\\n| ```exchange.IO(\\\"logs\\\", ...)``` | The ```exchange.IO(\\\"logs\\\", ...)``` calling method is used to query the event logs of a contract (```eth_getLogs```) and decode them according to the ABI. |\\n| ```exchange.IO(\\\"waitReceipt\\\", ...)``` | The ```exchange.IO(\\\"waitReceipt\\\", ...)``` calling method is used to wait for a transaction to be included on-chain and reach the specified number of confirma... |\\n| ```exchange.IO(\\\"nonce\\\", ...)``` | The ```exchange.IO(\\\"nonce\\\", ...)``` function call is used to query, synchronize, or set the nonce counter used when sending transactions. |\\n| ```exchange.IO(\\\"speedUp\\\", ...)``` | The ```exchange.IO(\\\"speedUp\\\", ...)``` call is used to resend a stuck transaction (one that has not been mined for a long time) with a higher fee: the recipie... |\\n| ```exchange.IO(\\\"cancelTx\\\", ...)``` | The ```exchange.IO(\\\"cancelTx\\\", ...)``` calling method is used to cancel a transaction that has not yet been included on-chain: it sends a zero-amount transac... |\\n| ```exchange.IO(\\\"toUnits\\\", ...)``` | The ```exchange.IO(\\\"toUnits\\\", ...)``` function call is used to convert a human-readable amount into an on-chain integer. |\\n| ```exchange.IO(\\\"fromUnits\\\", ...)``` | The ```exchange.IO(\\\"fromUnits\\\", ...)``` calling method is used to convert an on-chain integer value into a human-readable amount. |\\n| ```exchange.IO(\\\"uniswapV3\\\", ...)``` | The ```exchange.IO(\\\"uniswapV3\\\", ...)``` calling method is used for concentrated liquidity (Uniswap V3) related calculations, including conversions between ti... |\\n| ```exchange.IO(\\\"contracts\\\", ...)``` | The ```exchange.IO(\\\"contracts\\\", ...)``` call is used to obtain commonly used contract addresses on the current chain (or a specified chain), including mainst... |\\n| {@fun/Web3/exchange.IO(\\\"address\\\") exchange.IO(\\\"address\\\")} | The ```exchange.IO(\\\"address\\\")``` call returns the address of the wallet configured on the exchange object. |\\n| ```exchange.IO(\\\"base\\\", ...)``` | The ```exchange.IO(\\\"base\\\", ...)``` calling method is used to set the RPC node address, and supports setting multiple nodes as backups for each other. |\\n| ```exchange.IO(\\\"sendBase\\\", ...)``` | The ```exchange.IO(\\\"sendBase\\\", ...)``` call is used to set a node dedicated solely to broadcasting transactions. |\\n\\n### Uniswap\\n\\n| Name | Description |\\n| - | - |\\n| ```exchange.IO(\\\"transfer\\\", ...)``` | The ```exchange.IO(\\\"transfer\\\", ...)``` call transfers the chain's native coin (such as ETH or BNB) or an ERC20 token out of the wallet configured on the Unis... |\\n| ```exchange.IO(\\\"receipt\\\", ...)``` | When called as ```exchange.IO(\\\"receipt\\\", ...)```, this function queries the receipt of a transaction sent by the Uniswap exchange object (such as an order or... |\\n| ```exchange.IO(\\\"route\\\", ...)``` | The ```exchange.IO(\\\"route\\\", ...)``` call requests quotes on a Uniswap exchange object. |\\n| ```exchange.IO(\\\"simulate\\\", ...)``` | The ```exchange.IO(\\\"simulate\\\", ...)``` call builds a swap transaction using the same order logic as the Uniswap exchange object (route selection, quoting and... |\\n| ```exchange.IO(\\\"token\\\", ...)``` | The ```exchange.IO(\\\"token\\\", ...)``` call is used to register a token on a Uniswap exchange object, or to list the token table. |\\n| ```exchange.IO(\\\"wrap\\\", ...)``` | The ```exchange.IO(\\\"wrap\\\", ...)``` call wraps the native coin (ETH, BNB) into the wrapped coin (WETH, WBNB) on a Uniswap exchange object: 1:1, no slippage, o... |\\n| ```exchange.IO(\\\"unwrap\\\", ...)``` | The ```exchange.IO(\\\"unwrap\\\", ...)``` call unwraps the wrapped coin (WETH, WBNB) into the native coin (ETH, BNB) on a Uniswap exchange object: 1:1, no slippag... |\\n| ```exchange.IO(\\\"approve\\\", ...)``` | When called as ```exchange.IO(\\\"approve\\\", ...)```, this function sets the token approval mode on a Uniswap exchange object. |\\n| ```exchange.IO(\\\"slippage\\\", ...)``` | When called this way, ```exchange.IO(\\\"slippage\\\", ...)``` sets slippage protection for market orders on a Uniswap exchange object. |\\n| ```exchange.IO(\\\"deadline\\\", ...)``` | The ```exchange.IO(\\\"deadline\\\", ...)``` call sets the transaction deadline on a Uniswap exchange object. |\\n| ```exchange.IO(\\\"gasMultiplier\\\", ...)``` | ```exchange.IO(\\\"gasMultiplier\\\", ...)``` is used to set the gas limit multiplier on a Uniswap exchange object. |\\n\\n### TA\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/TA/TA.MACD TA.MACD} | The ```TA.MACD()``` function is used to calculate the **Moving Average Convergence Divergence (MACD) indicator**. |\\n| {@fun/TA/TA.KDJ TA.KDJ} | The ```TA.KDJ()``` function is used to calculate the **Stochastic Oscillator (KDJ)**. |\\n| {@fun/TA/TA.RSI TA.RSI} | The ```TA.RSI()``` function is used to calculate the **Relative Strength Index (RSI)**. |\\n| {@fun/TA/TA.ATR TA.ATR} | The ```TA.ATR()``` function is used to calculate the **Average True Range indicator (ATR)**. |\\n| {@fun/TA/TA.OBV TA.OBV} | ```TA.OBV()``` function is used to calculate the **On-Balance Volume (OBV)**. |\\n| {@fun/TA/TA.MA TA.MA} | The ```TA.MA()``` function is used to calculate the **Moving Average indicator (Moving Average)**. |\\n| {@fun/TA/TA.EMA TA.EMA} | The ```TA.EMA()``` function is used to calculate the **Exponential Moving Average (EMA) indicator**. |\\n| {@fun/TA/TA.BOLL TA.BOLL} | The ```TA.BOLL()``` function is used to calculate the **Bollinger Bands indicator**. |\\n| {@fun/TA/TA.Alligator TA.Alligator} | ```TA.Alligator()``` function is used to calculate the **Alligator indicator**. |\\n| {@fun/TA/TA.CMF TA.CMF} | The ```TA.CMF()``` function is used to calculate the **Chaikin Money Flow (CMF)** indicator. |\\n| {@fun/TA/TA.Highest TA.Highest} | The ```TA.Highest()``` function is used to calculate the **highest price within a period**. |\\n| {@fun/TA/TA.Lowest TA.Lowest} | The ```TA.Lowest()``` function is used to calculate the **lowest price over a period**. |\\n| {@fun/TA/TA.SMA TA.SMA} | The ```TA.SMA()``` function is used to calculate the **Simple Moving Average (SMA) indicator**. |\\n\\n#### Talib/OverlapStudies\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/OverlapStudies/talib.BBANDS talib.BBANDS} | The ```talib.BBANDS()``` function is used to calculate **Bollinger Bands**. |\\n| {@fun/Talib/OverlapStudies/talib.DEMA talib.DEMA} | The ```talib.DEMA()``` function is used to calculate **Double Exponential Moving Average**. |\\n| {@fun/Talib/OverlapStudies/talib.EMA talib.EMA} | The ```talib.EMA()``` function is used to calculate **Exponential Moving Average**. |\\n| {@fun/Talib/OverlapStudies/talib.HT_TRENDLINE talib.HT_TRENDLINE} | The ```talib.HT_TRENDLINE()``` function is used to calculate **Hilbert Transform - Instantaneous Trendline**. |\\n| {@fun/Talib/OverlapStudies/talib.KAMA talib.KAMA} | The ```talib.KAMA()``` function is used to calculate **Kaufman Adaptive Moving Average**. |\\n| {@fun/Talib/OverlapStudies/talib.MA talib.MA} | The ```talib.MA()``` function is used to calculate **Moving average**. |\\n| {@fun/Talib/OverlapStudies/talib.MAMA talib.MAMA} | The ```talib.MAMA()``` function is used to calculate the **MESA Adaptive Moving Average**. |\\n| {@fun/Talib/OverlapStudies/talib.MIDPOINT talib.MIDPOINT} | The ```talib.MIDPOINT()``` function is used to calculate **MidPoint over period**. |\\n| {@fun/Talib/OverlapStudies/talib.MIDPRICE talib.MIDPRICE} | The ```talib.MIDPRICE()``` function is used to calculate **Midpoint Price over period**. |\\n| {@fun/Talib/OverlapStudies/talib.SAR talib.SAR} | The ```talib.SAR()``` function is used to calculate the **Parabolic SAR (Stop and Reverse)** indicator. |\\n| {@fun/Talib/OverlapStudies/talib.SAREXT talib.SAREXT} | The ```talib.SAREXT()``` function is used to calculate **Parabolic SAR - Extended**. |\\n| {@fun/Talib/OverlapStudies/talib.SMA talib.SMA} | The ```talib.SMA()``` function is used to calculate **Simple Moving Average**. |\\n| {@fun/Talib/OverlapStudies/talib.T3 talib.T3} | The ```talib.T3()``` function is used to calculate **Triple Exponential Moving Average (T3)**. |\\n| {@fun/Talib/OverlapStudies/talib.TEMA talib.TEMA} | The ```talib.TEMA()``` function is used to calculate **Triple Exponential Moving Average**. |\\n| {@fun/Talib/OverlapStudies/talib.TRIMA talib.TRIMA} | The ```talib.TRIMA()``` function is used to calculate **Triangular Moving Average**. |\\n| {@fun/Talib/OverlapStudies/talib.WMA talib.WMA} | The ```talib.WMA()``` function is used to calculate **Weighted Moving Average**. |\\n\\n#### Talib/MomentumIndicators\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/MomentumIndicators/talib.ADX talib.ADX} | The ```talib.ADX()``` function is used to calculate the **Average Directional Movement Index**. |\\n| {@fun/Talib/MomentumIndicators/talib.ADXR talib.ADXR} | The ```talib.ADXR()``` function is used to calculate the **Average Directional Movement Index Rating**. |\\n| {@fun/Talib/MomentumIndicators/talib.APO talib.APO} | The ```talib.APO()``` function is used to calculate **Absolute Price Oscillator**. |\\n| {@fun/Talib/MomentumIndicators/talib.AROON talib.AROON} | The ```talib.AROON()``` function is used to calculate **Aroon (Aroon Indicator)**. |\\n| {@fun/Talib/MomentumIndicators/talib.AROONOSC talib.AROONOSC} | The ```talib.AROONOSC()``` function is used to calculate the **Aroon Oscillator**. |\\n| {@fun/Talib/MomentumIndicators/talib.BOP talib.BOP} | The ```talib.BOP()``` function is used to calculate **Balance Of Power**. |\\n| {@fun/Talib/MomentumIndicators/talib.CCI talib.CCI} | The ```talib.CCI()``` function is used to calculate the **Commodity Channel Index**. |\\n| {@fun/Talib/MomentumIndicators/talib.CMO talib.CMO} | The ```talib.CMO()``` function is used to calculate the **Chande Momentum Oscillator**. |\\n| {@fun/Talib/MomentumIndicators/talib.DX talib.DX} | The ```talib.DX()``` function is used to calculate the **Directional Movement Index**. |\\n| {@fun/Talib/MomentumIndicators/talib.MACD talib.MACD} | The ```talib.MACD()``` function is used to calculate **Moving Average Convergence/Divergence**. |\\n| {@fun/Talib/MomentumIndicators/talib.MACDEXT talib.MACDEXT} | The ```talib.MACDEXT()``` function is used to calculate **MACD with controllable MA type**. |\\n| {@fun/Talib/MomentumIndicators/talib.MACDFIX talib.MACDFIX} | The ```talib.MACDFIX()``` function is used to calculate **Moving Average Convergence/Divergence Fix 12/26**. |\\n| {@fun/Talib/MomentumIndicators/talib.MFI talib.MFI} | The ```talib.MFI()``` function is used to calculate **Money Flow Index**. |\\n| {@fun/Talib/MomentumIndicators/talib.MINUS_DI talib.MINUS_DI} | The ```talib.MINUS_DI()``` function is used to calculate the **Minus Directional Indicator**. |\\n| {@fun/Talib/MomentumIndicators/talib.MINUS_DM talib.MINUS_DM} | The ```talib.MINUS_DM()``` function is used to calculate **Minus Directional Movement**. |\\n| {@fun/Talib/MomentumIndicators/talib.MOM talib.MOM} | The ```talib.MOM()``` function is used to calculate **Momentum (Momentum Indicator)**. |\\n| {@fun/Talib/MomentumIndicators/talib.PLUS_DI talib.PLUS_DI} | The ```talib.PLUS_DI()``` function is used to calculate the **Plus Directional Indicator**. |\\n| {@fun/Talib/MomentumIndicators/talib.PLUS_DM talib.PLUS_DM} | The ```talib.PLUS_DM()``` function is used to calculate **Plus Directional Movement**. |\\n| {@fun/Talib/MomentumIndicators/talib.PPO talib.PPO} | The ```talib.PPO()``` function is used to calculate **Percentage Price Oscillator**. |\\n| {@fun/Talib/MomentumIndicators/talib.ROC talib.ROC} | The ```talib.ROC()``` function is used to calculate the **Rate of Change indicator: ((price/prevPrice)-1)*100**. |\\n| {@fun/Talib/MomentumIndicators/talib.ROCP talib.ROCP} | The ```talib.ROCP()``` function is used to calculate **Rate of change Percentage: (price-prevPrice)/prevPrice**. |\\n| {@fun/Talib/MomentumIndicators/talib.ROCR talib.ROCR} | The ```talib.ROCR()``` function is used to calculate **Rate of change ratio: (price/prevPrice)**. |\\n| {@fun/Talib/MomentumIndicators/talib.ROCR100 talib.ROCR100} | The ```talib.ROCR100()``` function is used to calculate **Rate of change ratio 100 scale: (price/prevPrice)*100**. |\\n| {@fun/Talib/MomentumIndicators/talib.RSI talib.RSI} | The ```talib.RSI()``` function is used to calculate the **Relative Strength Index**. |\\n| {@fun/Talib/MomentumIndicators/talib.STOCH talib.STOCH} | The ```talib.STOCH()``` function is used to calculate the **Stochastic Oscillator (STOCH indicator)**. |\\n| {@fun/Talib/MomentumIndicators/talib.STOCHF talib.STOCHF} | The ```talib.STOCHF()``` function is used to calculate **Stochastic Fast**. |\\n| {@fun/Talib/MomentumIndicators/talib.STOCHRSI talib.STOCHRSI} | The ```talib.STOCHRSI()``` function is used to calculate the **Stochastic Relative Strength Index**. |\\n| {@fun/Talib/MomentumIndicators/talib.TRIX talib.TRIX} | The ```talib.TRIX()``` function is used to calculate **1-day Rate-Of-Change (ROC) of a Triple Smooth EMA**. |\\n| {@fun/Talib/MomentumIndicators/talib.ULTOSC talib.ULTOSC} | The ```talib.ULTOSC()``` function is used to calculate the **Ultimate Oscillator**. |\\n| {@fun/Talib/MomentumIndicators/talib.WILLR talib.WILLR} | The ```talib.WILLR()``` function is used to calculate **Williams' %R (Williams Percent Range)**. |\\n\\n#### Talib/VolumeIndicators\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/VolumeIndicators/talib.AD talib.AD} | The ```talib.AD()``` function is used to calculate the **Chaikin A/D Line (Accumulation/Distribution Line indicator)**. |\\n| {@fun/Talib/VolumeIndicators/talib.ADOSC talib.ADOSC} | The ```talib.ADOSC()``` function is used to calculate **Chaikin A/D Oscillator**. |\\n| {@fun/Talib/VolumeIndicators/talib.OBV talib.OBV} | The ```talib.OBV()``` function is used to calculate **On Balance Volume**. |\\n\\n#### Talib/VolatilityIndicators\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/VolatilityIndicators/talib.ATR talib.ATR} | The ```talib.ATR()``` function is used to calculate the **Average True Range** indicator. |\\n| {@fun/Talib/VolatilityIndicators/talib.NATR talib.NATR} | The ```talib.NATR()``` function is used to calculate **Normalized Average True Range**. |\\n| {@fun/Talib/VolatilityIndicators/talib.TRANGE talib.TRANGE} | The ```talib.TRANGE()``` function is used to calculate the **True Range** indicator. |\\n\\n#### Talib/CycleIndicators\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/CycleIndicators/talib.HT_DCPERIOD talib.HT_DCPERIOD} | The ```talib.HT_DCPERIOD()``` function is used to calculate **Hilbert Transform - Dominant Cycle Period**. |\\n| {@fun/Talib/CycleIndicators/talib.HT_DCPHASE talib.HT_DCPHASE} | The ```talib.HT_DCPHASE()``` function is used to calculate the **Hilbert Transform - Dominant Cycle Phase**. |\\n| {@fun/Talib/CycleIndicators/talib.HT_PHASOR talib.HT_PHASOR} | The ```talib.HT_PHASOR()``` function is used to calculate **Hilbert Transform - Phasor Components**. |\\n| {@fun/Talib/CycleIndicators/talib.HT_SINE talib.HT_SINE} | The ```talib.HT_SINE()``` function is used to calculate **Hilbert Transform - SineWave**. |\\n| {@fun/Talib/CycleIndicators/talib.HT_TRENDMODE talib.HT_TRENDMODE} | The ```talib.HT_TRENDMODE()``` function is used to calculate **Hilbert Transform - Trend vs Cycle Mode**. |\\n\\n#### Talib/PriceTransform\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/PriceTransform/talib.AVGPRICE talib.AVGPRICE} | The ```talib.AVGPRICE()``` function is used to calculate **Average Price**. |\\n| {@fun/Talib/PriceTransform/talib.MEDPRICE talib.MEDPRICE} | The ```talib.MEDPRICE()``` function is used to calculate **Median Price**. |\\n| {@fun/Talib/PriceTransform/talib.TYPPRICE talib.TYPPRICE} | The ```talib.TYPPRICE()``` function is used to calculate **Typical Price**. |\\n| {@fun/Talib/PriceTransform/talib.WCLPRICE talib.WCLPRICE} | The ```talib.WCLPRICE()``` function is used to calculate **Weighted Close Price**. |\\n\\n#### Talib/StatisticFunctions\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG talib.LINEARREG} | The ```talib.LINEARREG()``` function is used to calculate the **Linear Regression** indicator. |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG_ANGLE talib.LINEARREG_ANGLE} | The ```talib.LINEARREG_ANGLE()``` function is used to calculate **Linear Regression Angle**. |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG_INTERCEPT talib.LINEARREG_INTERCEPT} | The ```talib.LINEARREG_INTERCEPT()``` function is used to calculate the **Linear Regression Intercept**. |\\n| {@fun/Talib/StatisticFunctions/talib.LINEARREG_SLOPE talib.LINEARREG_SLOPE} | The ```talib.LINEARREG_SLOPE()``` function is used to calculate **Linear Regression Slope**. |\\n| {@fun/Talib/StatisticFunctions/talib.STDDEV talib.STDDEV} | The ```talib.STDDEV()``` function is used to calculate **Standard Deviation**. |\\n| {@fun/Talib/StatisticFunctions/talib.TSF talib.TSF} | The ```talib.TSF()``` function is used to calculate **Time Series Forecast**. |\\n| {@fun/Talib/StatisticFunctions/talib.VAR talib.VAR} | The ```talib.VAR()``` function is used to calculate **Variance**. |\\n\\n#### Talib/MathTransform\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/MathTransform/talib.ACOS talib.ACOS} | The ```talib.ACOS()``` function is used to calculate **Vector Trigonometric ACos**. |\\n| {@fun/Talib/MathTransform/talib.ASIN talib.ASIN} | The ```talib.ASIN()``` function is used to calculate **Vector Trigonometric ASin**. |\\n| {@fun/Talib/MathTransform/talib.ATAN talib.ATAN} | The ```talib.ATAN()``` function is used to calculate **Vector Trigonometric ATan**. |\\n| {@fun/Talib/MathTransform/talib.CEIL talib.CEIL} | The ```talib.CEIL()``` function is used to calculate **Vector Ceil**. |\\n| {@fun/Talib/MathTransform/talib.COS talib.COS} | The ```talib.COS()``` function is used to calculate **Vector Trigonometric Cos**. |\\n| {@fun/Talib/MathTransform/talib.COSH talib.COSH} | The ```talib.COSH()``` function is used to calculate **Vector Trigonometric Cosh**. |\\n| {@fun/Talib/MathTransform/talib.EXP talib.EXP} | The ```talib.EXP()``` function is used to calculate **Vector Arithmetic Exp**. |\\n| {@fun/Talib/MathTransform/talib.FLOOR talib.FLOOR} | The ```talib.FLOOR()``` function is used to calculate **Vector Floor**. |\\n| {@fun/Talib/MathTransform/talib.LN talib.LN} | The ```talib.LN()``` function is used to calculate **Vector Log Natural**. |\\n| {@fun/Talib/MathTransform/talib.LOG10 talib.LOG10} | The ```talib.LOG10()``` function is used to calculate **Vector Log10 (logarithm function)**. |\\n| {@fun/Talib/MathTransform/talib.SIN talib.SIN} | The ```talib.SIN()``` function is used to calculate **Vector Trigonometric Sin**. |\\n| {@fun/Talib/MathTransform/talib.SINH talib.SINH} | The ```talib.SINH()``` function is used to calculate **Vector Trigonometric Sinh**. |\\n| {@fun/Talib/MathTransform/talib.SQRT talib.SQRT} | The ```talib.SQRT()``` function is used to calculate **Vector Square Root**. |\\n| {@fun/Talib/MathTransform/talib.TAN talib.TAN} | The ```talib.TAN()``` function is used to calculate **Vector Trigonometric Tan**. |\\n| {@fun/Talib/MathTransform/talib.TANH talib.TANH} | The ```talib.TANH()``` function is used to calculate **Vector Trigonometric Tanh**. |\\n\\n#### Talib/MathOperators\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/MathOperators/talib.MAX talib.MAX} | The ```talib.MAX()``` function is used to calculate the **Highest value over a specified period**. |\\n| {@fun/Talib/MathOperators/talib.MAXINDEX talib.MAXINDEX} | The ```talib.MAXINDEX()``` function is used to calculate the **Index of highest value over a specified period**. |\\n| {@fun/Talib/MathOperators/talib.MIN talib.MIN} | The ```talib.MIN()``` function is used to calculate the **Lowest value over a specified period**. |\\n| {@fun/Talib/MathOperators/talib.MININDEX talib.MININDEX} | The ```talib.MININDEX()``` function is used to calculate the **Index of lowest value over a specified period**. |\\n| {@fun/Talib/MathOperators/talib.MINMAX talib.MINMAX} | The ```talib.MINMAX()``` function is used to calculate the **Lowest and highest values over a specified period**. |\\n| {@fun/Talib/MathOperators/talib.MINMAXINDEX talib.MINMAXINDEX} | The ```talib.MINMAXINDEX()``` function is used to calculate **Indexes of lowest and highest values over a specified period**. |\\n| {@fun/Talib/MathOperators/talib.SUM talib.SUM} | The ```talib.SUM()``` function is used to calculate **Summation**. |\\n\\n#### Talib/PatternRecognition\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/Talib/PatternRecognition/talib.CDL2CROWS talib.CDL2CROWS} | The ```talib.CDL2CROWS()``` function is used to calculate **Two Crows (K-line pattern - Two Crows)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDL3BLACKCROWS talib.CDL3BLACKCROWS} | The ```talib.CDL3BLACKCROWS()``` function is used to calculate **Three Black Crows (K-line pattern - Three Black Crows)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDL3INSIDE talib.CDL3INSIDE} | The ```talib.CDL3INSIDE()``` function is used to calculate **Three Inside Up/Down (Candlestick Pattern: Three Inside Up/Down)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDL3LINESTRIKE talib.CDL3LINESTRIKE} | The ```talib.CDL3LINESTRIKE()``` function is used to calculate **Three-Line Strike (Candlestick Pattern: Three-Line Strike)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDL3OUTSIDE talib.CDL3OUTSIDE} | The ```talib.CDL3OUTSIDE()``` function is used to calculate **Three Outside Up/Down (Candlestick Pattern: Three Outside)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDL3STARSINSOUTH talib.CDL3STARSINSOUTH} | The ```talib.CDL3STARSINSOUTH()``` function is used to calculate **Three Stars In The South (Candlestick Pattern: Three Stars In The South)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDL3WHITESOLDIERS talib.CDL3WHITESOLDIERS} | The ```talib.CDL3WHITESOLDIERS()``` function is used to calculate **Three Advancing White Soldiers (K-line pattern: Three White Soldiers)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLABANDONEDBABY talib.CDLABANDONEDBABY} | The ```talib.CDLABANDONEDBABY()``` function is used to calculate **Abandoned Baby (Candlestick Pattern: Abandoned Baby)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLADVANCEBLOCK talib.CDLADVANCEBLOCK} | The ```talib.CDLADVANCEBLOCK()``` function is used to calculate **Advance Block (Candlestick Pattern: Advance Block)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLBELTHOLD talib.CDLBELTHOLD} | The ```talib.CDLBELTHOLD()``` function is used to calculate **Belt-hold (Candlestick Pattern: Belt-hold)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLBREAKAWAY talib.CDLBREAKAWAY} | The ```talib.CDLBREAKAWAY()``` function is used to calculate **Breakaway (Candlestick Pattern: Breakaway Pattern)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLCLOSINGMARUBOZU talib.CDLCLOSINGMARUBOZU} | The ```talib.CDLCLOSINGMARUBOZU()``` function is used to calculate the **Closing Marubozu** candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLCONCEALBABYSWALL talib.CDLCONCEALBABYSWALL} | The ```talib.CDLCONCEALBABYSWALL()``` function is used to calculate **Concealing Baby Swallow (Candlestick Pattern: Concealing Baby Swallow)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLCOUNTERATTACK talib.CDLCOUNTERATTACK} | The ```talib.CDLCOUNTERATTACK()``` function is used to calculate **Counterattack Lines (K-Line Pattern: Counterattack)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLDARKCLOUDCOVER talib.CDLDARKCLOUDCOVER} | The ```talib.CDLDARKCLOUDCOVER()``` function is used to calculate **Dark Cloud Cover candlestick pattern**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLDOJI talib.CDLDOJI} | The ```talib.CDLDOJI()``` function is used to calculate **Doji (K-line pattern: Doji Star)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLDOJISTAR talib.CDLDOJISTAR} | The ```talib.CDLDOJISTAR()``` function is used to calculate **Doji Star (Candlestick Pattern: Doji Star)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLDRAGONFLYDOJI talib.CDLDRAGONFLYDOJI} | The ```talib.CDLDRAGONFLYDOJI()``` function is used to calculate **Dragonfly Doji (Candlestick Pattern: Dragonfly Doji)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLENGULFING talib.CDLENGULFING} | The ```talib.CDLENGULFING()``` function is used to calculate **Engulfing Pattern**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLEVENINGDOJISTAR talib.CDLEVENINGDOJISTAR} | The ```talib.CDLEVENINGDOJISTAR()``` function is used to calculate **Evening Doji Star (K-line pattern: Evening Doji Star)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLEVENINGSTAR talib.CDLEVENINGSTAR} | The ```talib.CDLEVENINGSTAR()``` function is used to calculate the **Evening Star** candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLGAPSIDESIDEWHITE talib.CDLGAPSIDESIDEWHITE} | The ```talib.CDLGAPSIDESIDEWHITE()``` function is used to calculate **Up/Down-gap side-by-side white lines (K-line pattern: Up/Down-gap side-by-side white li... |\\n| {@fun/Talib/PatternRecognition/talib.CDLGRAVESTONEDOJI talib.CDLGRAVESTONEDOJI} | The ```talib.CDLGRAVESTONEDOJI()``` function is used to calculate the **Gravestone Doji** candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHAMMER talib.CDLHAMMER} | The ```talib.CDLHAMMER()``` function is used to calculate **Hammer (Candlestick Pattern: Hammer)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHANGINGMAN talib.CDLHANGINGMAN} | The ```talib.CDLHANGINGMAN()``` function is used to calculate **Hanging Man (Candlestick Pattern: Hanging Man)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHARAMI talib.CDLHARAMI} | The ```talib.CDLHARAMI()``` function is used to calculate **Harami Pattern (K-line chart: bullish/bearish pattern)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHARAMICROSS talib.CDLHARAMICROSS} | The ```talib.CDLHARAMICROSS()``` function is used to calculate **Harami Cross Pattern (Candlestick Pattern: Harami Cross)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHIGHWAVE talib.CDLHIGHWAVE} | The ```talib.CDLHIGHWAVE()``` function is used to calculate **High-Wave Candle (Candlestick Pattern: High Wave Candle)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHIKKAKE talib.CDLHIKKAKE} | The ```talib.CDLHIKKAKE()``` function is used to calculate **Hikkake Pattern (Candlestick: Trap Pattern)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHIKKAKEMOD talib.CDLHIKKAKEMOD} | The ```talib.CDLHIKKAKEMOD()``` function is used to calculate **Modified Hikkake Pattern (Candlestick: Modified Hikkake Pattern)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLHOMINGPIGEON talib.CDLHOMINGPIGEON} | The ```talib.CDLHOMINGPIGEON()``` function is used to calculate **Homing Pigeon (Candlestick Pattern: Homing Pigeon)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLIDENTICAL3CROWS talib.CDLIDENTICAL3CROWS} | The ```talib.CDLIDENTICAL3CROWS()``` function is used to calculate **Identical Three Crows (Candlestick Pattern: Identical Three Crows)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLINNECK talib.CDLINNECK} | The ```talib.CDLINNECK()``` function is used to calculate **In-Neck Pattern (Candlestick Chart: In-Neck Pattern)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLINVERTEDHAMMER talib.CDLINVERTEDHAMMER} | The ```talib.CDLINVERTEDHAMMER()``` function is used to calculate **Inverted Hammer (K-Line Pattern: Inverted Hammer)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLKICKING talib.CDLKICKING} | The ```talib.CDLKICKING()``` function is used to calculate **Kicking (Candlestick Pattern: Kicking Pattern)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLKICKINGBYLENGTH talib.CDLKICKINGBYLENGTH} | The ```talib.CDLKICKINGBYLENGTH()``` function is used to calculate **Kicking - bull/bear determined by the longer marubozu (K-line pattern: Kicking Bull/Bear... |\\n| {@fun/Talib/PatternRecognition/talib.CDLLADDERBOTTOM talib.CDLLADDERBOTTOM} | The ```talib.CDLLADDERBOTTOM()``` function is used to calculate **Ladder Bottom (Candlestick Pattern: Ladder Bottom)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLLONGLEGGEDDOJI talib.CDLLONGLEGGEDDOJI} | The ```talib.CDLLONGLEGGEDDOJI()``` function is used to calculate **Long Legged Doji (Candlestick Pattern: Long Legged Doji)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLLONGLINE talib.CDLLONGLINE} | The ```talib.CDLLONGLINE()``` function is used to calculate **Long Line Candle Pattern (Candlestick Chart: Long Line)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLMARUBOZU talib.CDLMARUBOZU} | The ```talib.CDLMARUBOZU()``` function is used to calculate the **Marubozu (Candlestick Pattern: Shaven Head and Bottom)** pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLMATCHINGLOW talib.CDLMATCHINGLOW} | The ```talib.CDLMATCHINGLOW()``` function is used to calculate **Matching Low (Candlestick Pattern: Matching Low)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLMATHOLD talib.CDLMATHOLD} | The ```talib.CDLMATHOLD()``` function is used to calculate **Mat Hold (Candlestick Pattern: Mat Hold)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLMORNINGDOJISTAR talib.CDLMORNINGDOJISTAR} | The ```talib.CDLMORNINGDOJISTAR()``` function is used to calculate **Morning Doji Star (Candlestick Pattern: Morning Doji Star)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLMORNINGSTAR talib.CDLMORNINGSTAR} | The ```talib.CDLMORNINGSTAR()``` function is used to calculate **Morning Star (Candlestick Pattern: Morning Star)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLONNECK talib.CDLONNECK} | The ```talib.CDLONNECK()``` function is used to calculate **On-Neck Pattern (Candlestick Chart: On-Neck Pattern)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLPIERCING talib.CDLPIERCING} | The ```talib.CDLPIERCING()``` function is used to calculate **Piercing Pattern (Candlestick Pattern: Piercing Pattern)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLRICKSHAWMAN talib.CDLRICKSHAWMAN} | The ```talib.CDLRICKSHAWMAN()``` function is used to calculate **Rickshaw Man (Candlestick Pattern: Rickshaw Man)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLRISEFALL3METHODS talib.CDLRISEFALL3METHODS} | The ```talib.CDLRISEFALL3METHODS()``` function is used to calculate **Rising/Falling Three Methods (Candlestick Pattern: Rising/Falling Three Methods)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLSEPARATINGLINES talib.CDLSEPARATINGLINES} | The ```talib.CDLSEPARATINGLINES()``` function is used to calculate **Separating Lines Pattern (Candlestick Chart: Separating Lines)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLSHOOTINGSTAR talib.CDLSHOOTINGSTAR} | The ```talib.CDLSHOOTINGSTAR()``` function is used to calculate **Shooting Star (Candlestick Pattern: Shooting Star)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLSHORTLINE talib.CDLSHORTLINE} | The ```talib.CDLSHORTLINE()``` function is used to calculate **Short Line Candle Pattern (K-Line: Short Line)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLSPINNINGTOP talib.CDLSPINNINGTOP} | The ```talib.CDLSPINNINGTOP()``` function is used to calculate **Spinning Top (Candlestick Pattern: Spinning Top)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLSTALLEDPATTERN talib.CDLSTALLEDPATTERN} | The ```talib.CDLSTALLEDPATTERN()``` function is used to calculate **Stalled Pattern (Candlestick Pattern: Stalled Pattern)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLSTICKSANDWICH talib.CDLSTICKSANDWICH} | The ```talib.CDLSTICKSANDWICH()``` function is used to calculate **Stick Sandwich (Candlestick Pattern: Stick Sandwich)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLTAKURI talib.CDLTAKURI} | The ```talib.CDLTAKURI()``` function is used to calculate **Takuri (Dragonfly Doji with very long lower shadow)** candlestick pattern. |\\n| {@fun/Talib/PatternRecognition/talib.CDLTASUKIGAP talib.CDLTASUKIGAP} | The ```talib.CDLTASUKIGAP()``` function is used to calculate **Tasuki Gap (Candlestick Pattern: Tasuki Gap)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLTHRUSTING talib.CDLTHRUSTING} | The ```talib.CDLTHRUSTING()``` function is used to calculate **Thrusting Pattern (Candlestick Pattern: Thrusting Pattern)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLTRISTAR talib.CDLTRISTAR} | The ```talib.CDLTRISTAR()``` function is used to calculate **Tristar Pattern (Candlestick Chart: Tristar Pattern)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLUNIQUE3RIVER talib.CDLUNIQUE3RIVER} | The ```talib.CDLUNIQUE3RIVER()``` function is used to calculate **Unique 3 River (Candlestick Pattern: Unique Three River)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLUPSIDEGAP2CROWS talib.CDLUPSIDEGAP2CROWS} | The ```talib.CDLUPSIDEGAP2CROWS()``` function is used to calculate **Upside Gap Two Crows (Candlestick Pattern: Two Crows)**. |\\n| {@fun/Talib/PatternRecognition/talib.CDLXSIDEGAP3METHODS talib.CDLXSIDEGAP3METHODS} | The ```talib.CDLXSIDEGAP3METHODS()``` function is used to calculate **Upside/Downside Gap Three Methods (Candlestick Pattern Recognition)**. |\\n\\n### OS\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/OS/ListFilesResult ListFilesResult} | File list object used to record directory listing information. |\\n| {@fun/OS/FileStat FileStat} | File statistics information object. |\\n\\n#### OS/os\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/OS/os/open open} | Open a file in the specified mode. |\\n| {@fun/OS/os/fgets fgets} | Read the entire file content at once. |\\n| {@fun/OS/os/fputs fputs} | Write content to a file. |\\n| {@fun/OS/os/mmap mmap} | Memory-mapped file, returns the binary data of the file. |\\n| {@fun/OS/os/getRootDir getRootDir} | Get the root directory path for file operations. |\\n| {@fun/OS/os/listFiles listFiles} | List files and subdirectories in the specified directory. |\\n| {@fun/OS/os/exists exists} | Check if the specified file or directory exists. |\\n| {@fun/OS/os/remove remove} | Delete the specified file. |\\n| {@fun/OS/os/mkdir mkdir} | Create a directory. |\\n| {@fun/OS/os/rmdir rmdir} | Remove a directory and all its contents. |\\n| {@fun/OS/os/rename rename} | Rename a file or move a file. |\\n| {@fun/OS/os/stat stat} | Get detailed statistics information of a file. |\\n| {@fun/OS/os/exit exit} | Exit the program. |\\n\\n#### OS/File\\n\\n| Name | Description |\\n| - | - |\\n| {@fun/OS/File/close close} | Close the file and release associated resources. |\\n| {@fun/OS/File/puts puts} | Write one or more strings to a file. |\\n| {@fun/OS/File/printf printf} | Write formatted data to file. |\\n| {@fun/OS/File/flush flush} | Flush the file buffer to ensure data is written to disk. |\\n| {@fun/OS/File/tell tell} | Get the current file pointer position. |\\n| {@fun/OS/File/seek seek} | Move the file pointer to a specified position. |\\n| {@fun/OS/File/eof eof} | Check if the file pointer has reached the end of file. |\\n| {@fun/OS/File/read read} | Read data from a file. |\\n| {@fun/OS/File/write write} | Write string data to a file. |\\n| {@fun/OS/File/getline getline} | Read the next line from the file. |\\n| {@fun/OS/File/toString toString} | Get the string representation of the file object. |\\n\\n## Structures\\n\\n| Name | Description |\\n| - | - |\\n| {@struct/Ticker Ticker} | Market data structure. |\\n| {@struct/Depth Depth} | Market depth data structure. |\\n| {@struct/OrderBook OrderBook} | Order structure in market depth. |\\n| {@struct/Trade Trade} | Data structure for market trade records. |\\n| {@struct/Record Record} | Data structure for candlestick bars in standard OHLC format, used for charting candlesticks and calculating technical indicators. |\\n| {@struct/Market Market} | Data structure for trading symbol market information. |\\n| {@struct/Order Order} | Order structure. |\\n| {@struct/Condition Condition} | Conditional order configuration structure, used to set trigger conditions and execution prices for conditional orders. |\\n| {@struct/Account Account} | Data structure for account information. |\\n| {@struct/Asset Asset} | Data structure for specific currency asset information. |\\n| {@struct/Position Position} | Data structure for contract position information. |\\n| {@struct/Funding Funding} | Data structure for trading instrument funding rate information, only cryptocurrency perpetual contracts support funding rate functionality. |\\n\\n### OtherStruct\\n\\n| Name | Description |\\n| - | - |\\n| {@struct/OtherStruct/HttpQuery-options HttpQuery-options} | This JSON structure is used to configure various parameters for HTTP requests sent by HttpQuery and HttpQuery_Go functions. |\\n| {@struct/OtherStruct/HttpQuery-return HttpQuery-return} | This JSON structure is the data structure returned by the HttpQuery function in debug mode, when the debug field is set to true in the ```options``` paramete... |\\n| {@struct/OtherStruct/LogStatus-table LogStatus-table} | This JSON structure is used to configure the table content displayed in the strategy status bar. |\\n| {@struct/OtherStruct/LogStatus-btnTypeOne LogStatus-btnTypeOne} | This JSON structure is used to configure button controls in the status bar. |\\n| {@struct/OtherStruct/LogStatus-btnTypeTwo LogStatus-btnTypeTwo} | This JSON structure is used to configure button controls in the status bar. |\\n| {@struct/OtherStruct/Chart-options Chart-options} | This JSON is used to configure chart settings for the custom plotting function ```Chart()```. |\\n| {@struct/OtherStruct/KLineChart-options KLineChart-options} | This JSON is used to configure the chart settings for the custom drawing function ```KLineChart```. |\\n| {@struct/OtherStruct/SetData-data SetData-data} | This JSON is used to set the data to be loaded by the ```exchange.SetData()``` function. |\\n| {@struct/OtherStruct/EventLoop-return EventLoop-return} | This JSON is the data structure returned by the ```EventLoop()``` function. |\\n| {@struct/OtherStruct/DBExec-return DBExec-return} | This JSON is the data structure returned by the ```DBExec()``` function; this JSON data structure is also returned when executing SQL statements using the ``... |\\n| {@struct/OtherStruct/Thread.join-return Thread.join-return} | This JSON is the data structure returned by the ```join()``` member function of the ```Thread``` object, used to store information related to concurrent thre... |\\n\\n## Built-in Variables and Constants\\n\\n### EXCHANGE\\n\\n| Name | Description |\\n| - | - |\\n| {@var/EXCHANGE/exchange exchange} | exchange is an exchange object, and it is also the first exchange object added in the strategy live trading settings and backtesting settings. |\\n| {@var/EXCHANGE/exchanges exchanges} | exchanges is an array of exchange objects that contains all the exchange objects added in the strategy's live trading settings or backtesting settings, where... |\\n\\n### ORDER_STATE\\n\\n| Name | Description |\\n| - | - |\\n| {@var/ORDER_STATE/ORDER_STATE_PENDING ORDER_STATE_PENDING} | ORDER_STATE_PENDING is the value of the ```Status``` property in the Order structure, indicating that the order status is pending. |\\n| {@var/ORDER_STATE/ORDER_STATE_CLOSED ORDER_STATE_CLOSED} | ORDER_STATE_CLOSED is the value of the ```Status``` property in the Order structure, indicating that the order status is completed. |\\n| {@var/ORDER_STATE/ORDER_STATE_CANCELED ORDER_STATE_CANCELED} | ORDER_STATE_CANCELED is the value of the ```Status``` property in the Order structure, indicating that the order status is canceled. |\\n| {@var/ORDER_STATE/ORDER_STATE_UNKNOWN ORDER_STATE_UNKNOWN} | ORDER_STATE_UNKNOWN is the value of the ```Status``` property in the Order structure, indicating that the order status is unknown (other status). |\\n\\n### ORDER_TYPE\\n\\n| Name | Description |\\n| - | - |\\n| {@var/ORDER_TYPE/ORDER_TYPE_BUY ORDER_TYPE_BUY} | ORDER_TYPE_BUY is the value of the ```Type``` property in the Order structure, representing a buy order type. |\\n| {@var/ORDER_TYPE/ORDER_TYPE_SELL ORDER_TYPE_SELL} | ORDER_TYPE_SELL is the ```Type``` property value in the Order structure, used to indicate a sell order type. |\\n\\n### ORDER_CONDITION_TYPE\\n\\n| Name | Description |\\n| - | - |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_OCO ORDER_CONDITION_TYPE_OCO} | ORDER_CONDITION_TYPE_OCO is the value of the ```ConditionType``` property in the Condition structure, representing OCO orders (One-Cancels-the-Other). |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_TP ORDER_CONDITION_TYPE_TP} | ORDER_CONDITION_TYPE_TP is the ```ConditionType``` attribute value in the Condition structure, representing a Take Profit order. |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_SL ORDER_CONDITION_TYPE_SL} | ORDER_CONDITION_TYPE_SL is the ```ConditionType``` attribute value in the Condition structure, representing a Stop Loss order. |\\n| {@var/ORDER_CONDITION_TYPE/ORDER_CONDITION_TYPE_GENERIC ORDER_CONDITION_TYPE_GENERIC} | ORDER_CONDITION_TYPE_GENERIC is the ```ConditionType``` property value in the Condition structure, representing a generic conditional order. |\\n\\n### POSITION_DIRECTION\\n\\n| Name | Description |\\n| - | - |\\n| {@var/POSITION_DIRECTION/PD_LONG PD_LONG} | PD_LONG is the value of the ```Type``` property in the Position structure, representing a long position type. |\\n| {@var/POSITION_DIRECTION/PD_SHORT PD_SHORT} | PD_SHORT is the value of the ```Type``` property in the Position structure, representing a short position type. |\\n\\n### ORDER_OFFSET\\n\\n| Name | Description |\\n| - | - |\\n| {@var/ORDER_OFFSET/ORDER_OFFSET_OPEN ORDER_OFFSET_OPEN} | ORDER_OFFSET_OPEN is a value for the ```Offset``` property in the Order structure, indicating that the order is an opening position operation. |\\n| {@var/ORDER_OFFSET/ORDER_OFFSET_CLOSE ORDER_OFFSET_CLOSE} | ORDER_OFFSET_CLOSE is a value for the ```Offset``` property in the Order structure, indicating that the order is in the close position direction. |\\n\\n### PERIOD\\n\\n| Name | Description |\\n| - | - |\\n| {@var/PERIOD/PERIOD_M1 PERIOD_M1} | Constant representing 1-minute candlestick period, with a value of 60. |\\n| {@var/PERIOD/PERIOD_M3 PERIOD_M3} | Constant representing the 3-minute candlestick period, with a value of 180. |\\n| {@var/PERIOD/PERIOD_M5 PERIOD_M5} | Constant representing the 5-minute candlestick period, with a value of 300. |\\n| {@var/PERIOD/PERIOD_M15 PERIOD_M15} | Constant representing the 15-minute candlestick period, with a value of 900. |\\n| {@var/PERIOD/PERIOD_M30 PERIOD_M30} | Constant representing the 30-minute candlestick period, with a value of 1800 seconds. |\\n| {@var/PERIOD/PERIOD_H1 PERIOD_H1} | Constant representing 1-hour candlestick period, with a value of 3600. |\\n| {@var/PERIOD/PERIOD_H2 PERIOD_H2} | Constant representing the 2-hour candlestick period, with a value of 7200. |\\n| {@var/PERIOD/PERIOD_H4 PERIOD_H4} | Constant representing the 4-hour candlestick period, with a value of 14400. |\\n| {@var/PERIOD/PERIOD_H6 PERIOD_H6} | Constant representing the 6-hour candlestick period, with a value of 21600. |\\n| {@var/PERIOD/PERIOD_H12 PERIOD_H12} | Constant representing the 12-hour candlestick period, with a value of 43200. |\\n| {@var/PERIOD/PERIOD_D1 PERIOD_D1} | Constant representing 1-day candlestick period, with a value of 86400. |\\n| {@var/PERIOD/PERIOD_D3 PERIOD_D3} | Constant representing the 3-day candlestick period, with a value of 259200. |\\n| {@var/PERIOD/PERIOD_W1 PERIOD_W1} | Constant representing 1-week candlestick period, with a value of 604800 seconds. |\\n\\n### LOG_TYPE\\n\\n| Name | Description |\\n| - | - |\\n| {@var/LOG_TYPE/LOG_TYPE_BUY LOG_TYPE_BUY} | LOG_TYPE_BUY is an optional value for the ```LogType``` parameter of the exchange.Log function, used to set the log type printed by the ```exchange.Log``` fu... |\\n| {@var/LOG_TYPE/LOG_TYPE_SELL LOG_TYPE_SELL} | LOG_TYPE_SELL is an optional value for the ```LogType``` parameter of the exchange.Log function, used to set the ```exchange.Log``` function to print sell or... |\\n| {@var/LOG_TYPE/LOG_TYPE_CANCEL LOG_TYPE_CANCEL} | LOG_TYPE_CANCEL is an optional value for the ```LogType``` parameter of the exchange.Log function, used to set the ```exchange.Log``` function to print order... |\"], \"title\": \"API Quick Reference\"}], \"desc\": \"Strategies in ```JavaScript``` (including TypeScript), ```Python``` and ```Rust``` consist of a few functions with agreed names, which the docker calls at fixed points. MyLanguage, PINE, Blockly and Workflow strategies do not need to define them.\\n\\n**Lifecycle functions**\\n\\n| Function | Required | When it is called |\\n| - | - | - |\\n| ```main()``` | Yes | The entry function and body of the strategy. When ```main()``` returns, the strategy has finished. |\\n| ```init()``` | No | Called once before ```main()```, for initialization. |\\n| ```onexit()``` | No | Called when the strategy exits, for cleanup (cancel orders, close positions, save state, etc.). |\\n| ```onerror(msg)``` | No | ```JavaScript``` only: called when ```main()``` ends with an uncaught exception; ```msg``` is the error message. When ```onerror()``` is called, ```onexit()``` is not. |\\n| ```destroy()``` | No | ```JavaScript``` template libraries only: called when the strategy exits, after ```onexit()``` or ```onerror()```; see Writing Strategies → Template Library. |\\n\\nWhich function runs on exit:\\n\\n| Exit reason | JavaScript | Python | Rust |\\n| - | - | - | - |\\n| ```main()``` returns normally | ```onexit()``` | ```onexit()``` | ```onexit()``` |\\n| Live trading stopped | ```onexit()``` | ```onexit()``` | ```onexit()``` |\\n| Uncaught exception or ```panic``` | ```onerror(msg)``` | neither | ```onexit()``` |\\n\\n**Notes:**\\n- ```onexit()``` and ```onerror()``` may run for at most 5 minutes (the limit is sent by the server with each task; the default is 5 minutes) and are terminated when they exceed it.\\n- In backtesting a strategy is usually an endless polling loop, so ```main()``` does not return normally when the backtest ends; see Strategy Structure → onexit() for how to handle this.\\n- When ```main()``` of a ```JavaScript``` strategy returns, threads created with ```threading``` are terminated; ```setTimeout``` callbacks that have not fired yet run first, then ```onexit()``` is called.\\n- ```JavaScript``` and ```Python``` template libraries can define their own ```init()```, which runs when the template is loaded, before the strategy's ```init()```.\\n\\n**Main loop and event-driven strategies**\\n\\nMost strategies run a loop in ```main()```: each round fetches data, computes, places orders, then calls ```Sleep()``` to wait for the next round (see Strategy Structure → Main Loop). A strategy can also wait for market data, order updates and other events and handle them as they arrive (see Strategy Structure → Event-Driven). For a categorized list of all API functions see Strategy Structure → API Quick Reference.\", \"title\": \"Strategy Structure\"}, {\"_src_hash\": \"a206e0ec5373f65d518bf6261200d003492c052ee0958eecf1990e0fe9f91f71\", \"children\": [{\"_src_hash\": \"f181df7dfcc36f55629fc500d74b542c763150412fb81c8f1673fd1e35628e16\", \"desc\": \"| Variable (naming example) | Description | Type | Default Value (description) | Component Configuration (description) | Remarks |\\n| - | - | - | - | - | - |\\n| pNum | Description of parameter pNum | Numeric (number) | Example: Set default value to 100; f64 in Rust strategies| Used to set the interface control bound to the current parameter: component type, minimum value, maximum value, grouping, filters, etc. | Remarks for parameter pNum, the value of pNum is numeric type |\\n| pBool | Description of parameter pBool | Boolean (true/false) | Use switch control to set default value, optional control not supported | Same as above | Remarks for parameter pBool, the value of pBool is boolean type |\\n| pStr | Description of parameter pStr | String (string) | Example: Set default value to abc | Same as above | Remarks for parameter pStr, the value of pStr is string type |\\n| pCombox | Description of parameter pCombox | Dropdown (selected) | Set one or more options from the options | Same as above | Remarks for parameter pCombox, the value of pCombox may have various forms |\\n| pSecretStr | Description of parameter pSecretStr | Encrypted string (string) | Example: Set default value to xyz | Same as above | Remarks for parameter pSecretStr, the value of pSecretStr is string type |\\n\\nInterface parameters are configured in the strategy parameters area below the code editor on the strategy editing page. Please note the following:\\n1. In the default value option of parameter settings, the \\\"Optional\\\" control is optional by default. You can change the state of this control to set the current parameter as required. After setting a parameter as required, if the parameter is not set during backtesting or live trading, backtesting cannot be performed or live trading cannot be started.\\n2. Variable names for interface parameters in strategy code should not use reserved words (keywords) of the current programming language.\\n3. In the backtesting or live trading interface, hovering the mouse over the control bound to a parameter will display the parameter's remarks.\\n4. The \\\"Description\\\" of a parameter is the display name of the control bound to the parameter.\\n5. The \\\"Variable\\\" of a parameter refers to those in the table above: ```pNum```, ```pBool```, ```pStr```, ```pCombox```, ```pSecretStr```. They exist as global variables in the strategy code, so the values of strategy parameters can be modified in the code (except in Rust, where parameters are global constants and cannot be modified).\\n6. For \\\"Encrypted string\\\" and \\\"String\\\" type parameters, no quotes are needed when entering default values; all input is treated as strings. \\\"Encrypted string\\\" parameters are used the same way as \\\"String\\\" parameters, but encrypted strings are transmitted encrypted and not sent in plain text.\\n7. If a \\\"String\\\" type parameter is set to \\\"Optional\\\", when no parameter is filled in the control bound to the parameter, the value of the parameter variable is **empty string**;\\n Similarly, the value of a \\\"Numeric\\\" parameter is **null**;\\n Similarly, the value of a \\\"Dropdown\\\" parameter is **null**;\\n Similarly, the value of an \\\"Encrypted string\\\" parameter is **null**.\\n In ```Rust``` strategies, an optional parameter that is left empty has the zero value of its type: ```0``` for numbers, an empty string for strings and encrypted strings, ```false``` for booleans.\\n8. For dropdown type interface parameters (e.g., variable name ```pCombox```), when \\\"Support multiple selection\\\" is not enabled in \\\"Component Configuration\\\", the value of pCombox is the index or specific data of the currently selected option (when data is bound to options).\\n If \\\"Support multiple selection\\\" is enabled, the value of pCombox is an array containing the indices or specific data of all currently selected options (when data is bound to options).\", \"title\": \"Interface Parameter Types\"}, {\"_src_hash\": \"79d7dcbbe358771cf5ace610a7801ed8175eb040464eec7af580e3f8a1fd061f\", \"desc\": \"Both strategy interface parameters and strategy interactive controls have a \\\"Component Configuration\\\" option. It sets the UI control used for the parameter (or interactive control), as well as the minimum, maximum, group, filter and so on.\\n\\nComponents supported by each type:\\n- Number (number)\\n Input box (default), time picker, slider.\\n- Boolean (true/false)\\n Switch only (default).\\n- String (string)\\n Input box (default), text box, time picker, color picker, currency, trading symbol.\\n- Dropdown (selected)\\n Dropdown (default), segmented control, currency, trading symbol.\\n- Encrypted string (string), strategy parameters only\\n Encrypted input box only (default).\\n- Button (button), interactive controls only\\n A single button (default), with no input.\\n\\n**Group**\\n\\nEnter a label in the \\\"Group\\\" box of the component configuration to put several strategy parameters in the same group (replacing the platform's old \\\"Strategy Grouping\\\" feature). Interactive controls can be grouped the same way (replacing the old \\\"Interactive Control Grouping\\\" feature).\\n\\n**Filter**\\n\\nIn the component configuration of a strategy parameter, the \\\"Filter\\\" box takes a condition expression that controls whether the parameter is available (replacing the platform's old \\\"Parameter Dependency\\\" feature).\\nThe filter is empty by default, meaning no filtering. Expressions such as ```a > b```, ```a == 1```, ```a```, ```!a``` and ```a >= 1 && a <= 10``` can be used. The parameter is available when the condition is true.\\n- With the filter ```a == 1```, the parameter's availability depends on the value of parameter ```a```: it is available when ```a``` equals 1, otherwise not.\\n- With the filter ```a >= 1 && a <= 10```, the parameter is available when ```a``` is greater than or equal to 1 and less than or equal to 10, otherwise not.\\n- With the filter ```!a```, the condition is \\\"not a\\\"; ```a``` can be a boolean or a number (```!0``` is true).\", \"title\": \"Component Configuration\"}, {\"_src_hash\": \"b7c15282155c21b3d333140e2d03cfcf5136c6c56d9df27e79bc6d7c2fc17b2a\", \"desc\": \"- Parameter saving in the backtesting system\\n When backtesting, if you want to save the strategy parameters, you can click the \\\"Save Backtest Settings\\\" button after modifying the strategy parameters. For details, see Backtesting System → Backtest Configuration and Saving.\\n\\n | Variable | Description | Type | Default Value |\\n | - | - | - | - |\\n |number |Numeric type |Number (number) |1 |\\n |string |String |String (string) |Hello FMZ |\\n |combox |Dropdown box |Dropdown (selected) |1\\\\|2\\\\|3|\\n |bool |Boolean value |Boolean (true/false) |true |\\n |numberA@isShowA |Numeric A |Number (number) |2 |\\n |isShowA |Whether to display the numberA parameter |Boolean (true/false) |false |\\n\\n The configured strategy parameters will be saved in the strategy in the form of code, for example:\\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 ```rust\\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 If a ```Rust``` strategy declares dependencies in a frontmatter block at the top, the backtest configuration block must come after the frontmatter (see Programming Languages → Rust).\\n- Importing and exporting live trading parameters\\n When running live trading, if you need to save the parameter data of the live trading configuration, you can click the \\\"Parameter Settings\\\" option on the strategy live trading page, then click the \\\"Export Parameters\\\" button. The exported strategy parameters will be saved as a ```json``` file.\\n The exported strategy parameter configuration can also be imported into live trading again. Click the \\\"Import Parameters\\\" button to import the saved strategy live trading parameters into the current live trading, and after importing, click the \\\"Update Parameters\\\" button to save and apply them.\", \"title\": \"Save Parameter Settings\"}], \"desc\": \"Parameters set in the strategy interface appear in the strategy code as global variables with the same names (global constants in Rust) and are accessed by name:\\n- ```JavaScript```, ```MyLanguage```: parameters can be read directly and the parameter variables can also be modified in code.\\n- ```Python```: parameters can be read directly; to assign a new value to one inside a function, declare it with ```global``` first.\\n- ```Rust```: parameters are constants that can only be read, not modified; see Programming Languages → Rust for the type of each kind of parameter.\\n- ```PINE```: interface parameters are created with the ```input()``` function.\\n- ```Blockly Visual```: there are no interface parameters.\\n\\n![Strategy Parameter Settings Interface](/upload/asset/2e46b5e593de3b2f11445.png)\", \"title\": \"Strategy Parameters\"}, {\"_src_hash\": \"272de84678d5c2e1bd8888206393a8529070bd9090e6f61461c76d95e30be569\", \"children\": [{\"_src_hash\": \"498dbe7e6c6013e9681687f6c9366ddaf93a3b13760457354cf81705a7d5039a\", \"desc\": \"| Variable (naming example) | Description | Type | Default Value (description) | Component Configuration (description) | Notes |\\n| - | - | - | - | - | - |\\n| cmdNum | Description of interactive control cmdNum | Number type (number) | Default value is optional, can be left empty | Used to set the component type, minimum value, maximum value, grouping, etc. of the interface control bound to the current interactive item | Notes for interactive control cmdNum |\\n| cmdBool | Description of interactive control cmdBool | Boolean type (true/false) | Default value is required, on or off | Same as above | Notes for interactive control cmdBool |\\n| cmdStr | Description of interactive control cmdStr | String type (string) | Default value is optional, can be left empty | Same as above | Notes for interactive control cmdStr |\\n| cmdCombox | Description of interactive control cmdCombox | Dropdown (selected) | Default value is optional, can be left empty | Same as above | Notes for interactive control cmdCombox |\\n| cmdBtn | Description of interactive control cmdBtn | Button (button) | Button control does not bind input items | Same as above | Notes for interactive control cmdBtn |\\n\\nMessages (strings) sent to the strategy after interactive control is triggered:\\n- Number type\\n After entering interactive data ```123``` in the input box of interactive control ```cmdNum```, click the button of interactive control cmdNum. The ```GetCommand()``` function in the strategy program will receive the message: ```cmdNum:123```.\\n- Boolean type\\n After setting the switch control of interactive control ```cmdBool``` to on, click the button of interactive control cmdBool. The ```GetCommand()``` function in the strategy program will receive the message: ```cmdBool:true```.\\n- String type\\n After entering interactive data ```abc``` in the input box of interactive control ```cmdStr```, click the button of interactive control cmdStr. The ```GetCommand()``` function in the strategy program will receive the message: ```cmdStr:abc```.\\n- Dropdown\\n After selecting the second option in the dropdown of interactive control ```cmdCombox```, click the button of interactive control cmdCombox. The ```GetCommand()``` function in the strategy program will receive the message: ```cmdCombox:1```, where 1 represents the index of the selected option, the first option has index 0, the second option has index 1.\\n- Button\\n Click the button of interactive control ```cmdBtn```. The ```GetCommand()``` function in the strategy program will receive the message: ```cmdBtn```.\\n\\nThe \\\"Component Configuration\\\" of interactive controls is the same as for strategy parameters (see Strategy Parameters → Component Configuration).\\n\\n**Example: changing a strategy parameter with an interactive control**\\n\\nOn the strategy editing page, add a string interactive control named ```changeSymbol``` under \\\"Strategy Interaction\\\". The settings of the interactive control:\\n\\n![Setting up an interactive control](/upload/asset/1741a2b35e569c5e07e3.png)\\n\\nWhile the strategy runs live, enter ```ETH_USDT``` in the control's input box and click its button; ```GetCommand()``` receives the message ```changeSymbol:ETH_USDT```. The strategy detects the message and updates the corresponding variable (parameters set in the strategy interface are global variables too; a global variable in the code is used here for demonstration):\\n\\n```js\\n// strategy parameter\\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 // the changeSymbol control was triggered: update the parameter\\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```\", \"title\": \"Types of Interactive Controls\"}, {\"_src_hash\": \"6de560c1670ad5809a3999bd19a2affe30bb6f7da7e056ae35c86b0004865e06\", \"desc\": \"In addition to designing interactive controls in the \\\"Strategy Interaction\\\" section, you can also design interactive controls in the strategy status bar. Currently, the only supported interactive control type is the button type. See {@fun/Log/LogStatus LogStatus}.\\n\\nButton controls in the status bar can be divided into:\\n- Regular button controls\\n Data structure example:\\n ```json\\n {\\\"type\\\": \\\"button\\\", \\\"name\\\": \\\"Button 1\\\", \\\"cmd\\\": \\\"button1\\\", \\\"description\\\": \\\"This is the first button\\\"}\\n ```\\n- Button controls with a single input data\\n Use the ```input``` attribute to set input control options. Data structure example:\\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- Button controls with a group of input data\\n Use the ```group``` attribute to set options for a group of input controls. Data structure example:\\n ```json\\n {\\n \\\"type\\\": \\\"button\\\",\\n \\\"cmd\\\": \\\"open\\\",\\n \\\"name\\\": \\\"Open\\\",\\n \\\"group\\\": [\\n {\\\"name\\\": \\\"orderType\\\", \\\"description\\\": \\\"Order Method|order type\\\", \\\"type\\\": \\\"selected\\\", \\\"defValue\\\": \\\"Market Order|Limit Order\\\"},\\n {\\\"name\\\": \\\"tradePrice@orderType==1\\\", \\\"description\\\": \\\"Trade Price|trade price\\\", \\\"type\\\": \\\"number\\\", \\\"defValue\\\": 100},\\n {\\\"name\\\": \\\"orderAmount\\\", \\\"description\\\": \\\"Order Quantity|order amount\\\", \\\"type\\\": \\\"string\\\", \\\"defValue\\\": 100},\\n {\\\"name\\\": \\\"boolean\\\", \\\"description\\\": \\\"Yes/No|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\\nEncode the JSON data of these button controls as a JSON string, then wrap it with ``` ` ``` characters and output it in the status bar. Using JavaScript as an example:\\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\\nThese button controls can also be written into status bar tables. For detailed examples see {@fun/Log/LogStatus LogStatus}.\\n\\nThe ```input``` field structure is consistent with the single control structure in the ```group``` field. The following is a detailed explanation (an annotated JavaScript object):\\n\\n```js\\n{\\n \\\"type\\\": \\\"selected\\\", // Control type (required field), supports: number, string, selected, boolean\\n \\\"name\\\": \\\"test\\\", // Name (required field when used in group)\\n \\\"label\\\": \\\"topic\\\", // Title (required field)\\n \\\"description\\\": \\\"desc\\\", // Tooltip information for the component\\n \\\"default\\\": 1, // Default value; if the settings field is not set in the current JSON structure, it is compatible with defValue, and defValue can be used instead of default\\n \\\"filter\\\": \\\"a>1\\\", // Selector, not setting this field means no filtering (display control); when this field is set, the control is not filtered (displayed) when the expression is true, and filtered (not displayed) when the expression is false\\n // For the selector, using the expression a>1 in this example, 'a' refers to the control value with name 'a' under the group field in the type=button structure, and this value is used to determine whether to filter\\n \\\"group\\\": \\\"group1\\\", // Grouping\\n \\\"settings\\\": {} // Component configuration, fields described below\\n}\\n```\\n\\nDetailed explanation of each field in the component configuration ```settings```:\\n- ```settings.required```: Whether it is required.\\n- ```settings.disabled```: Whether it is disabled.\\n- ```settings.min```: Valid when ```type=number```, represents the minimum value.\\n- ```settings.max```: Valid when ```type=number```, represents the maximum value.\\n- ```settings.step```: Valid when ```type=number``` and ```render=slider```, represents the step size.\\n- ```settings.multiple```: Valid when ```type=selected```, indicates support for multiple selection.\\n- ```settings.customizable```: Valid when ```type=selected```, indicates support for customization; users can directly edit and add new options in the dropdown control. If a newly edited option is selected, the option's name will be used instead of the option's value when triggering the interaction.\\n- ```settings.options```: Valid when ```type=selected```, represents the selector's option data format: ```[\\\"Option 1\\\", \\\"Option 2\\\"]```, ```[{'name':'xxx','value':0}, {'name':'xxx','value':1}]```.\\n- ```settings.render```: Render component type.\\n When ```type=number```, ```settings.render``` is not set (defaults to number input box), options: ```slider``` (slider), ```date``` (date picker, returns timestamp).\\n When ```type=string```, ```settings.render``` is not set (defaults to single-line input box), options: ```textarea``` (multi-line input), ```date``` (date picker, returns yyyy-MM-dd hh:mm:ss), ```color``` (color picker, returns #FF00FF).\\n When ```type=selected```, ```settings.render``` is not set (defaults to dropdown), options: ```segment``` (segmented selector).\\n When ```type=boolean```, currently only the default checkbox is available.\\n\\nBilingual settings are supported. For example, the text ```'选项|options'``` adapts to the current language. Using a single control in the ```group``` field as an example, a complete example (a JavaScript object):\\n\\n```js\\n{\\n type:'selected',\\n name:'test',\\n label:'选项|options',\\n description:'描述|description',\\n default:0, // Here the default value is set to 0, representing the value in {name:'xxx|yyy',value:0} option\\n filter:'a>1&&a<10',\\n group:'Group|group',\\n settings:{\\n multiple:true,\\n customizable:true,\\n options:[{name:'xxx|yyy',value:0}]\\n }\\n}\\n```\", \"title\": \"Interactive Controls in Status Bar\"}], \"desc\": \"Strategies in ```JavaScript```, ```Python```, ```Rust``` and MyLanguage can have interactive controls, which send interaction commands to the strategy while it is running live. In ```JavaScript```, ```Python``` and ```Rust``` strategies, the messages produced by interactive controls are read with the {@fun/Global/GetCommand GetCommand} function. The \\\"Component Configuration\\\" of interactive controls is the same as for strategy parameters (see Strategy Parameters → Component Configuration).\\n\\n![Interactive Controls](/upload/asset/2e4320d0cc33c15eb935d.png)\\n\\nWith code in the strategy that handles interactive control messages, interactive controls in live trading can be used for (among other things):\\n- Manually closing the strategy's positions.\\n- Changing strategy parameters dynamically without restarting the live trading.\\n- Switching strategy logic.\\n- Printing debugging information or data to test a feature.\", \"title\": \"Interactive Controls\"}, {\"_src_hash\": \"1ca4ec5eefb2babb01bedc8c9ad1503a4f882b0965b15084fde2f4eec27cc693\", \"children\": [{\"_src_hash\": \"26435f824f1ecb1a6b0f3b2752c47d09e40cd38a72bb4365f76c05ed9713c382\", \"desc\": \"Export functions are the interface functions of template libraries, which can be called by strategies that reference the template library.\", \"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\": \"// after referencing this template, a strategy calls it as ext::Test()\\n// functions called by the strategy must be declared pub\\npub fn Test() {\\n Log!(\\\"template call\\\");\\n}\", \"lang\": \"rust\"}], \"value\": \"Different programming languages have different formats for writing template libraries. The following are example codes for declaring and implementing export functions in template libraries:\"}, {\"value\": \"Strategies written in ```Blockly visual``` mode can implement library functions through ```JavaScript``` language template libraries. Please use the following format.\\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\": \"Export Functions of Template Libraries\"}, {\"_src_hash\": \"324893503da9cadd8970462af372a35d544238d76c2175e0789742095672bfd5\", \"desc\": \"Template libraries can also set their own interface parameters. Template library parameters are used as global variables in the template library code.\\n\\nFor example, we set a template library parameter:\\n\\n![Template Parameter](/upload/asset/2e4ab550b85e6a1cac08e.png)\\n\\n| Variable Name in Strategy Code | Parameter Name Displayed on Strategy Interface | Type | Default Value |\\n| - | - | - | - |\\n| param1 | Template Parameter 1 | Number | 99 |\\n\\nParameters of a ```Rust``` template are constants that can only be read, not modified, so in Rust the example below can only read the parameter:\\n\\n```rust\\n// template code\\npub fn GetParam1() -> f64 {\\n Log!(\\\"param1:\\\", param1);\\n param1\\n}\\n```\\n\\n```rust\\n// strategy code\\nfn main() {\\n Log!(\\\"Calling ext::GetParam1:\\\", ext::GetParam1());\\n}\\n```\", \"examples\": [{\"examples\": [{\"code\": \"$.SetParam1 = function(p1) {\\n param1 = p1\\n}\\n\\n$.GetParam1 = function() {\\n Log(\\\"param1:\\\", param1)\\n return param1\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def SetParam1(p1):\\n global param1\\n param1 = p1\\n\\ndef GetParam1():\\n Log(\\\"param1:\\\", param1)\\n return param1\\n\\next.SetParam1 = SetParam1\\next.GetParam1 = GetParam1\", \"lang\": \"python\"}, {\"code\": \"// Rust template parameters are read-only constants; see above for how to read them\", \"lang\": \"rust\"}], \"value\": \"Template library code for testing the ```param1``` parameter:\"}, {\"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\": \"// Rust template parameters are read-only constants; see above for how to read them\", \"lang\": \"rust\"}], \"value\": \"Strategy code referencing the above template library example, using the template library's exported functions to get parameter ```param1``` and modify parameter ```param1```.\"}], \"title\": \"Template Library Parameters\"}, {\"_src_hash\": \"b473e57cc099945d38c87d179784ed7b286337dc9c69722dbc5e8bd8ce4fad05\", \"desc\": \"When a strategy references a template library, the currently logged-in FMZ Quant Trading Platform account must have available template libraries in its strategy library. On the [Strategy Edit Page](https://www.fmz.com/m/add-strategy), check the templates you need to reference in the Template section, then save the strategy to complete the reference.\\n\\n![Template Reference Screenshot](/upload/asset/2e4ee2ec7b3e7b1649af8.png)\", \"title\": \"Reference Template Library\"}], \"desc\": \"A **template library** is a reusable code module on the FMZ Quant Trading Platform and a category of strategy code. Languages that support template libraries: ```JavaScript``` (including TypeScript), ```Python``` and ```Rust```; ```Blockly Visual``` strategies can use blocks provided by JavaScript template libraries. If the category is set to template library when a strategy is created, a template library is created in the strategy library of the logged-in account; its category cannot be changed to an ordinary strategy afterwards.\\n\\n![Create Template Library Page](/upload/asset/2e4c55da99fd457ca94a0.png)\\n\\nHow template functions are exported and called in each language:\\n\\n| Language | Export in the template | Call in the strategy |\\n| - | - | - |\\n| JavaScript | attach to ```$```: ```$.Test = function() {...}``` | ```$.Test()``` |\\n| Python | attach to ```ext```: ```ext.Test = Test``` | ```ext.Test()``` |\\n| Rust | the template code goes into the ```ext``` module; functions the strategy calls are declared ```pub fn``` | ```ext::Test()``` |\\n\\n- A template's ```main()``` function is not run by the strategy; it is only the entry point for backtesting or debugging the template on its own.\\n- ```JavaScript``` templates can define ```init()``` and ```destroy()```: ```init()``` runs when the template is loaded (before the strategy's ```init()```), and ```destroy()``` runs when the strategy exits, after ```onexit()``` or ```onerror()```. ```Python``` templates can define ```init()```, which runs when the template is loaded.\\n- Both ```Rust``` templates and strategies can declare third-party crates in a frontmatter block, but the dependency block may appear in only one of them; declaring it in both fails the build.\", \"title\": \"Template Library\"}, {\"_src_hash\": \"741cfc8ca91f042797472513837c7d82f585d592eebc941aabc96e62a92b9c77\", \"children\": [], \"desc\": \"The FMZ Quant Trading Platform has some commonly used libraries built in. Availability by language:\\n\\n| Library | JavaScript / TypeScript | Python | Rust |\\n| - | - | - | - |\\n| ```TA``` indicators | yes | yes | yes |\\n| ```talib``` indicators | yes | requires TA-Lib and numpy installed on the docker's machine | no |\\n| JSON | the language's built-in ```JSON``` | the standard ```json``` module | ```JSONParse()```/```JsonValue``` |\\n\\nFor the full list of functions and their arguments see {@fun/TA TA} and {@fun/Talib Talib} in the reference.\\n\\n**TA indicator library**\\n\\nThe platform's ```TA``` library optimizes the common indicator algorithms ([open-source TA library code](https://www.fmz.com/bbs-topic/409)). Where there are not enough K-lines to compute an indicator, invalid values are returned at those positions.\\n\\n```js\\nfunction main(){\\n var records = exchange.GetRecords()\\n var macd = TA.MACD(records)\\n var atr = TA.ATR(records, 14)\\n\\n // print the last set of indicator values\\n Log(macd[0][records.length-1], macd[1][records.length-1], macd[2][records.length-1])\\n Log(atr[atr.length-1])\\n}\\n```\\n\\n```rust\\nfn main() {\\n let r = exchange.GetRecords(None, None, None).unwrap();\\n let macd = TA.MACD(&r, None, None, None);\\n let atr = TA.ATR(&r, 14);\\n Log!(macd[0][r.len() - 1], macd[1][r.len() - 1], macd[2][r.len() - 1]);\\n Log!(atr[atr.len() - 1]);\\n}\\n```\\n\\n**talib indicator library**\\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 needs TA-Lib and numpy installed on the docker's machine; without them calling talib raises an error asking to install it\\ndef main():\\n records = exchange.GetRecords()\\n cci = talib.CCI(records.High, records.Low, records.Close, 14)\\n Log(cci)\\n```\\n\\n**JavaScript: loading third-party libraries dynamically**\\n\\nOther third-party JavaScript libraries can be downloaded at run time and loaded with ```eval```:\\n\\n```js\\nfunction main() {\\n // via. https://cdnjs.com/libraries\\n eval(HttpQuery(\\\"https://cdnjs.cloudflare.com/ajax/libs/mathjs/13.2.0/math.min.js\\\"))\\n\\n Log(math.round(math.e, 3)) // 2.718\\n Log(math.atan2(3, -3) / math.pi) // 0.75\\n Log(math.log(10000, 10)) // 4\\n Log(math.sqrt(-4)) // {\\\"mathjs\\\":\\\"Complex\\\",\\\"re\\\":0,\\\"im\\\":2}\\n}\\n```\", \"title\": \"Built-in Libraries\"}, {\"_src_hash\": \"fa2c4213e910477952394cc09ed555da66ba9b7b7a101e4b3e1d95b361709c8d\", \"children\": [], \"desc\": \"Both the strategy name and the descriptions of strategy parameters can be written in the ```Chinese|English``` format, allowing the web page to automatically recognize and display the corresponding language. In other use cases—such as **strategy description**, **usage instructions**, and other ```Markdown```-formatted text—using ```[trans]Chinese|English[/trans]``` or ```[trans]Chinese||English[/trans]``` can likewise achieve automatic language recognition. After switching the language, refresh the web page for it to take effect. In addition, in strategy code, any function that can accept a string also supports language switching, such as the ```Log()``` function, the ```LogStatus()``` function, and so on.\\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\\\"}] // Note: there is no need to add the [trans] tag inside buttons\\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```rust\\nfn main() {\\n Log!(\\\"[trans]日志|log[/trans]\\\");\\n let table = r#\\\"{\\n \\\"type\\\": \\\"table\\\",\\n \\\"title\\\": \\\"[trans]操作|option[/trans]\\\",\\n \\\"cols\\\": [\\\"[trans]列1|col1[/trans]\\\", \\\"[trans]列2|col2[/trans]\\\", \\\"[trans]操作|option[/trans]\\\"],\\n \\\"rows\\\": [\\n [\\\"[trans]比特币|BTC[/trans]\\\", \\\"[trans]以太坊|ETH[/trans]\\\", {\\\"type\\\": \\\"button\\\", \\\"cmd\\\": \\\"coverAll\\\", \\\"name\\\": \\\"平仓|cover\\\", \\\"description\\\": \\\"描述|description\\\"}]\\n ]\\n }\\\"#;\\n LogStatus!(\\\"[trans]信息|message[/trans]\\\", format!(\\\"\\\\n`{}`\\\", table));\\n Panic!(\\\"[trans]错误|error[/trans]\\\");\\n}\\n```\", \"title\": \"Multi-language Support\"}], \"desc\": \"Writing strategies in the supported languages: notes for each language, strategy structure (lifecycle, main loop, event-driven), strategy parameters, interactive controls, template libraries, built-in libraries, and multi-language text in the strategy UI.\", \"title\": \"Writing Strategies\"}, {\"_src_hash\": \"b7226f8b8520982c4b151ce37783450236e8b1a3cf1da34aa476f102904bd68a\", \"children\": [{\"_src_hash\": \"526c6f7ea00725409648f55d8915c8b4bc135b2006be2978f0a854669ba82f60\", \"children\": [{\"_src_hash\": \"8f700a46e39eaf7f8e036e0c6f69168e3209d627bb9bd40fc00bd4592d3202ab\", \"desc\": \"The strategy editor has a built-in AI assistant that generates strategy code from a description, explains and edits selected code, adjusts strategy parameters and interactive controls, and runs backtests and analyzes their results automatically.\\n\\n- AI assistant panel\\n The AI assistant panel sits to the right of the code editor and can be collapsed or expanded. Describe what you want in the input box to start a conversation; code selected in the editor beforehand becomes context for the conversation.\\n Changes the AI proposes to code, parameters and interactive controls are shown as diffs that you can \\\"Accept\\\" or \\\"Reject\\\" one by one, or accept all at once; it asks for permission before modifying the strategy or running a backtest automatically.\\n- Quick actions on selected code\\n Select code and right-click: the menu has AI actions (such as explaining or optimizing the code), which can also be triggered with ```⌘1```, ```⌘2```, ... (```Ctrl+1```, ```Ctrl+2```, ... on Windows).\\n\\n ![AI assistant explaining code in the strategy editor](/upload/asset/16aa01684eda4e8163ed.png)\\n- Smart completion\\n Turn smart completion on or off from the right-click menu, or with ```⌘J``` (```Ctrl+J``` on Windows).\\n\\nThe AI assistant is charged to your account balance by usage, and each conversation shows its cost.\\n\\nBesides the assistant in the editor, you can connect the external AI assistant you already use to the platform and manage strategies, backtests and live robots through conversation (see Integrations → AI Integration).\", \"title\": \"AI Assistant\"}, {\"_src_hash\": \"1f0022e02bde493aca9b6ce1a8f5ad34eb0cb317ca3f44e4d0685be69f92bc6f\", \"desc\": \"Right-click in the strategy code editing area and select \\\"Command Palette\\\" from the context menu to view keyboard shortcuts and editor commands for various functions.\\n\\n![Command Palette display in strategy editor menu](/upload/asset/2e429269f02185dfbab3b.png)\", \"title\": \"Command Palette\"}, {\"_src_hash\": \"d683441a52852bd25ba43f4124353063fbb216d3d2212e473405c19e8997220a\", \"desc\": \"In the \\\"Code\\\" editing area of the **Strategy Editor Page**, you can quickly access the \\\"Syntax Manual\\\". Use the corresponding keyboard shortcuts based on your operating system:\\n\\n![Syntax Manual Quick Reference in Strategy Editor](/upload/asset/2e4d0722af99164f69996.png)\\n\\n- In browsers on Mac systems (Apple computers): Hold down the ```⌘``` key.\\n- In browsers on Windows systems: Hold down the ```Ctrl``` key.\\n\\nThen when you hover your mouse over the **variable name** or **function name** you want to look up, a jump link will appear. Click the link to open the \\\"Syntax Manual\\\" popup, which will automatically navigate to the queried content.\", \"title\": \"Syntax Manual Quick Reference\"}, {\"_src_hash\": \"a9dec6fc6f6c1f96fc0a464110501c40f54fc78925e74471342beb46491981c1\", \"desc\": \"Select the content you want to query, then right-click to open the context menu.\\n\\n- Go to Definition: Navigate to the definition location of the queried content.\\n\\n- Go to References: Navigate to the reference locations of the queried content.\\n\\n- Peek - Peek Definition: View the definition of the selected code without leaving the current line.\\n\\n- Peek - Peek References: View references to the current code in other lines without leaving the current position, with support for quick navigation to better understand code logic and structure.\", \"title\": \"Go to Definition and References\"}, {\"_src_hash\": \"8fe62a954909122634b24599f756adba484905fb01bab82b924266be7b19e142\", \"desc\": \"The online strategy editing page keeps the code, description, usage instructions and development notes of a strategy separately.\\n\\n![Strategy documentation options](/upload/asset/2e47983c191c1779bd52e.png)\\n\\n- Code: the source code of the strategy program.\\n A complete strategy on the platform consists of the source code, the strategy parameter design, the interactive control design and the template library references (see Writing Strategies → Strategy Parameters, Interactive Controls and Template Libraries).\\n- Notes: notes taken while developing the strategy.\\n- Description: the introduction shown when the strategy is published.\\n- Manual: instructions visible only to those who rent the strategy.\", \"title\": \"Strategy Documentation\"}, {\"_src_hash\": \"2ed575980932d1219b48b3d099e1aff1daabb4620f924a11ec62509e29e5e75b\", \"desc\": \"The platform supports version iteration functionality during strategy development. On the **Strategy Editing Page**, click the \\\"History Version\\\" button in the \\\"Code\\\" editing area to open the strategy history version management page.\\n\\n- When the current strategy has no history version snapshots, click the \\\"Create Now\\\" button to create a snapshot of the current strategy. Snapshot contents include: strategy code, notes, description, manual, parameter design, interaction design, etc.\\n\\n- After creating a history snapshot, the saved history snapshot list will be displayed on the right side of the history version management page. Click the \\\"Create History Version\\\" button above the list to continue saving new history snapshots.\\n\\n- Edit and use history snapshots: You can perform operations such as **modify history snapshot name**, **delete history snapshot**, and **restore to the strategy version of the history snapshot** on recorded strategy history snapshots.\\n\\n- Preview the currently selected history snapshot: Click the \\\"Preview\\\" button at the bottom left of the history version management page to preview the strategy code, notes, description, manual, parameter design, interaction design, and other contents in the current history snapshot.\\n\\n- Compare the differences between the currently selected history snapshot and the current strategy: Click the \\\"Compare\\\" button at the bottom left of the history version management page to compare the differences between the current history snapshot and the current strategy.\\n\\n\\n## Running History Versions in Live Trading\\n\\nStrategy history versions can not only be used for code management and version rollback, but can also be run directly in live trading:\\n\\n- **Set Default Running Version**: On the strategy editor page, click the \\\"History Version\\\" button, select a history version, then click the \\\"Modify\\\" button in the menu. In the popup, you can check the \\\"Set as Default Version\\\" option. If not set, the latest version will run by default.\\n\\n- **Use History Version in Live Trading**: When creating a live trading instance or modifying live trading parameters, the strategy owner can select a specific history version of the strategy to run. This feature is only available to the strategy owner.\\n\\n- **Version Control for Rented Strategies**: When a strategy is rented to other users, the renter can only run the \\\"default running version\\\" set by the strategy owner and cannot select other history versions. The strategy owner can control which version is used for rented strategies by setting the default running version.\", \"title\": \"History Version Management\"}], \"desc\": \"Open the **edit page** from the [new strategy page](https://www.fmz.com/m/add-strategy) or by opening an existing strategy in the [Strategy Library](https://www.fmz.com/m/strategies) (for strategy ID 123456 the address is ```https://www.fmz.com/m/edit-strategy/123456```) to write strategies.\\n\\n![Online strategy editor](/upload/asset/2e50fff4160187be92248.png)\\n\\nThis chapter covers the editor's assistance features. Related features of the editing page:\\n- Remote editing: write in a local editor and sync to the platform automatically (see Development Tools → Remote Editing).\\n- Backtest configuration and saving: save the backtest configuration and strategy parameters with the strategy (see Backtesting System).\\n- Import and export of complete strategies: export and import a strategy with its parameters and everything else (see Platform Basics → Strategy Library).\", \"title\": \"Strategy Editor\"}, {\"_src_hash\": \"f01696ca44480a0fc94d2148bab0017249e2bb0644b0daf9f7fd67b6c111ae47\", \"children\": [], \"desc\": \"The [Debugging Tool](https://www.fmz.com/m/debug) page provides a free environment for quickly testing live trading code, currently supporting only the ```JavaScript``` language.\\n\\n![Debugging Tool](/upload/asset/2e48d6d1bc77e46099058.png)\\n\\nWhen using the debugging tool to test code, the code will run directly on the specified docker, with a maximum runtime of 3 minutes. It supports calling all API functions of the FMZ Quant Trading Platform, but only supports a single exchange object.\", \"title\": \"Debugging Tool\"}, {\"_src_hash\": \"d3caefd50f5dcf3306b7ff40c7f3a57f078776b1fa987dc11d056851679e9e7d\", \"children\": [], \"desc\": \"You can write a strategy in a local editor and have it synced to FMZ automatically on save. ```VSCode```, ```Vim``` and ```Sublime Text 3``` are supported; ```JavaScript``` strategies can also use ```WebStorm``` and ```Python``` strategies ```PyCharm```. Blockly visual strategies do not support remote editing.\\n\\n![Remote editing screenshot](/upload/asset/2e4e8975d1e32517fd989.png)\\n\\n**Steps**\\n1. Click \\\"Remote Editing\\\" on the strategy editing page. The top of the dialog has download links for the editor plugins; follow one to the plugin page and install it (installation differs slightly between editors).\\n2. The dialog shows the current strategy's remote sync token. If it is empty, click \\\"Update Token\\\" to generate one.\\n3. Save the strategy source locally and insert the token line shown in the dialog as the first line (e.g. ```// fmz@``` for ```JavaScript```, ```# fmz@``` for ```Python```); from then on every save is synced to the platform.\\n\\nWithout a plugin you can upload the local source with ```curl``` (the dialog shows the full command with your token), for example:\\n\\n```bash\\ncurl -T quant.js -H \\\"Authorization: Bearer \\\" https://www.fmz.com/rsync\\n```\\n\\n**Managing the token**\\n- \\\"Update Token\\\": generates a new token; the old one stops working at once.\\n- \\\"Delete Token\\\": deletes the strategy's token and turns remote editing off.\\n\\nAnyone holding the token can overwrite the strategy's source code, so keep it private.\", \"title\": \"Remote Editing\"}], \"desc\": \"Tools for writing and debugging strategies: the strategy editor, the debugging tool and remote editing from a local editor.\", \"title\": \"Development Tools\"}, {\"_src_hash\": \"69618d1ce04d499c37a4083833918aca8f0a32f2ecaef4df310801e2aff62d53\", \"children\": [{\"_src_hash\": \"1ec95c2d4c62b9956cdd3ff46f00bb8c243c28a06c439cc678b932ea8aca6e7b\", \"desc\": \"A backtest drives the strategy code with the platform's historical market data: the backtest engine keeps a virtual clock and one simulated account per exchange object, and answers every market, order and account call from history. A backtest only shows how the strategy would have behaved on past data; the past does not represent the future, so read backtest results with caution.\\n\\n**Starting a backtest**\\n\\n- Website: open the strategy editor, switch to the \\\"Backtest\\\" tab, set the backtest configuration and strategy parameters, then click \\\"Start Backtest\\\" (keyboard shortcuts: see Backtesting System → Backtest Page Shortcuts). The configuration can be saved into the strategy source, see Backtesting System → Backtest Configuration and Saving.\\n- AI assistant: start a backtest with the MCP tool ```run_backtest``` and read the result with ```get_backtest```, see Integrations → AI Integration. Backtests started through MCP always use the simulated-tick mode.\\n- Your own machine: use the open-source local backtest engine, see Backtesting System → Local Backtesting Engine.\\n\\n**Configuration items**\\n\\n| Item | Description |\\n| - | - |\\n| Time range | Start and end time of the backtest. |\\n| K-line period | The K-line period that ```GetRecords()``` returns by default. |\\n| Base K-line period | The K-line period from which ticks are generated in simulated-tick mode. Smaller is closer to real markets and slower. Strategy K-lines are built from base K-lines, so they cannot be shorter than the base period. |\\n| Mode | Simulated tick or real tick, see Backtesting System → Backtest Modes and Order Matching. |\\n| Exchange, trading pair | Each exchange object has its own simulated account; pairs are written like ```BTC_USDT```. For futures exchanges the strategy must call ```exchange.SetContractType()``` before requesting market data or placing orders. |\\n| Initial funds | Initial balances of the quote currency (e.g. USDT) and the base currency (e.g. BTC). Coin-margined contracts use the base currency as margin, so set the base-currency balance. |\\n| Fees | Maker and taker rates in percent; the defaults come from the exchange market's configuration. A limit order that fills immediately when placed pays the taker rate; one that rests in the book and is filled later pays the maker rate. |\\n| Slippage | Number of price ticks added outside the simulated best bid and best ask; default 0. |\\n| Network delay | In milliseconds; every exchange call advances the virtual clock by this amount; default 200. |\\n| Depth levels, amount per level | Number of levels ```GetDepth()``` returns (1-20) and the amount on each simulated level; in real-tick mode the depth levels are the real depth requested from the data source. |\\n| Max K-line bars | Upper limit of history bars returned by the first ```GetRecords()``` call (100-5000, default 300). |\\n| Log limits | Upper limits on kept runtime logs, profit logs and chart data points. |\\n| Data source | The platform's historical data by default; a custom data source can be used instead, see Backtesting System → Custom Data Source. |\\n\\n**Fault-tolerance test**\\n\\nThe backtest page also offers a \\\"fault-tolerance test\\\": exchange calls fail with a given probability (0.5 by default), and the first call of each kind always fails; each failure is logged as the error ```FaultTolerant Test```. Use it to check how the strategy handles failed calls, e.g. whether it retries with ```_C()```.\\n\\n**What the strategy sees in a backtest**\\n\\n- ```IsVirtual()``` returns ```true```; logic that must not run in a backtest can be skipped based on it, see {@fun/Global/IsVirtual IsVirtual}.\\n- Time is virtual: ```Unix()```, ```_D()``` and similar functions read the backtest clock, and ```Sleep()``` advances it. When the clock passes the end time, the engine throws an ```EOF``` exception and the backtest ends; ```onexit()``` is not called in that case.\\n- In a backtest ```GetCommand()``` receives no interactive commands, ```onerror()``` is not supported, and network request functions are restricted.\", \"title\": \"Overview and Starting a Backtest\"}, {\"_src_hash\": \"7e3c93e74cc0150d98aa24295c1301b3b11d2986f61fb8c0b367a3b9d60fa466\", \"desc\": \"There are two backtest modes, **simulated tick** and **real tick**. Both are based on real historical data: simulated tick generates ticks from K-lines, real tick replays recorded ticks. The latter is more accurate and slower.\\n\\n**Simulated tick**\\n\\nWithin the price frame of each base K-line (open, high, low, close), the engine generates 2-14 simulated ticks along the path open → low/high → close and spreads the bar's volume over them; market calls return the data of the current simulated tick. Each base K-line therefore has several backtest time points, and a strategy can trade several times inside one bar instead of only at the close. The smaller the base K-line period, the closer the ticks follow the real price path, and the slower the backtest. Details: [Simulated-tick mechanism](https://www.fmz.com/bbs-topic/662), [Backtesting mechanism](https://www.fmz.com/digest-topic/4009).\\n\\nSimulated order book: best ask = tick close + one tick + slippage, best bid = close − one tick − slippage (slippage counted in ticks); ```GetDepth()``` returns several simulated levels spaced by that amount, each with the configured \\\"amount per level\\\".\\n\\n**Real tick**\\n\\nUses per-second ticks recorded by the platform, including order-book depth (configurable, up to 20 levels) and, optionally, replayed trade prints; ```GetDepth()``` and ```GetTrades()``` return the replayed real data. Because the data is large and the backtest slow, one backtest may use at most 50 MB of data, which limits the time range; to cover a longer range, lower the depth levels and do not use trade prints. Early periods may have no real-tick data, so do not choose a start time that is too early.\\n\\nAt a given market moment, calling each of ```GetTicker()```, ```GetDepth()```, ```GetTrades()``` and ```GetRecords()``` once does not move the backtest time; calling the same function again jumps to the next market moment. In real-tick mode keep the ```Sleep()``` in the strategy loop short (e.g. 100 ms).\\n\\n**Order matching**\\n\\nBoth modes use the same matching rules:\\n\\n- Orders fill when the price is touched, and always in full; there are no partial fills in a backtest.\\n- A market order fills on the current tick at the best ask/bid; the amount of a spot market buy order is in the quote currency.\\n- A limit buy fills when its price is at or above the best ask, a limit sell when its price is at or below the best bid; this is checked on every tick after the order is placed. An order that fills immediately when placed fills at the market price and pays the taker fee; an order that rests in the book and is touched later fills at its own price and pays the maker fee.\\n- In real-tick mode an order resting exactly at the best bid/ask fills only after the volume queued ahead of it has been consumed.\\n- Futures freeze margin of notional value ÷ leverage; when the market data includes funding rates, perpetual contracts are charged funding.\\n\\n**Effect of data granularity**\\n\\nThe same strategy produces different trade counts and P&L at different data granularities (real tick, simulated tick with a small base period, simulated tick with a large base period, ...). Coarse data backtests faster but may give misleading results, so use fine granularity where possible. The following strategy can be backtested at several granularities for comparison:\\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 // Price rose above the threshold -> go short\\n exchange.Sell(ticker.Last, lotSize)\\n Log(\\\"Short @\\\", ticker.Last)\\n direction = \\\"short\\\"\\n } else if ((!direction || direction == \\\"short\\\") && diff <= -delta) {\\n // Price fell below the threshold -> go long\\n exchange.Buy(ticker.Last, lotSize)\\n Log(\\\"Long @\\\", ticker.Last)\\n direction = \\\"long\\\"\\n }\\n // Keep it short in tick mode; it has no effect in K-line mode\\n Sleep(100)\\n }\\n}\\n```\", \"title\": \"Backtest Modes and Order Matching\"}, {\"_src_hash\": \"2c5ff13dad5c0022d6cfa68d2d0895c7a5ccab6ea3423b686de44f04ce5376e2\", \"desc\": \"The backtest configuration on the \\\"Backtest\\\" tab (time range, exchanges, fees, ...) and the strategy parameters can be saved with the strategy and are loaded again the next time the strategy is opened.\\n\\n**Saving**\\n\\n- Click \\\"Save Backtest Settings\\\": the configuration and strategy parameters are written as a comment block (the ```backtest``` block) at the top of the strategy source.\\n- Click \\\"Save Strategy\\\": the platform also records the current backtest configuration and strategy parameters.\\n\\n**Loading**\\n\\n- When the strategy editor is opened or refreshed, the configuration in the source's ```backtest``` block is loaded first.\\n- If the source has no ```backtest``` block, the configuration recorded by the last \\\"Save Strategy\\\" is loaded.\\n- After editing the ```backtest``` block by hand, click the \\\"Backtest Settings\\\" button above the block to apply the change to the backtest form.\\n\\n**Block format**\\n\\nThe word ```backtest``` follows the language's block-comment opener directly, then one ```key: value``` per line:\\n\\n```js\\n/*backtest\\nstart: 2024-01-01 00:00:00\\nend: 2024-03-01 00:00:00\\nperiod: 1h\\nbasePeriod: 15m\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"balance\\\":10000,\\\"stocks\\\":0,\\\"fee\\\":[0.1,0.1]}]\\nargs: [[\\\"fast\\\",5],[\\\"slow\\\",20]]\\n*/\\n```\\n\\nComment syntax per language: JavaScript, TypeScript, Rust and PINE use ```/*backtest ... */```; Python uses ```'''backtest ... '''```; MyLanguage uses ```(*backtest ... *)```.\\n\\n| Key | Format | Description |\\n| - | - | - |\\n| start, end | ```YYYY-MM-DD HH:mm:ss``` | Start and end time, parsed in the browser's time zone. |\\n| period | ```1m```, ```1h```, ```1d``` etc., or seconds | Strategy K-line period. |\\n| basePeriod | same | Base K-line period; defaults to ```period```; ignored in real-tick mode. |\\n| mode | ```1``` | Real-tick mode; omit for simulated-tick mode. |\\n| exchanges | JSON array | One element per exchange object, fields below. |\\n| args | JSON array | Strategy parameters, ```[[\\\"name\\\", value], ...]```; a third element with a template ID sets that template's parameter: ```[\\\"name\\\", value, templateId]```. |\\n\\nFields of an ```exchanges``` element; everything except ```eid``` and ```currency``` is optional:\\n\\n| Field | Description |\\n| - | - |\\n| eid | Exchange ID, e.g. ```Binance```, ```Futures_OKX```. |\\n| currency | Trading pair, e.g. ```BTC_USDT```. |\\n| balance, stocks | Initial quote-currency and base-currency balances. |\\n| fee | ```[maker rate, taker rate]``` in percent. |\\n| feeMin | Minimum fee per fill; only applies to some markets. |\\n| depthDeep, depthAmount | Depth levels and the amount on each simulated level. |\\n| tradesMode | Whether trade prints are replayed in real-tick mode: ```\\\"0\\\"``` replay, ```\\\"1\\\"``` do not. |\\n| feeder | Custom data source URL, see Backtesting System → Custom Data Source. |\\n\\n\\\"Save Backtest Settings\\\" also writes some keys starting with ```bt``` (e.g. ```btSlipPoint``` slippage, ```btNetDelay``` network delay, ```btFaultTolerant``` failure probability, ```btMaxBarLen``` max K-line bars) that record the other options of the backtest form; editing them by hand is not recommended. The local backtest engines read the same block, see Backtesting System → Local Backtesting Engine.\", \"title\": \"Backtest Configuration and Saving\"}, {\"_src_hash\": \"3c03d019e2df200c8f4b2082adb784a487e7e080c60034bfcfac5b367d3fcf99\", \"desc\": \"**Programming languages**\\n\\nThe backtesting system supports strategies written in JavaScript, TypeScript, Python, Rust, [PINE](https://www.fmz.com/bbs-topic/9315), [MyLanguage](https://www.fmz.com/bbs-topic/2569), Blockly and Workflow.\\n\\n- JavaScript strategies (TypeScript is compiled to JavaScript first) are backtested in the browser, where the backtest engine runs as WebAssembly; nothing needs to be installed. JavaScript strategies can be debugged with Chrome DevTools during a backtest, see [this guide](https://www.fmz.com/digest-topic/9459).\\n- Rust strategies are compiled by the platform's servers and the result is backtested in the browser; third-party crates declared in the strategy's frontmatter are fetched at compile time, so no local toolchain is needed.\\n- Python strategies are backtested on a docker, either the platform's public servers or your own docker. Both backtesting and live trading use the Python 3 environment of the docker's system; install the third-party libraries you need yourself. The public servers only provide common libraries.\\n- Workflow strategies show each node's execution state and data flow visually during a backtest.\\n\\n**Exchanges**\\n\\nBacktests use the platform's historical data; the exchanges selectable on the backtest page are the ones that can be backtested (the MCP tool ```list_exchanges``` also shows this: exchanges with ```backtest``` set to ```true``` have history data).\\n\\n- Cryptocurrency: spot and futures of major exchanges, e.g. Binance and Futures_Binance, OKX and Futures_OKX, HTX and Futures_HTX, Bybit and Futures_Bybit, Bitget and Futures_Bitget, GateIO and Futures_GateIO, with all symbols of the exchange.\\n- Futu Securities (```Futures_Futu```): Hong Kong, US and other stock markets. Only daily data is available for backtesting; set ```currency``` to ```STOCK``` and select the stock code in the strategy with ```exchange.SetContractType()```:\\n\\n```js\\n/*backtest\\nstart: 2024-05-01 00:00:00\\nend: 2025-02-17 00:00:00\\nperiod: 1d\\nbasePeriod: 1d\\nexchanges: [{\\\"eid\\\":\\\"Futures_Futu\\\",\\\"currency\\\":\\\"STOCK\\\",\\\"fee\\\":[0.03,0.03]}]\\n*/\\n\\nfunction main() {\\n var info = exchange.SetContractType(\\\"TSLA.US\\\") // Set the stock code: Tesla\\n Log(\\\"info:\\\", info) // Contract info: InstrumentID, PriceTick, LotTick, VolumeMultiple, ...\\n Log(exchange.GetTicker()) // Daily market data at the current backtest time\\n}\\n```\", \"title\": \"Supported Languages and Exchanges\"}, {\"_src_hash\": \"0e3093bb46bbb35ad881c4eef00a675789811592d66617ae667eb70fc12cee7f\", \"desc\": \"Parameter optimization generates several parameter sets from the ranges you configure and backtests each of them. In the strategy parameter section of the \\\"Backtest\\\" tab, tick the **Optimize** option to the right of a parameter to show its settings:\\n\\n- Min: the starting value of the parameter.\\n- Max: the largest value the parameter is increased to.\\n- Step: the increment.\\n- Concurrent threads: how many backtests run at the same time during optimization. This option only applies to JavaScript, PINE and MyLanguage strategies, and not to template parameters.\\n\\nThe system generates parameter combinations from ```Min```, ```Max``` and ```Step``` and backtests every combination once. Only **number** parameters can be optimized.\", \"title\": \"Parameter Optimization\"}, {\"_src_hash\": \"44b5611b9c54b1a4fe1b532a9be8462cbe406da7520ec85937b9fe3c3a7c71fc\", \"desc\": \"When a backtest finishes, the backtest page shows the profit curve, statistics, status information, logs and account information.\\n\\n**Profit curve**\\n\\nThe profit curve consists of the values the strategy records with ```LogProfit()``` ({@fun/Log/LogProfit LogProfit}). If the strategy never calls ```LogProfit()```, there is no profit curve and the statistics below, which depend on that series, cannot be computed; only the final assets in the account information remain. The ```profit``` and ```max_drawdown``` returned by the MCP tool ```get_backtest``` also come from ```LogProfit()```.\\n\\n**Statistics**\\n\\nThe statistics are computed from the profit series ```profits``` (each element ```[timestamp, profit]```) and the initial assets ```totalAssets``` with the algorithm below:\\n\\n| Metric | Meaning |\\n| - | - |\\n| Return (totalReturns) | Last profit value ÷ initial assets. |\\n| Annualized return (annualizedReturns) | Return × one year (yearDays days) ÷ backtest duration, scaled linearly. |\\n| Max drawdown (maxDrawdown) | The largest fractional drop of assets (initial assets + profit) from their previous peak. maxDrawdownStartTime is the time of that peak, maxDrawdownTime the time of the deepest point. |\\n| Win rate (winningRate) | Share of points in the profit series that are higher than the previous point (the first point is compared with 0). It counts profit records, not individual trades. |\\n| Volatility (volatility) | The backtest period is cut into days; each day's profit ÷ initial assets is multiplied by yearDays to annualize it (days without profit records count as 0); volatility is the population standard deviation of these values. |\\n| Sharpe ratio (sharpeRatio) | (Annualized return − risk-free rate 3%) ÷ volatility; 0 when volatility is 0. |\\n\\nyearDays is the number of days per year used for annualization, passed in by the backtest page. Note that daily returns are annualized by multiplying by yearDays rather than the usual √yearDays, so this Sharpe ratio should not be compared directly with values from other platforms.\\n\\nAlgorithm source:\\n\\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```\\n\\n**Downloading data**\\n\\n- Status bar data: after the backtest finishes, click \\\"Download Table\\\" at the top right of the \\\"Status\\\" panel to download the final status bar data as a CSV file.\\n- Log data: click \\\"Download Table\\\" at the top right of the \\\"Logs\\\" panel to download the backtest logs as a CSV file.\", \"title\": \"Reading Backtest Results\"}, {\"_src_hash\": \"d687185b15fd4d8ab49db2e8c0014d9f58c63e1500fcf4cb61c8fc4775024745\", \"children\": [{\"_src_hash\": \"39bc262b1ea3c3b3f282faa79b0a13564f55ee112de90f062a36e64652632569\", \"desc\": \"The returned format must be one of the following two formats (automatically recognized by the system):\\n- Simulated-level Tick, here is a JSON data example:\\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- Live-level Tick, here is a JSON data example:\\n Tick-level backtest data (includes order book depth information, depth format is an array of ```[price, quantity]```. Can include multiple levels of depth, ```asks``` sorted in ascending order by price, ```bids``` sorted in descending order by price).\\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| Field | Description |\\n| - | - |\\n| detail | Detailed information of the requested instrument, including quote currency name, base currency name, precision, minimum order quantity, etc. |\\n| schema | Specifies the column attributes in the data array, case-sensitive. Limited to time, open, high, low, close, vol, asks, bids, trades |\\n| data | Data recorded according to the column structure set by schema |\\n\\n**Numeric precision**\\n\\nRequests always carry ```round=true```, and all values are returned as integers scaled by their precision, so that no floating-point precision is lost in transit:\\n\\n- Prices (```open```, ```high```, ```low```, ```close```, and the prices in ```asks```/```bids``` and ```trades```) = actual value × 10^```quotePrecision```.\\n- Amounts (```vol```, and the amounts in ```asks```/```bids``` and ```trades```) = actual value × 10^```basePrecision```.\\n\\nIn the examples above ```quotePrecision``` is 2, so ```9531300``` means a price of 95313.00; ```basePrecision``` is 5, so ```787``` means an amount of 0.00787. Time columns (```time``` and the time in ```trades```) are millisecond timestamps and are not scaled.\\n\\n**detail field**\\n\\n| Field | Description |\\n| - | - |\\n| eid | Exchange ID, note that spot and futures of the same exchange use different eids |\\n| symbol | Trading instrument code |\\n| alias | The corresponding symbol of the current trading instrument code on the exchange |\\n| baseCurrency | Base currency |\\n| quoteCurrency | Quote currency |\\n| marginCurrency | Margin currency |\\n| basePrecision | Base currency precision |\\n| quotePrecision | Quote currency precision |\\n| minQty | Minimum order quantity |\\n| maxQty | Maximum order quantity |\\n| minNotional | Minimum order amount |\\n| maxNotional | Maximum order amount |\\n| priceTick | Minimum price tick size |\\n| volumeTick | Minimum volume tick size |\\n| marginLevel | Futures leverage multiplier |\\n| contractType | For perpetual contracts set to: ```swap```, the backtest system will continue to send funding rate and price index requests |\\n\\nSpecial column attributes ```asks```, ```bids```, ```trades``` description:\\n\\n| Field | Description | Remarks |\\n| - | - | - |\\n| asks / bids | [[price, quantity], ...] | For example, data in the ```Live-level Tick``` data example: ```[[9531300, 10]]``` |\\n| trades | [[time, direction(0:buy,1:sell), price, quantity], ...] | For example, data in the ```Live-level Tick``` data example: ```[[1564315200000, 0, 9531300, 10]]``` |\\n\\nWhen backtesting perpetual contracts on futures exchanges, custom data sources also need to provide additional funding rate data and price index data. Only when the requested market data is returned and the detail field in the return structure contains the ```\\\"contractType\\\": \\\"swap\\\"``` key-value pair, will the backtest system continue to send funding rate requests.\\nAfter the backtest system receives the funding rate data, it will continue to send price index data requests.\\n\\nFunding rate data structure is as follows:\\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- Adjacent period interval is 8 hours\\n- Why is the funding rate -16795?\\n Like K-line data it is an integer scaled by precision: ```quotePrecision``` of this data is 8, so -16795 means a funding rate of -0.00016795. Funding rates can be negative.\\n\\nExample of funding rate data request sent by the backtest system:\\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\\nPrice index data structure is as follows:\\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\\nExample of price index data request sent by the backtest system:\\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\": \"Data Format\"}, {\"_src_hash\": \"57df19812523959049163c9015a4d18228de43938c0f4dbdcfca7030e9d0205f\", \"desc\": \"Deploy the service below on a server reachable from the public internet; the data source URL is then ```http://:9090/data``` (replace `````` with the server's public IP or domain name). The custom data source service is written in ```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 DataSource: http://xxx.xx.x.xx:9090/data\\n\\n // request: GET http://xxx.xx.x.xx:9090/data?custom=0&depth=20&detail=true&eid=OKX&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 // /* Simulation-level 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 /* Live trading-level 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\\nTest strategy, ```JavaScript``` example:\\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://: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\": \"Custom Data Source Example\"}], \"desc\": \"The FMZ Quant Trading Platform's backtesting system supports custom data sources. During a backtest the platform's data server requests the custom URL with the ```GET``` method, so the URL must be reachable from the public internet. The request carries these parameters:\\n\\n| Parameter | Meaning | Description |\\n| - | - | - |\\n| symbol | Symbol name | Spot market data example: ```BTC_USDT```, Futures market data example: ```BTC_USDT.swap```, Perpetual futures funding rate data example: ```BTC_USDT.funding```, Perpetual futures price index data example: ```BTC_USDT.index``` |\\n| eid | Exchange | For example: OKX, Futures_OKX |\\n| round | Data precision | Always ```round=true```: prices and amounts are returned as integers scaled by their precision, which is given by ```quotePrecision``` and ```basePrecision``` in the returned ```detail```; see Backtesting System → Custom Data Source → Data Format. |\\n| period | K-line data period (milliseconds) | For example: ```60000``` represents a 1-minute period |\\n| depth | Order book depth levels | 1-20 |\\n| trades | Whether trade-by-trade data is required | Yes (1) / No (0) |\\n| from | Start time | Unix timestamp in seconds |\\n| to | End time | Unix timestamp in seconds |\\n| detail | Request detailed information of the symbol | When true, indicates that it needs to be provided by the custom data source. The request sent by the FMZ Quant Trading Platform backtesting system to the custom data source is fixed as: ```detail=true``` |\\n| custom | -- | This parameter can be ignored |\\n\\nWhen the data source of spot exchange or futures exchange objects is set to custom data source (feeder), examples of requests sent by the backtesting system to the custom data source service:\\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\": \"Custom Data Source\"}, {\"_src_hash\": \"32ef2e1e251fc30369102acedc553ee1e18960e8cff8f03021f5b06455cb7ea6\", \"desc\": \"The platform publishes local backtest engines for JavaScript and Python. They use the same engine core and the same history data (downloaded from the platform's data server) as cloud backtests, and backtest JavaScript and Python strategies quickly on your own computer:\\n\\n- [Python backtest engine](https://github.com/fmzquant/backtest_python)\\n- [JavaScript backtest engine](https://github.com/fmzquant/backtest_javascript)\\n\\n**Python**\\n\\nInstall (requires Python 3 and pip):\\n\\n```bash\\npip install https://github.com/fmzquant/backtest_python/archive/master.zip\\npip install pandas matplotlib # only needed for Join(True) and Show()\\n```\\n\\nOn first use the package downloads the engine file for your system from the data server; afterwards only history data is downloaded. A strategy file is an ordinary FMZ strategy plus the ```backtest``` configuration comment at the top (format: see Backtesting System → Backtest Configuration and Saving) and a few lines that drive the engine:\\n\\n```python\\n'''backtest\\nstart: 2026-09-01 00:00:00\\nend: 2026-09-15 00:00:00\\nperiod: 1h\\nbasePeriod: 15m\\nexchanges: [{\\\"eid\\\":\\\"Binance\\\",\\\"currency\\\":\\\"BTC_USDT\\\",\\\"balance\\\":10000,\\\"stocks\\\":0}]\\n'''\\nimport json\\nfrom fmz import *\\ntask = VCtx(__doc__) # Initialize the engine from the configuration above; exchange, Log, TA etc. become globals\\n\\n# The strategy under test, copied from the platform as is\\ndef main():\\n Log(exchange.GetAccount())\\n while True:\\n r = exchange.GetRecords()\\n LogStatus(_D(), r[-1][\\\"Close\\\"])\\n Sleep(60 * 60 * 1000)\\n\\ntry:\\n main()\\nexcept EOFError: # The engine raises EOFError when the virtual clock reaches the end time\\n pass\\nresult = json.loads(task.Join(False)) # Raw backtest result (JSON)\\nprint(result[\\\"LogsCount\\\"], result[\\\"Elapsed\\\"] / 1e6)\\n# task.Show() # Or show the profit chart (requires matplotlib)\\n```\\n\\nRun it with ```python strategy.py```. ```task.Join(False)``` returns the raw result as JSON, ```task.Join(True)``` returns the profit data as a pandas DataFrame, and ```task.Show()``` plots the profit curve.\\n\\n**JavaScript**\\n\\n```bash\\nnpm install git+https://github.com/fmzquant/backtest_javascript.git\\n```\\n\\n```js\\nvar fmz = require(\\\"fmz\\\")\\nvar task = fmz.VCtx({\\n start: \\\"2026-09-01 00:00:00\\\", end: \\\"2026-09-15 00:00:00\\\", period: \\\"1h\\\", basePeriod: \\\"15m\\\",\\n exchanges: [{eid: \\\"Binance\\\", currency: \\\"BTC_USDT\\\", balance: 10000, stocks: 0}]\\n})\\n// From here on exchange, Log, TA etc. are globals; paste the strategy code and call main()\\n\\nfunction main() {\\n Log(exchange.GetAccount())\\n while (true) {\\n var r = exchange.GetRecords()\\n LogStatus(_D(), r[r.length - 1].Close)\\n Sleep(60 * 60 * 1000)\\n }\\n}\\n\\ntry {\\n main()\\n} catch (e) {\\n // The engine throws \\\"EOF\\\" when the virtual clock reaches the end time\\n}\\nvar result = JSON.parse(task.Join()) // Same result as Join(False) of the Python engine\\nconsole.log(result.LogsCount)\\n```\\n\\n**Differences from cloud backtests**\\n\\n- Only JavaScript and Python strategies are supported and templates are not loaded automatically: paste the code of referenced templates into the file. PINE and MyLanguage strategies depend on trading libraries and therefore cannot be backtested locally.\\n- Strategy parameters are not injected; define them as global variables in the code.\\n- ```start``` and ```end``` in the comment are parsed in the machine's time zone; network delay is fixed at 200 ms; slippage and real-tick mode are not supported.\\n- As in the cloud, profit, drawdown and the profit curve exist only if the strategy calls ```LogProfit()```.\\n\\n**Backtesting with an AI assistant**\\n\\nAn AI assistant can run backtests for you: it starts a cloud backtest with the MCP tool ```run_backtest``` and reads profit, drawdown, error logs and other results with ```get_backtest```, see Integrations → AI Integration. It can also install the local engine on your machine for a fast edit-and-run loop, then confirm once with a cloud backtest.\", \"title\": \"Local Backtesting Engine\"}, {\"_src_hash\": \"8c63d53c56f0b8ae7094827097e1fff46d06753e8dedbf0f820cd042f9cedc61\", \"desc\": \"- Shortcut for switching between strategy editor and backtest page\\n Use ```Ctrl + ,``` to switch between backtest page and strategy editor page. Hold ```Ctrl``` and press ```,```.\\n- Shortcut for saving strategy\\n Use ```Ctrl + s``` to save strategy.\\n- Shortcut for starting backtest\\n Use ```Ctrl + b``` to start backtest.\", \"title\": \"Backtest Page Shortcuts\"}], \"desc\": \"Test strategies on historical data: the backtesting system drives the strategy code with past market data, simulates order matching and accounts, and reports profit, drawdown and other results. A backtest only shows how a strategy behaved on past data; it does not predict future returns.\", \"title\": \"Backtesting System\"}, {\"_src_hash\": \"c5d1b86d6acc7222d2adc53864bc5e0170c4cdef250a65baf3c461a6d412fe7b\", \"children\": [{\"_src_hash\": \"f3658676af954762bae69e8a233e4b305fa884ff089161a5f98cc875e7429588\", \"desc\": \"JavaScript strategies can use the ```threading``` object to create threads that really run in parallel, and exchange data between them with messages, shared dictionaries, locks and similar objects. This page explains when to use threads and how to organize thread code; for the parameters and return values of each function see {@fun/Threads Threads} in the syntax manual.\\n\\n## Pick the right tool first\\n\\n| Need | Recommended | Languages |\\n| - | - | - |\\n| Send several API requests at once (for example tickers from several exchanges) and wait for the results | {@fun/Threads/exchange.Go exchange.Go}, with {@fun/Threads/EventLoop EventLoop} to wait for completion events | All languages |\\n| Long-running background work: separate market data collection, risk checks, heavy computation | {@fun/Threads/threading/Thread threading.Thread} | JavaScript only |\\n| Serve HTTP, WebSocket or TCP from inside the strategy | {@fun/Threads/threading/Serve threading.Serve} | JavaScript only |\\n\\nWhen you only need a few concurrent requests, ```exchange.Go()``` is simpler and involves no data passing between threads. The ```threading``` object on this page is for JavaScript strategies only; Python and Rust strategies use ```exchange.Go()```.\\n\\nThese functions can be called in the backtesting system, but the threads actually run one after another there; this only keeps the code runnable in backtests.\\n\\n## Threads run in isolated environments\\n\\nThe function passed to ```threading.Thread()``` runs in a separate JavaScript environment. This is the most important thing to keep in mind when writing thread code:\\n\\n- A thread function **cannot reference outer variables or closures**, nor call other functions defined in the strategy. Pass the data it needs as arguments: ```threading.Thread(func, arg1, arg2, ...)```.\\n- Plain objects and arrays passed as arguments are **deep-copied**: changing them inside the thread does not affect other threads. When several threads need to see the same data, use a dictionary created by ```threading.Dict()```.\\n- Functions can be passed as arguments too; ```threading.Thread()``` also accepts function source strings, which can be used to load external libraries in the thread.\\n- Platform API functions such as ```exchange.GetTicker()``` and ```Log()``` can be called directly in a thread.\\n- The return value of the thread function is retrieved with ```join()```: ```t.join().ret```.\\n\\n## Exchanging data between threads\\n\\n| Method | Usage | Notes |\\n| - | - | - |\\n| Messages | ```t.postMessage(msg)``` sends to thread ```t```; inside a thread, ```threading.currentThread().peekMessage(timeout)``` reads the messages it received; a child thread sends back to the main thread with ```threading.mainThread().postMessage(msg)``` | Each thread has its own inbox, read in order. ```peekMessage(-1)``` does not block and returns an empty value when there is no message |\\n| Shared dictionary | ```var d = threading.Dict()```, pass it to threads as an argument, then each thread uses ```d.get(key)``` and ```d.set(key, value)``` | Good for holding the \\\"latest state\\\", such as the latest price or a running flag |\\n| Thread data | ```t.setData(key, value)```, ```t.getData(key)``` | Key-value pairs attached to a thread object; invalid after the thread ends (```join()```, ```terminate()```) |\\n| Synchronization objects | ```threading.Lock()```, ```threading.Event()```, ```threading.Condition()``` | Passed to threads as arguments for mutual exclusion and waiting for notifications |\\n\\nA message received by a thread also raises an event, so the thread object's {@fun/Threads/Thread/eventLoop eventLoop} can wait for messages and other events in one place.\\n\\n## Thread lifecycle\\n\\n- ```t.join()``` waits for the thread to end and returns its result, with an optional timeout; ```t.terminate()``` ends a thread forcibly.\\n- When a thread has ended and is no longer referenced, its resources are reclaimed automatically; there is no need to call ```join()``` just to free them. An error is raised when more than 2000 threads are kept referenced and cannot be reclaimed.\\n- ```threading.pending()``` returns the number of running threads (main thread included).\\n- All threads end when the live trading stops. Waits in ```peekMessage()```, ```join()```, locks and events are interrupted by the stop.\\n\\n## Serving from inside the strategy\\n\\n```threading.Serve(address, handler, ...args)``` starts an HTTP (WebSocket included) or TCP service inside the strategy process. Each request or connection calls the handler in its own thread. It returns a {@fun/Threads/Server Server} object (```addr()``` gives the actual listening address, ```close()``` shuts it down). Like thread functions, handlers run in isolated environments and receive what they need as arguments; a ```threading.Dict()``` is commonly used to share state with the main thread. For the address syntax and the methods of the ```ctx``` object see {@fun/Threads/threading/Serve Serve}.\\n\\nThe old global function ```__Serve()``` still works but only returns the listening address string; use ```threading.Serve()``` in new code.\\n\\n## Examples\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var symbols = [\\\"BTC_USDT\\\", \\\"ETH_USDT\\\", \\\"SOL_USDT\\\"]\\n var threads = []\\n for (var i = 0; i < symbols.length; i++) {\\n threads.push(threading.Thread(function(symbol, period) {\\n // runs in the thread: only arguments and platform APIs are available\\n var records = exchange.GetRecords(symbol, period)\\n if (!records || records.length < 20) {\\n return null\\n }\\n var ma = TA.MA(records, 20)\\n return {symbol: symbol, close: records[records.length - 1].Close, ma20: ma[ma.length - 1]}\\n }, symbols[i], PERIOD_H1))\\n }\\n for (var i = 0; i < threads.length; i++) {\\n var r = threads[i].join().ret\\n if (r) {\\n Log(r.symbol, \\\"close:\\\", r.close, \\\"MA20:\\\", r.ma20)\\n }\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"### Several threads compute in parallel, the main thread collects the results\\n\\nEach thread fetches the K-lines of one symbol and computes a moving average; the result goes back to the main thread as the return value. Note that the symbol is passed as an argument and the thread function references no outer variables.\"}, {\"examples\": [{\"code\": \"function main() {\\n var shared = threading.Dict()\\n var worker = threading.Thread(function(dict, symbol) {\\n while (true) {\\n // read commands from the main thread; -1 means do not block\\n var cmd = threading.currentThread().peekMessage(-1)\\n if (cmd == \\\"stop\\\") {\\n break\\n }\\n var ticker = exchange.GetTicker(symbol)\\n if (ticker) {\\n dict.set(\\\"last\\\", ticker.Last)\\n dict.set(\\\"time\\\", ticker.Time)\\n } else {\\n threading.mainThread().postMessage(\\\"failed to get ticker: \\\" + GetLastError())\\n }\\n Sleep(1000)\\n }\\n return \\\"worker exited\\\"\\n }, shared, \\\"BTC_USDT\\\")\\n\\n for (var i = 0; i < 10; i++) {\\n // wait at most 1 second for a message from the background thread\\n var msg = threading.currentThread().peekMessage(1000)\\n if (msg) {\\n Log(\\\"background thread reports:\\\", msg)\\n }\\n LogStatus(\\\"last:\\\", shared.get(\\\"last\\\"), \\\"time:\\\", _D(shared.get(\\\"time\\\")))\\n }\\n worker.postMessage(\\\"stop\\\")\\n Log(worker.join().ret)\\n}\", \"lang\": \"javascript\"}], \"value\": \"### A background thread collects prices, the main thread reads them and sends commands\\n\\nThe background thread writes the latest price into a shared dictionary and reports errors to the main thread through messages; the main thread tells it to exit with a message.\"}, {\"examples\": [{\"code\": \"function main() {\\n var state = threading.Dict()\\n var server = threading.Serve(\\\"http://127.0.0.1:8088\\\", function(ctx, st) {\\n if (ctx.path() == \\\"/status\\\") {\\n ctx.setHeader(\\\"Content-Type\\\", \\\"application/json\\\")\\n ctx.write(JSON.stringify({last: st.get(\\\"last\\\"), updated: st.get(\\\"updated\\\")}))\\n } else {\\n ctx.setStatus(404)\\n }\\n }, state)\\n Log(\\\"listening on:\\\", server.addr())\\n\\n while (true) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (ticker) {\\n state.set(\\\"last\\\", ticker.Last)\\n state.set(\\\"updated\\\", _D())\\n }\\n Sleep(3000)\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"### A status endpoint with threading.Serve\\n\\nThe main thread writes the state into a shared dictionary; the HTTP handler gets the same dictionary as an argument and returns it as JSON.\"}], \"seeAlso\": [\"{@fun/Threads Threads}, {@fun/Threads/threading/Thread Thread}, {@fun/Threads/threading/Dict Dict}, {@fun/Threads/threading/Serve Serve}, {@fun/Threads/exchange.Go exchange.Go}, {@fun/Threads/EventLoop EventLoop}\"], \"title\": \"JavaScript Multi-threading\"}, {\"_src_hash\": \"eb00dc29027044de2a9048beee3779610263afc99035b1451c6573f9c24c703f\", \"desc\": \"Every live trading has a channel whose ID is the live trading ID. A live trading publishes data on its own channel with ```SetChannelData()```, and other live tradings read it with ```GetChannelData(liveTradingId)```. The data is relayed by the platform server, so it can travel across dockers and servers.\\n\\nA channel holds the **latest state**, not a message queue: each publish overwrites the previous data, and a subscriber always reads the current latest copy. If history is needed, the subscriber keeps it itself.\\n\\nTypical uses:\\n\\n- **Master/follower**: a master strategy analyzes the market and publishes signals; several follower strategies read them and trade on their own accounts.\\n- **Status monitoring**: each strategy publishes its running status; a monitoring live trading collects them for display or alerts.\\n- **Data sharing**: one live trading computes indicators and publishes the results; others use them directly instead of computing them again.\\n\\n## Key points\\n\\n- **The first read subscribes**: the first ```GetChannelData()``` call for a channel subscribes to it and returns an empty value (```null```/```None```). From then on the server pushes the channel's updates to this live trading, and later calls return the latest data. A subscriber should start reading at startup and handle empty values.\\n- **Subscription limit**: a live trading can subscribe to at most 10 different channels (UUID channels below included). Beyond that, the call returns an empty value and logs the error ```channel subscriber exceed limit```.\\n- **Data format**: in JavaScript and Python, ```SetChannelData()``` accepts any JSON-serializable data and the subscriber reads the parsed object. Unchanged data is not sent again. For the data size limit see {@fun/Storage/SetChannelData SetChannelData}.\\n- **Rust**: ```SetChannelData(string)``` only accepts a string, so build the JSON text yourself; ```GetChannelData()``` takes no channel argument and cannot choose the channel to read, so it cannot subscribe to other live tradings or UUID channels. Rust strategies are suited to publishing; write subscribers in JavaScript or Python.\\n- **Cross-platform push**: an external system (a TradingView alert, your own program, etc.) can push data to a given live trading on a channel identified by a 32-character UUID through the extended API's ```method=pub```; the live trading reads it with ```GetChannelData(UUID)```. See {@fun/Storage/SetChannelData SetChannelData} and {@fun/Storage/GetChannelData GetChannelData} for details.\\n- **Live trading feature**: channels are meant for communication between live tradings; do not rely on them in backtests. The current live trading ID is available from ```_G()```.\\n- Do not pass keys or other sensitive information through channels.\\n\\n## Basic usage\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var robotId = _G() // current live trading ID, which is also this live trading's channel ID\\n var updateId = 0\\n\\n while (true) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (ticker) {\\n // publish the latest state, overwriting the previous data\\n SetChannelData({\\n robotId: robotId,\\n updateId: ++updateId,\\n timestamp: Date.now(),\\n symbol: \\\"BTC_USDT\\\",\\n lastPrice: ticker.Last\\n })\\n LogStatus(\\\"channel\\\", robotId, \\\"publish #\\\", updateId, \\\"last price:\\\", ticker.Last)\\n }\\n Sleep(60000) // publish once a minute\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import time\\n\\ndef main():\\n robotId = _G() # current live trading ID, which is also this live trading's channel ID\\n updateId = 0\\n\\n while True:\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if ticker:\\n updateId += 1\\n # publish the latest state, overwriting the previous data\\n SetChannelData({\\n \\\"robotId\\\": robotId,\\n \\\"updateId\\\": updateId,\\n \\\"timestamp\\\": int(time.time() * 1000),\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"lastPrice\\\": ticker[\\\"Last\\\"]\\n })\\n LogStatus(\\\"channel\\\", robotId, \\\"publish #\\\", updateId, \\\"last price:\\\", ticker[\\\"Last\\\"])\\n Sleep(60000) # publish once a minute\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n let robotId = _G!(); // current live trading ID, which is also this live trading's channel ID\\n let mut updateId = 0;\\n\\n loop {\\n if let Ok(ticker) = exchange.GetTicker(\\\"BTC_USDT\\\") {\\n updateId += 1;\\n // Rust's SetChannelData only accepts a string; build the JSON text yourself\\n let state = format!(\\n r#\\\"{{\\\"robotId\\\": \\\"{}\\\", \\\"updateId\\\": {}, \\\"timestamp\\\": {}, \\\"symbol\\\": \\\"BTC_USDT\\\", \\\"lastPrice\\\": {}}}\\\"#,\\n robotId, updateId, Unix() * 1000, ticker.Last\\n );\\n SetChannelData(&state);\\n LogStatus!(\\\"channel\\\", robotId, \\\"publish #\\\", updateId, \\\"last price:\\\", ticker.Last);\\n }\\n Sleep(60000); // publish once a minute\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"### Publisher: publish a market summary\"}, {\"examples\": [{\"code\": \"function main() {\\n // live trading IDs to subscribe to (change as needed)\\n var channels = [\\\"632799\\\", \\\"632800\\\"]\\n\\n while (true) {\\n var msg = \\\"\\\"\\n for (var i = 0; i < channels.length; i++) {\\n // the first call subscribes and returns null; later calls return the latest data\\n var state = GetChannelData(channels[i])\\n if (state) {\\n msg += \\\"channel \\\" + channels[i] + \\\": #\\\" + state.updateId + \\\" \\\" + _D(state.timestamp) + \\\" last \\\" + state.lastPrice + \\\"\\\\n\\\"\\n } else {\\n msg += \\\"channel \\\" + channels[i] + \\\": waiting for data\\\\n\\\"\\n }\\n }\\n LogStatus(msg)\\n Sleep(5000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # live trading IDs to subscribe to (change as needed)\\n channels = [\\\"632799\\\", \\\"632800\\\"]\\n\\n while True:\\n msg = \\\"\\\"\\n for ch in channels:\\n # the first call subscribes and returns None; later calls return the latest data\\n state = GetChannelData(ch)\\n if state:\\n msg += \\\"channel {}: #{} {} last {}\\\\n\\\".format(ch, state[\\\"updateId\\\"], _D(state[\\\"timestamp\\\"]), state[\\\"lastPrice\\\"])\\n else:\\n msg += \\\"channel {}: waiting for data\\\\n\\\".format(ch)\\n LogStatus(msg)\\n Sleep(5000)\", \"lang\": \"python\"}, {\"code\": \"// Rust's GetChannelData() takes no channel argument and cannot subscribe to other live tradings' channels\", \"lang\": \"rust\"}], \"value\": \"### Subscriber: read two channels\"}, {\"examples\": [{\"code\": \"function main() {\\n while (true) {\\n var records = exchange.GetRecords(\\\"BTC_USDT\\\")\\n if (records && records.length >= 21) {\\n var ma5 = TA.MA(records, 5)\\n var ma20 = TA.MA(records, 20)\\n var n = records.length\\n var signal = \\\"HOLD\\\"\\n if (ma5[n - 1] > ma20[n - 1] && ma5[n - 2] <= ma20[n - 2]) {\\n signal = \\\"BUY\\\"\\n } else if (ma5[n - 1] < ma20[n - 1] && ma5[n - 2] >= ma20[n - 2]) {\\n signal = \\\"SELL\\\"\\n }\\n SetChannelData({\\n timestamp: Date.now(),\\n symbol: \\\"BTC_USDT\\\",\\n signal: signal,\\n price: records[n - 1].Close\\n })\\n LogStatus(\\\"current signal:\\\", signal, \\\"price:\\\", records[n - 1].Close)\\n }\\n Sleep(60000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import time\\n\\ndef main():\\n while True:\\n records = exchange.GetRecords(\\\"BTC_USDT\\\")\\n if records and len(records) >= 21:\\n ma5 = TA.MA(records, 5)\\n ma20 = TA.MA(records, 20)\\n signal = \\\"HOLD\\\"\\n if ma5[-1] > ma20[-1] and ma5[-2] <= ma20[-2]:\\n signal = \\\"BUY\\\"\\n elif ma5[-1] < ma20[-1] and ma5[-2] >= ma20[-2]:\\n signal = \\\"SELL\\\"\\n SetChannelData({\\n \\\"timestamp\\\": int(time.time() * 1000),\\n \\\"symbol\\\": \\\"BTC_USDT\\\",\\n \\\"signal\\\": signal,\\n \\\"price\\\": records[-1][\\\"Close\\\"]\\n })\\n LogStatus(\\\"current signal:\\\", signal, \\\"price:\\\", records[-1][\\\"Close\\\"])\\n Sleep(60000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n loop {\\n if let Ok(records) = exchange.GetRecords(\\\"BTC_USDT\\\", None, None) {\\n let n = records.len();\\n if n >= 21 {\\n let ma5 = TA.MA(&records, 5);\\n let ma20 = TA.MA(&records, 20);\\n let mut signal = \\\"HOLD\\\";\\n if ma5[n - 1] > ma20[n - 1] && ma5[n - 2] <= ma20[n - 2] {\\n signal = \\\"BUY\\\";\\n } else if ma5[n - 1] < ma20[n - 1] && ma5[n - 2] >= ma20[n - 2] {\\n signal = \\\"SELL\\\";\\n }\\n let price = records[n - 1].Close;\\n // Rust's SetChannelData only accepts a string; build the JSON text yourself\\n let data = format!(\\n r#\\\"{{\\\"timestamp\\\": {}, \\\"symbol\\\": \\\"BTC_USDT\\\", \\\"signal\\\": \\\"{}\\\", \\\"price\\\": {}}}\\\"#,\\n Unix() * 1000, signal, price\\n );\\n SetChannelData(&data);\\n LogStatus!(\\\"current signal:\\\", signal, \\\"price:\\\", price);\\n }\\n }\\n Sleep(60000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"## Scenario: master/follower strategies\\n\\nThe master strategy computes a moving-average crossover signal and publishes it; the follower reads the signal and places an order when it changes.\\n\\n**Master strategy (publishes signals)**\"}, {\"examples\": [{\"code\": \"function main() {\\n var masterId = \\\"632799\\\" // live trading ID of the master strategy\\n var lastSignal = null\\n\\n while (true) {\\n var data = GetChannelData(masterId)\\n if (!data) {\\n LogStatus(\\\"waiting for the master strategy's signal...\\\")\\n } else {\\n if (data.signal !== lastSignal) {\\n Log(\\\"new signal:\\\", data.signal, \\\"signal price:\\\", data.price)\\n var ticker = exchange.GetTicker(data.symbol)\\n if (ticker && data.signal === \\\"BUY\\\") {\\n exchange.CreateOrder(data.symbol, \\\"buy\\\", ticker.Last, 0.01)\\n } else if (ticker && data.signal === \\\"SELL\\\") {\\n exchange.CreateOrder(data.symbol, \\\"sell\\\", ticker.Last, 0.01)\\n }\\n lastSignal = data.signal\\n }\\n LogStatus(\\\"current signal:\\\", data.signal, \\\"signal time:\\\", _D(data.timestamp))\\n }\\n Sleep(5000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n masterId = \\\"632799\\\" # live trading ID of the master strategy\\n lastSignal = None\\n\\n while True:\\n data = GetChannelData(masterId)\\n if not data:\\n LogStatus(\\\"waiting for the master strategy's signal...\\\")\\n else:\\n if data[\\\"signal\\\"] != lastSignal:\\n Log(\\\"new signal:\\\", data[\\\"signal\\\"], \\\"signal price:\\\", data[\\\"price\\\"])\\n ticker = exchange.GetTicker(data[\\\"symbol\\\"])\\n if ticker and data[\\\"signal\\\"] == \\\"BUY\\\":\\n exchange.CreateOrder(data[\\\"symbol\\\"], \\\"buy\\\", ticker[\\\"Last\\\"], 0.01)\\n elif ticker and data[\\\"signal\\\"] == \\\"SELL\\\":\\n exchange.CreateOrder(data[\\\"symbol\\\"], \\\"sell\\\", ticker[\\\"Last\\\"], 0.01)\\n lastSignal = data[\\\"signal\\\"]\\n LogStatus(\\\"current signal:\\\", data[\\\"signal\\\"], \\\"signal time:\\\", _D(data[\\\"timestamp\\\"]))\\n Sleep(5000)\", \"lang\": \"python\"}, {\"code\": \"// Rust's GetChannelData() takes no channel argument and cannot read the master strategy's channel\", \"lang\": \"rust\"}], \"value\": \"**Follower strategy (reads and executes signals)**\"}, {\"examples\": [{\"code\": \"function main() {\\n var monitorList = [\\\"632799\\\", \\\"632800\\\", \\\"632801\\\"] // at most 10\\n\\n while (true) {\\n var table = {type: \\\"table\\\", title: \\\"Strategy status\\\", cols: [\\\"Live trading ID\\\", \\\"Status\\\", \\\"Last update\\\", \\\"Symbol\\\", \\\"Last price\\\"], rows: []}\\n for (var i = 0; i < monitorList.length; i++) {\\n var data = GetChannelData(monitorList[i])\\n if (data) {\\n var status = Date.now() - data.timestamp < 120000 ? \\\"running\\\" : \\\"abnormal\\\"\\n table.rows.push([monitorList[i], status, _D(data.timestamp), data.symbol || \\\"-\\\", data.lastPrice || \\\"-\\\"])\\n } else {\\n table.rows.push([monitorList[i], \\\"waiting for data\\\", \\\"-\\\", \\\"-\\\", \\\"-\\\"])\\n }\\n }\\n LogStatus(\\\"`\\\" + JSON.stringify(table) + \\\"`\\\")\\n Sleep(10000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"import json\\nimport time\\n\\ndef main():\\n monitorList = [\\\"632799\\\", \\\"632800\\\", \\\"632801\\\"] # at most 10\\n\\n while True:\\n table = {\\\"type\\\": \\\"table\\\", \\\"title\\\": \\\"Strategy status\\\", \\\"cols\\\": [\\\"Live trading ID\\\", \\\"Status\\\", \\\"Last update\\\", \\\"Symbol\\\", \\\"Last price\\\"], \\\"rows\\\": []}\\n for robotId in monitorList:\\n data = GetChannelData(robotId)\\n if data:\\n status = \\\"running\\\" if time.time() * 1000 - data[\\\"timestamp\\\"] < 120000 else \\\"abnormal\\\"\\n table[\\\"rows\\\"].append([robotId, status, _D(data[\\\"timestamp\\\"]), data.get(\\\"symbol\\\", \\\"-\\\"), data.get(\\\"lastPrice\\\", \\\"-\\\")])\\n else:\\n table[\\\"rows\\\"].append([robotId, \\\"waiting for data\\\", \\\"-\\\", \\\"-\\\", \\\"-\\\"])\\n LogStatus(\\\"`\\\" + json.dumps(table) + \\\"`\\\")\\n Sleep(10000)\", \"lang\": \"python\"}, {\"code\": \"// Rust's GetChannelData() takes no channel argument and cannot read other live tradings' channels\", \"lang\": \"rust\"}], \"value\": \"## Scenario: monitoring several strategies\\n\\nEach strategy publishes its status as the publisher above does; the monitoring live trading reads every channel, shows them in a table and marks those without an update for over 2 minutes as abnormal.\"}], \"seeAlso\": [\"{@fun/Storage/SetChannelData SetChannelData}, {@fun/Storage/GetChannelData GetChannelData}, {@fun/Storage/_G _G}\"], \"title\": \"Communication Between Live Trading Strategies\"}, {\"_src_hash\": \"529b4cddaf187986d3a6959e3e784d0a8433e36d6d9d0d8f7fdd9150c6c58999\", \"desc\": \"Exchanges limit how often their API may be called. Going over the limit gets requests rejected at best and the account temporarily banned at worst. With ```exchange.IO(\\\"rate\\\", ...)``` or ```exchange.IO(\\\"quota\\\", ...)``` you can cap the call frequency of standard functions locally on the docker: a call that exceeds the limit is never sent.\\n\\n```js\\nexchange.IO(\\\"rate\\\" | \\\"quota\\\", name, count, window[, \\\"delay\\\"])\\n```\\n\\n## Two modes\\n\\n- **rate (token bucket)**: the bucket capacity defaults to ```count```. It starts full and refills at a steady \\\"count per window\\\"; each call takes one token. Short bursts are allowed, while the long-run average never exceeds \\\"count per window\\\". Writing ```count``` as ```\\\"10/5\\\"``` means 10 refills per window with a bucket capacity of 5, which limits bursts.\\n- **quota (fixed window)**: at most ```count``` calls per window; the counter resets when the next window starts. Windows are aligned to the Unix epoch: ```\\\"1s\\\"``` to whole seconds, ```\\\"1m\\\"``` to whole minutes, ```\\\"1h\\\"``` to whole hours, ```\\\"1d\\\"``` to UTC midnight (08:00 Beijing time). For example, counting that starts at 12:00:00.900 is already in a new window at 12:00:01.000.\\n\\nUse ```quota``` with a window matching the exchange's counting period when you must guarantee \\\"no more than N calls in any of the exchange's periods\\\"; use ```rate``` when you only need to control the average frequency.\\n\\n## Parameters\\n\\n| Parameter | Description |\\n| - | - |\\n| name | The function to limit, see the table below. Several names separated by commas (such as ```\\\"GetTicker,GetDepth\\\"```) share one rule and their calls are counted together. ```\\\"*\\\"``` is a fallback rule that applies only to functions without a rule of their own. |\\n| count | Calls allowed per window, must be greater than 0; in ```rate``` mode it can be written as ```\\\"count/burst\\\"```. Passing ```0``` or a negative number deletes the rule for that name. |\\n| window | A duration in the syntax of Go's ```time.ParseDuration```: units ```ns```, ```us``` (or ```µs```), ```ms```, ```s```, ```m```, ```h```, decimals allowed (```\\\"1.5s\\\"```), units can be combined (```\\\"1h30m\\\"```); ```\\\"Nd\\\"``` means N days (decimals allowed, such as ```\\\"0.5d\\\"```, not combinable with other units). ```\\\"@HHMM\\\"``` or ```\\\"@HHMMSS\\\"``` (such as ```\\\"@0800\\\"```) counts per day and resets at that time of day (Beijing time); it works with both ```rate``` and ```quota```. |\\n| action | When omitted, a call over the limit fails immediately; with ```\\\"delay\\\"``` the call blocks until a call is available and is then sent. Stopping the live trading interrupts the wait. |\\n\\n## Function names that can be limited\\n\\n| Category | Names |\\n| - | - |\\n| Market data | ```GetTicker```, ```GetTickers```, ```GetDepth```, ```GetTrades```, ```GetRecords```, ```GetMarkets```, ```GetFundings``` |\\n| Account | ```GetAccount```, ```GetAssets```, ```GetPositions```, ```SetMarginLevel``` |\\n| Trading | ```CreateOrder``` (```Buy``` and ```Sell``` count here too), ```CancelOrder```, ```ModifyOrder``` |\\n| Order queries | ```GetOrder```, ```GetOrders```, ```GetHistoryOrders``` |\\n| Conditional orders | ```CreateConditionOrder```, ```ModifyConditionOrder```, ```CancelConditionOrder```, ```GetConditionOrder```, ```GetConditionOrders```, ```GetHistoryConditionOrders``` |\\n| Custom requests | ```IO/api```: limits only ```exchange.IO(\\\"api\\\", ...)```, other ```exchange.IO()``` commands are unaffected |\\n\\n- ```GetAccount``` and ```GetAssets``` are the same underlying request; a rule under either name applies to both functions.\\n- Calls made concurrently through ```exchange.Go()``` are counted under the function actually called.\\n\\n## Scope of rules\\n\\n- Rules are set per exchange object: a rule on ```exchanges[0]``` does not affect ```exchanges[1]```.\\n- Rules last for the current run only. Set them again after the live trading restarts, usually at the beginning of ```main()```.\\n- Setting the same name again replaces its rule; an empty name (```exchange.IO(\\\"rate\\\", \\\"\\\")```) clears all rules of that exchange object.\\n- Each call is counted under one rule only: a function with its own rule is no longer counted under ```\\\"*\\\"```, so ```\\\"*\\\"``` cannot be used as a \\\"total quota for all calls\\\" stacked on top of specific rules.\\n\\n## When the limit is exceeded\\n\\nWith the default action, a call over the limit sends no request and is treated as a failed call (JavaScript returns ```null```, Python returns ```None```, Rust returns ```Err```). The error message looks like:\\n\\n```\\nrate limit exceeded: GetTicker 10/1s\\nquota limit exceeded: GetTicker 10/1m\\nquota limit exceeded: GetRecords 2000/day (resets at 0800)\\n```\\n\\nWith the ```\\\"delay\\\"``` action the call blocks until a call is available, so the time recorded in the log is the time after the wait. With a rule that resets daily, ```\\\"delay\\\"``` may wait until the next day; use it with care.\\n\\n## Examples\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n // GetTicker at most 5 calls per second on average (token bucket, capacity 5)\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\")\\n\\n for (var i = 0; i < 10; i++) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if (ticker) {\\n Log(\\\"call\\\", i + 1, \\\"succeeded:\\\", ticker.Last)\\n } else {\\n // a call over the limit sends no request and returns null\\n Log(\\\"call\\\", i + 1, \\\"rate limited:\\\", GetLastError())\\n }\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # GetTicker at most 5 calls per second on average (token bucket, capacity 5)\\n exchange.IO(\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\")\\n\\n for i in range(10):\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n if ticker:\\n Log(\\\"call\\\", i + 1, \\\"succeeded:\\\", ticker[\\\"Last\\\"])\\n else:\\n # a call over the limit sends no request and returns None\\n Log(\\\"call\\\", i + 1, \\\"rate limited:\\\", GetLastError())\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n // GetTicker at most 5 calls per second on average (token bucket, capacity 5)\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker\\\", 5, \\\"1s\\\"));\\n\\n for i in 0..10 {\\n match exchange.GetTicker(\\\"BTC_USDT\\\") {\\n Ok(ticker) => Log!(\\\"call\\\", i + 1, \\\"succeeded:\\\", ticker.Last),\\n // a call over the limit sends no request and returns Err\\n Err(e) => Log!(\\\"call\\\", i + 1, \\\"rate limited:\\\", e),\\n }\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"### Default action: calls over the limit fail\"}, {\"examples\": [{\"code\": \"function main() {\\n // market data: GetTicker and GetDepth together at most 20 calls per second on average\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\")\\n // trading: placing orders (Buy/Sell included) and cancelling together 5 per second, wait when over the limit\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\")\\n // fallback: other functions (such as GetAccount, GetPositions) together 60 per minute, window aligned to whole minutes\\n exchange.IO(\\\"quota\\\", \\\"*\\\", 60, \\\"1m\\\")\\n\\n while (true) {\\n var ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n var depth = exchange.GetDepth(\\\"BTC_USDT\\\")\\n if (ticker && depth) {\\n Log(\\\"last:\\\", ticker.Last, \\\"best bid:\\\", depth.Bids[0].Price)\\n }\\n Sleep(1000)\\n }\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # market data: GetTicker and GetDepth together at most 20 calls per second on average\\n exchange.IO(\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\")\\n # trading: placing orders (Buy/Sell included) and cancelling together 5 per second, wait when over the limit\\n exchange.IO(\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\")\\n # fallback: other functions (such as GetAccount, GetPositions) together 60 per minute, window aligned to whole minutes\\n exchange.IO(\\\"quota\\\", \\\"*\\\", 60, \\\"1m\\\")\\n\\n while True:\\n ticker = exchange.GetTicker(\\\"BTC_USDT\\\")\\n depth = exchange.GetDepth(\\\"BTC_USDT\\\")\\n if ticker and depth:\\n Log(\\\"last:\\\", ticker[\\\"Last\\\"], \\\"best bid:\\\", depth[\\\"Bids\\\"][0][\\\"Price\\\"])\\n Sleep(1000)\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n // market data: GetTicker and GetDepth together at most 20 calls per second on average\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetTicker,GetDepth\\\", 20, \\\"1s\\\"));\\n // trading: placing orders (Buy/Sell included) and cancelling together 5 per second, wait when over the limit\\n let _ = exchange.IO((\\\"rate\\\", \\\"CreateOrder,CancelOrder\\\", 5, \\\"1s\\\", \\\"delay\\\"));\\n // fallback: other functions (such as GetAccount, GetPositions) together 60 per minute, window aligned to whole minutes\\n let _ = exchange.IO((\\\"quota\\\", \\\"*\\\", 60, \\\"1m\\\"));\\n\\n loop {\\n if let (Ok(ticker), Ok(depth)) = (exchange.GetTicker(\\\"BTC_USDT\\\"), exchange.GetDepth(\\\"BTC_USDT\\\")) {\\n Log!(\\\"last:\\\", ticker.Last, \\\"best bid:\\\", depth.Bids[0].Price);\\n }\\n Sleep(1000);\\n }\\n}\", \"lang\": \"rust\"}], \"value\": \"### Rules grouped after the exchange's own limits\\n\\nMarket data and trading each share one rule; trading calls wait instead of failing when over the limit; every other function without a rule of its own falls back to ```\\\"*\\\"```.\"}, {\"examples\": [{\"code\": \"function main() {\\n // 10 calls per second on average, but at most 2 in a burst\\n exchange.IO(\\\"rate\\\", \\\"GetDepth\\\", \\\"10/2\\\", \\\"1s\\\")\\n // resets every day at 08:00 Beijing time, at most 2000 calls per day\\n exchange.IO(\\\"quota\\\", \\\"GetRecords\\\", 2000, \\\"@0800\\\")\\n // units can be combined: at most 100 calls every 1 hour 30 minutes\\n exchange.IO(\\\"rate\\\", \\\"GetOrders\\\", 100, \\\"1h30m\\\")\\n\\n // count 0: delete the rule for GetOrders\\n exchange.IO(\\\"rate\\\", \\\"GetOrders\\\", 0)\\n // empty name: clear all rules of this exchange object\\n exchange.IO(\\\"rate\\\", \\\"\\\")\\n}\", \"lang\": \"javascript\"}, {\"code\": \"def main():\\n # 10 calls per second on average, but at most 2 in a burst\\n exchange.IO(\\\"rate\\\", \\\"GetDepth\\\", \\\"10/2\\\", \\\"1s\\\")\\n # resets every day at 08:00 Beijing time, at most 2000 calls per day\\n exchange.IO(\\\"quota\\\", \\\"GetRecords\\\", 2000, \\\"@0800\\\")\\n # units can be combined: at most 100 calls every 1 hour 30 minutes\\n exchange.IO(\\\"rate\\\", \\\"GetOrders\\\", 100, \\\"1h30m\\\")\\n\\n # count 0: delete the rule for GetOrders\\n exchange.IO(\\\"rate\\\", \\\"GetOrders\\\", 0)\\n # empty name: clear all rules of this exchange object\\n exchange.IO(\\\"rate\\\", \\\"\\\")\", \"lang\": \"python\"}, {\"code\": \"fn main() {\\n // 10 calls per second on average, but at most 2 in a burst\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetDepth\\\", \\\"10/2\\\", \\\"1s\\\"));\\n // resets every day at 08:00 Beijing time, at most 2000 calls per day\\n let _ = exchange.IO((\\\"quota\\\", \\\"GetRecords\\\", 2000, \\\"@0800\\\"));\\n // units can be combined: at most 100 calls every 1 hour 30 minutes\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetOrders\\\", 100, \\\"1h30m\\\"));\\n\\n // count 0: delete the rule for GetOrders\\n let _ = exchange.IO((\\\"rate\\\", \\\"GetOrders\\\", 0));\\n // empty name: clear all rules of this exchange object\\n let _ = exchange.IO((\\\"rate\\\", \\\"\\\"));\\n}\", \"lang\": \"rust\"}], \"value\": \"### Burst capacity, daily quota and deleting rules\"}], \"seeAlso\": [\"{@fun/IO/exchange.IO exchange.IO}, {@fun/Threads/exchange.Go exchange.Go}, {@fun/Global/GetLastError GetLastError}\"], \"title\": \"API Rate Limiting Control\"}, {\"_src_hash\": \"9c6654b6d2f6c7c73641f49a24b15f9f2b2cdf7d0b36734e55502285ac0d6fda\", \"desc\": \"The FMZ Quant Trading Platform supports options trading on the cryptocurrency futures exchanges below. Options are used the same way as futures contracts: set the contract to an option code with ```exchange.SetContractType()``` (the option code is the exchange's native code, and the format differs between exchanges). After that, market data functions such as ```GetTicker()``` and ```GetDepth()``` and trading functions such as ```Buy()```, ```Sell()``` (set the trade direction with ```exchange.SetDirection()``` before placing orders), ```CancelOrder()``` and ```GetPositions()``` all work on that option contract. You can also place orders with the full instrument code in the form ```pair.optionCode```, for example ```BTC_USDT.BTC-260925-145000-C```.\\n\\nOption order books are usually thin: when there is no bid or ask, ```Buy``` and ```Sell``` in the ```Ticker``` are 0, and ```Last``` may be 0 for a contract that has never traded; see each exchange below. Whether ```exchange.GetMarkets()``` lists option contracts depends on the exchange; where it does not, get the option codes from the exchange's API or website.\\n\\n## Futures_Deribit\\n\\nAfter setting an option contract you can get market data, place and cancel orders and query positions. Option code examples: ```BTC-13SEP24-60000-C```, ```XRP_USDC-27SEP24-1-C```; combination examples: ```BTC-CS-6SEP24-57000_57500```, ```BTC-PCAL-20SEP24_13SEP24-55000```. The result of ```exchange.GetMarkets()``` includes option contracts.\\n\\nReference strategy: [Deribit options test strategy](https://www.fmz.com/strategy/179475)\\n\\n## Futures_OKX\\n\\nUsed the same way as Deribit. Set the trading pair to ```BTC_USD``` or similar; option codes look like ```BTC-USD-200626-4500-C```. For an option that has never traded, ```Last``` in ```GetTicker()``` is the mark price. ```exchange.GetMarkets()``` does not list option contracts; the option contract list is available from OKX's ```/api/v5/public/instruments``` endpoint, for example BTC options:\\n\\n```js\\nfunction main() {\\n Log(HttpQuery(\\\"https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD\\\"))\\n}\\n```\\n\\n```python\\nimport json\\nimport urllib.request\\ndef 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```rust\\nfn main() {\\n let body: String = HttpQuery(\\\"https://www.okx.com/api/v5/public/instruments?instType=OPTION&uly=BTC-USD\\\", None);\\n Log!(body);\\n}\\n```\\n\\n## Futures_Binance\\n\\nBinance European options (USDT-settled) are supported. Set the trading pair to ```BTC_USDT``` or similar; option codes look like ```BTC-260925-145000-C``` (underlying-expiry YYMMDD-strike-C/P). Options trading must be enabled on the account. Limitations:\\n\\n- Only limit orders are supported; market orders, conditional orders and order amendment (```exchange.ModifyOrder()```) are not.\\n- Leverage and margin mode settings such as ```exchange.SetMarginLevel()``` are not supported.\\n- Unified (portfolio margin) accounts do not support options.\\n- ```exchange.GetMarkets()``` does not list option contracts.\\n\\n## Futures_Bybit\\n\\nOptions with two settlement currencies are supported:\\n\\n- USDC-settled: set the trading pair to ```ETH_USDC``` or similar; option codes look like ```ETH-25NOV22-1375-P```.\\n- USDT-settled: set the trading pair to ```ETH_USDT``` or similar; the option code has an extra settlement-currency suffix compared with USDC-settled ones, like ```ETH-25JUN27-2800-C-USDT```.\\n\\nThe result of ```exchange.GetMarkets()``` includes options of both settlement currencies. Bybit has no kline endpoint for options, so ```GetRecords()``` is built from trades.\\n\\n## Futures_Aevo\\n\\nUSDC options on Aevo are supported. Set the trading pair to ```ETH_USDC``` or similar; option codes look like ```ETH-30JUN23-1600-C```. ```Last``` in ```GetTicker()``` is the mark price. Aevo has no kline endpoint, so ```GetRecords()``` is built from trades and is empty while the contract has no trades. The result of ```exchange.GetMarkets()``` includes option contracts.\\n\\n## Futures_GateIO\\n\\nUSDT options on Gate are supported. Set the trading pair to ```BTC_USDT``` or similar; option codes look like ```BTC_USDT-20211130-65000-C```. The result of ```exchange.GetMarkets()``` includes option contracts. If options are not enabled on the account, order and position queries return the exchange's error.\\n\\n## Futures_Kraken\\n\\nOptions on Kraken Futures are supported. Set the trading pair to ```ETH_USD``` or similar; option codes look like ```OF_ETHUSD_261225_4000_C``` (```OF_```, underlying and quote currency, expiry YYMMDD, strike, C/P). The underlying and quote currency in the code must match the trading pair, and BTC is written as ```XBT``` in the code (e.g. ```OF_XBTUSD_...```).\\n\\n- Kraken has no option listing endpoint, so ```exchange.GetMarkets()``` does not include option contracts; get the option codes from the Kraken website.\\n- ```Last``` in ```GetTicker()``` is the mark price, and ```Buy```, ```Sell```, ```High``` and ```Low``` are 0; the raw data in ```Info``` carries the implied volatility, the greeks and other fields.\\n- Market data, klines, orders, positions and order history queries work; option orders go through the same order endpoint as futures contracts and have not been verified in live trading yet.\\n- Options have no funding rate, and ```exchange.SetMarginLevel()``` is not supported.\", \"seeAlso\": [\"{@fun/Futures/exchange.SetContractType exchange.SetContractType}, {@fun/Futures/exchange.SetDirection exchange.SetDirection}, {@fun/Futures/exchange.GetPositions exchange.GetPositions}\"], \"title\": \"Options Trading\"}, {\"_src_hash\": \"a67824b1213013415d0d82f475ed7aa25dfb75b33b3be7c5899f1956a634586c\", \"children\": [{\"_src_hash\": \"4b8b85efaa17fc456b7b7f803313a0fbefc864dbd41ef7f46e21a1549602457e\", \"desc\": \"The Uniswap exchange object connects to the V2 and V3 pools of Uniswap or PancakeSwap on one chain and maps on-chain swaps to spot trading functions: check prices with ```exchange.GetTicker()``` and place orders with ```exchange.CreateOrder()```, with no ABIs to register and no contract calls to encode. Routing, quoting, token approval, price protection and sending transactions are all handled by the exchange object.\\n\\n## When to use the Uniswap exchange object and when to use Web3\\n\\n- To **swap tokens** on Uniswap or PancakeSwap: use the Uniswap exchange object.\\n- To call other contracts or other DEX features (such as providing liquidity or managing V3 positions), to use other chains, or to build custom transactions: use the Web3 exchange object, see Advanced Topics → Web3 → Ethereum (EVM).\\n\\nA strategy can add both kinds of exchange objects and use the same wallet with them.\\n\\n## Configure the exchange object\\n\\n| Field | Description |\\n| - | - |\\n| DEX | ```Uniswap``` or ```PancakeSwap``` |\\n| Chain | ```Ethereum```, ```Arbitrum```, ```Base```, ```BNB Chain```. One exchange object is one DEX on one chain |\\n| Private Key | Wallet private key (hex string). The key can be deployed locally on the docker, see Getting Started → Key Security |\\n| Rpc Address | Node address of the chain; a public node is filled in when the chain is chosen (```https://ethereum-rpc.publicnode.com``` for Ethereum, for example). Several nodes separated by commas back each other up |\\n| Rpc Api Key | Node authentication, may be left empty. Written as ```Name: value``` it is sent as a request header with that name; otherwise it is sent as ```Authorization: Basic ``` |\\n\\nOn the first call the exchange object checks that the node is on the configured chain and reports an error otherwise, so transactions never go to another chain. The wallet needs the chain's native coin (ETH or BNB) to pay gas.\\n\\n## Trading pairs\\n\\n- Pairs are written as ```base_quote```, such as ```ETH_USDC``` or ```UNI_USDT```.\\n- Token names are resolved in this order: built-in common tokens (native coin, wrapped native coin, USDC, USDT, etc.) → tokens registered with ```exchange.IO(\\\"token\\\", name, contractAddress)``` → the official token lists. When the official list has several tokens with the same name on a chain, use the contract address instead.\\n- Tokens not in the token table can be used directly by contract address as part of the pair, for example ```0x1f9840a85d5af5bf1d1762f925bdaddc4201f984_USDC```.\\n- **The native coin and its wrapped token are two different assets**: ```ETH``` and ```WETH```, ```BNB``` and ```WBNB``` are different currencies. When trading the native coin, the router wraps and unwraps automatically. Converting between the two cannot be done with orders; use ```exchange.IO(\\\"wrap\\\", amount)``` and ```exchange.IO(\\\"unwrap\\\", amount)```, which call the wrapped token contract directly, 1:1, costing only gas.\\n- ```exchange.GetMarkets()``` lists only common pairs; pairs not listed can be traded as well.\\n\\n## What the standard functions do\\n\\n| Function | Behavior |\\n| - | - |\\n| ```exchange.GetTicker()``` | Best bid and ask are executable prices from actual quotes of a certain size (pool fees included); there are no 24-hour statistics on chain |\\n| ```exchange.GetDepth()``` | Price levels derived from on-chain quotes of increasing size, not a real order book |\\n| ```exchange.GetTrades()``` | Recent on-chain swaps in the pair's pools |\\n| ```exchange.GetAccount()```, ```exchange.GetAssets()``` | Balances of the native coin and of the tokens in the token table |\\n| ```exchange.CreateOrder()``` | Swaps on chain immediately, see below |\\n| ```exchange.GetOrder()``` | The order ID is the transaction hash and the status comes from the receipt: unfinished before it is mined, filled or failed after |\\n| ```exchange.GetOrders()``` | Orders sent in the current run that are not mined yet |\\n| ```exchange.CancelOrder()``` | Sends a replacement transaction with the same nonce, best effort, see below |\\n\\n```exchange.GetRecords()```, ```exchange.GetTickers()``` and ```exchange.GetHistoryOrders()``` are not supported.\\n\\n## Placing orders\\n\\nA DEX has no order book; every order is a swap executed on chain immediately. It either fills completely or reverts completely (losing only gas); it never fills partially and never rests waiting for a price.\\n\\n- **Limit orders**: the limit price is the **worst execution price**. A quote is taken first; if the current price cannot reach the limit, an error is returned and no transaction is sent. Otherwise the minimum to receive / maximum to pay is written into the on-chain transaction, and if the price moves before the transaction is mined so that the limit can no longer be met, the whole swap reverts.\\n- **Market orders**: the minimum to receive / maximum to pay is the quote minus slippage. Slippage defaults to 0.5% and is changed with ```exchange.IO(\\\"slippage\\\", ratio)```.\\n- **Amount**: for sells, the amount of base currency to sell; for limit buys, the amount of base currency to buy; **for market buys, the amount of quote currency to spend**.\\n- Settings for a single order can be appended after the side argument, for example ```exchange.CreateOrder(\\\"ETH_USDC\\\", 'sell;{\\\"slippage\\\":0.01,\\\"route\\\":\\\"v3\\\"}', -1, 0.1)```: ```slippage``` is the slippage for this order, ```route``` restricts the route type (```v2```, ```v3```, ```hop``` for two hops, ```direct```).\\n- Before selling a token (ERC20), the router's allowance is checked; if it is not enough, an approval transaction is sent first and waited for. By default only the amount needed is approved; ```exchange.IO(\\\"approve\\\", \\\"max\\\")``` switches to unlimited approval and saves later approval transactions.\\n- A transaction not mined before its deadline (120 seconds by default, change it with ```exchange.IO(\\\"deadline\\\", seconds)```) reverts, so it cannot fill after the price has moved a lot.\\n\\n## Cancelling orders\\n\\n```exchange.CancelOrder()``` sends a zero-value transaction to yourself with the original order's nonce and a higher fee; if it is mined first, the original order becomes invalid. This is a best effort: the original order may be mined and filled before the replacement, and cancelling an order that is already mined returns an error. Check the final status with ```exchange.GetOrder()``` after cancelling.\\n\\n## Common exchange.IO() commands\\n\\n| Command | Purpose |\\n| - | - |\\n| ```exchange.IO(\\\"slippage\\\", ratio)``` | Slippage for market orders, default ```0.005``` |\\n| ```exchange.IO(\\\"deadline\\\", seconds)``` | Transaction deadline, default 120 seconds |\\n| ```exchange.IO(\\\"gasMultiplier\\\", x)``` | Gas limit = node estimate × x, default 1.2 |\\n| ```exchange.IO(\\\"approve\\\", \\\"exact\\\" or \\\"max\\\")``` | Approval mode |\\n| ```exchange.IO(\\\"token\\\", name, contractAddress)``` | Register a token; without arguments, list the token table |\\n| ```exchange.IO(\\\"route\\\", symbol, side, amount)``` | Quote only: prices of the candidate routes and the best one, no order |\\n| ```exchange.IO(\\\"simulate\\\", symbol, side, amount[, price])``` | Build the transaction as an order would and only simulate it on chain, no gas spent |\\n| ```exchange.IO(\\\"transfer\\\", toAddress, amount[, token])``` | Send the native coin or a token; the amount can be ```\\\"all\\\"``` |\\n| ```exchange.IO(\\\"receipt\\\", txHash[, waitMs])``` | Receipt of a transfer or other transaction, optionally waiting for it to be mined |\\n| ```exchange.IO(\\\"wrap\\\", amount)```, ```exchange.IO(\\\"unwrap\\\", amount)``` | Convert between the native coin and the wrapped token 1:1 |\\n| ```exchange.IO(\\\"contracts\\\")``` | Contract addresses of this DEX on this chain |\\n| ```exchange.IO(\\\"base\\\", nodeAddress)```, ```exchange.IO(\\\"sendBase\\\", nodeAddress)``` | Switch nodes; set a node used only for broadcasting transactions (private transaction channel) |\\n| ```exchange.IO(\\\"address\\\")``` | Wallet address |\\n\\nFor the parameters and return values of each command see the {@fun/Uniswap Uniswap} category of the syntax manual.\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var symbol = \\\"ETH_USDC\\\"\\n exchange.IO(\\\"slippage\\\", 0.003) // 0.3% slippage for market orders\\n\\n var t = exchange.GetTicker(symbol)\\n Log(\\\"bid:\\\", t.Buy, \\\"ask:\\\", t.Sell)\\n\\n // quote only: best route for selling 0.1 ETH\\n var r = exchange.IO(\\\"route\\\", symbol, \\\"sell\\\", 0.1)\\n Log(\\\"best route:\\\", r.best, \\\"price:\\\", r.price)\\n\\n // simulate on chain first, no gas spent\\n if (!exchange.IO(\\\"simulate\\\", symbol, \\\"sell\\\", 0.1)) {\\n Log(\\\"simulation failed:\\\", GetLastError())\\n return\\n }\\n\\n // sell 0.1 ETH at market; the order ID is the transaction hash\\n var id = exchange.CreateOrder(symbol, \\\"sell\\\", -1, 0.1)\\n if (!id) {\\n Log(\\\"order failed:\\\", GetLastError())\\n return\\n }\\n while (true) {\\n var o = exchange.GetOrder(id)\\n if (o && o.Status != ORDER_STATE_PENDING) {\\n Log(\\\"status:\\\", o.Status, \\\"filled:\\\", o.DealAmount, \\\"average price:\\\", o.AvgPrice)\\n break\\n }\\n Sleep(3000)\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"## Example: quote, simulate, then sell at market\\n\\nUses ```ETH_USDC``` on Ethereum. Note that ```CreateOrder``` sends a real transaction.\"}], \"seeAlso\": [\"{@fun/Uniswap Uniswap}, {@fun/Trade/exchange.CreateOrder exchange.CreateOrder}, {@fun/Trade/exchange.CancelOrder exchange.CancelOrder}\"], \"title\": \"Uniswap and PancakeSwap\"}, {\"_src_hash\": \"ad0c1326570f7a7cf94f462ce1b00932c56d5fa59eaa30378757fc458ba0f937\", \"desc\": \"With ```ChainType``` set to ```ETH```, the Web3 exchange object connects to nodes of Ethereum and every EVM-compatible chain (BSC, Base, Arbitrum, Optimism, Polygon and so on), and uses the ```exchange.IO()``` commands to query balances, call contracts and send transactions. This page walks through the commands in the order of a typical on-chain operation; for the full parameters of each command see the corresponding ```exchange.IO(\\\"command\\\", ...)``` in the {@fun/Web3 Web3} category of the syntax manual.\\n\\nIf you only want to swap tokens on Uniswap or PancakeSwap, use the Uniswap exchange object (see Advanced Topics → Web3 → Uniswap and PancakeSwap): it supports standard functions such as ```exchange.GetTicker()``` and ```exchange.CreateOrder()``` directly, with no contract calls to encode yourself.\\n\\n## 1. Configure the exchange object\\n\\nAdd an exchange on the \\\"Exchange\\\" page (```/m/add-platform```), choose the protocol \\\"Cryptocurrency\\\" and the exchange ```Web3```:\\n\\n| Field | Description |\\n| - | - |\\n| ChainType | ```ETH```: Ethereum and all EVM-compatible chains; ```TRON```: TRON, see Advanced Topics → Web3 → TRON |\\n| Private Key | Wallet private key (hex string, the ```0x``` prefix is optional). The key can be deployed locally on the docker, see Getting Started → Key Security |\\n| Rpc Address | Node address, by default ```https://ethereum-rpc.publicnode.com``` (a public Ethereum mainnet node). For other chains enter a node of that chain, for example BSC: ```https://bsc-dataseed.binance.org```. ```http(s)://``` and ```ws(s)://``` are supported. Several nodes separated by commas back each other up |\\n| Rpc Api Key | Node authentication, may be left empty. Written as ```Name: value``` (such as ```x-api-key: xxx```) it is sent as a request header with that name; otherwise it is sent as ```Authorization: Basic ``` |\\n\\nWith several nodes, requests start from the node that last succeeded and move on only when a node is unavailable (connection failure, timeout, rate limiting); errors such as a failed contract execution are returned directly. Nodes whose chain ID differs from the first node's are skipped, so transactions are never sent to another chain.\\n\\nAt runtime, ```exchange.IO(\\\"base\\\", nodeAddress)``` switches nodes (several nodes can be passed as an array or a comma-separated string), ```exchange.IO(\\\"key\\\", privateKey)``` switches the wallet private key, and {@fun/Web3/exchange.IO(\\\"address\\\") exchange.IO(\\\"address\\\")} returns the current wallet address.\\n\\nAmong the standard functions only ```exchange.GetAccount()``` and ```exchange.GetAssets()``` are available; they return the wallet's native coin balance (the currency is recognized from the chain ID, ```BNB``` on BSC for example).\\n\\n## 2. Query balances and read contracts\\n\\nRead-only contract methods (```view```/```pure```) cost no gas and return decoded results directly:\\n\\n```js\\nexchange.IO(\\\"api\\\", \\\"eth\\\", \\\"eth_getBalance\\\", wallet, \\\"latest\\\") // native coin balance, on-chain integer (hex string)\\nexchange.IO(\\\"api\\\", tokenAddress, \\\"balanceOf\\\", wallet) // ERC20 balance, on-chain integer\\nexchange.IO(\\\"api\\\", tokenAddress, \\\"decimals\\\") // token decimals\\n```\\n\\n- ```exchange.IO(\\\"api\\\", \\\"eth\\\", method, ...args)``` calls the node's JSON-RPC methods directly, such as ```eth_gasPrice```, ```eth_blockNumber``` and ```eth_getTransactionReceipt```.\\n- ```exchange.IO(\\\"api\\\", contractAddress, method, ...args)``` calls a contract method. The method can be a name, a full signature (such as ```\\\"approve(address,uint256)\\\"```, to tell overloads apart) or a selector (such as ```\\\"0x095ea7b3\\\"```).\\n- On-chain amounts are integers. ```exchange.IO(\\\"fromUnits\\\", onChainInteger, decimals)``` converts to a readable amount and ```exchange.IO(\\\"toUnits\\\", \\\"1.5\\\", decimals)``` converts back; a token contract address can be passed in place of the decimals. Both compute exactly on strings.\\n- Use ```exchange.IO(\\\"multicall\\\", ...)``` to read many contracts in one request, and ```exchange.IO(\\\"logs\\\", ...)``` to query event logs.\\n\\n## 3. Register ABIs\\n\\nStandard ERC20 methods (```balanceOf```, ```decimals```, ```allowance```, ```approve```, ```transfer``` and others) are built in and need no registration. Before calling methods of other contracts, register the contract's ABI with ```exchange.IO(\\\"abi\\\", contractAddress, abi)```.\\n\\nCommon contracts can use built-in templates by passing the template name as the third argument: ```\\\"weth\\\"```, ```\\\"uniswapV3Pool\\\"```, ```\\\"uniswapV3Factory\\\"```, ```\\\"uniswapV3QuoterV2\\\"```, ```\\\"uniswapV3SwapRouter02\\\"```, ```\\\"uniswapV3PositionManager\\\"```, ```\\\"permit2\\\"``` (PancakeSwap V3 uses the same templates, aliases such as ```\\\"pancakeV3Pool\\\"``` also work). Addresses of common contracts are available from ```exchange.IO(\\\"contracts\\\")```.\\n\\n```js\\nexchange.IO(\\\"abi\\\", poolAddress, \\\"uniswapV3Pool\\\")\\nvar slot0 = exchange.IO(\\\"api\\\", poolAddress, \\\"slot0\\\")\\n```\\n\\nThe ABI of other contracts can be obtained from a block explorer, for example Etherscan's V2 API (an Etherscan API key is required, ```chainid``` is the chain ID, take the ```result``` field of the response):\\n\\n```url\\nhttps://api.etherscan.io/v2/api?chainid=1&module=contract&action=getabi&address=0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45&apikey=YourApiKey\\n```\\n\\n## 4. Send transactions\\n\\nWhen a write method of a contract is called, the exchange object signs the transaction with the configured private key, broadcasts it and returns the transaction hash. Before sending you can replace ```\\\"api\\\"``` with ```\\\"call\\\"``` and rehearse the same call with ```exchange.IO(\\\"call\\\", ...)```: it is simulated on the node without signing or spending gas; on failure it returns an empty value and ```GetLastError()``` holds the reason given by the contract.\\n\\nTaking approve as an example:\\n\\n```js\\nvar amount = exchange.IO(\\\"toUnits\\\", \\\"100\\\", tokenAddress) // 100 tokens as an on-chain integer\\nvar txHash = exchange.IO(\\\"api\\\", tokenAddress, \\\"approve\\\", spender, amount)\\n```\\n\\nWhen the method's ```stateMutability``` is ```payable```, pass one extra argument before the method arguments: the amount of native coin to attach (on-chain integer). The last argument can be an options object:\\n\\n| Option | Description |\\n| - | - |\\n| gasLimit | Gas limit. Estimated by the node (```eth_estimateGas```) when omitted. Do not use ```21000``` for contract calls; that is only enough for a plain transfer |\\n| gasPrice | Fixed gas price; when given, a legacy transaction is sent. When omitted, chains that support EIP-1559 get an EIP-1559 transaction: the tip is the larger of the node's suggestion and the tips actually paid in recent blocks, and the max fee is ```2 × baseFee + tip``` |\\n| nonce | A specific nonce. Allocated automatically when omitted and kept in sync with the on-chain pending count, so consecutive sends never reuse a nonce |\\n| dryRun | When ```true```, sign without broadcasting and return fields such as ```hash```, ```raw``` (the signed transaction), ```nonce``` and ```gasLimit```, for checking the transaction or sending it through another channel |\\n\\nNative coin is sent with ```exchange.IO(\\\"api\\\", \\\"eth\\\", \\\"send\\\", toAddress, amount)```, where the amount is an on-chain integer (wei). Its options also accept ```data``` (hex call data) to send a transaction ```{to, data, value}``` returned by an aggregator API as is; gas is then estimated as for a contract call. Note: a plain transfer without ```gasPrice``` bids a fixed 100 Gwei with a gas limit of 21000, usually too high on Ethereum mainnet; query ```eth_gasPrice``` first and pass it in.\\n\\nTo send transactions through a private channel (such as Flashbots Protect or MEV Blocker) and avoid front-running, set a node used only for broadcasting with ```exchange.IO(\\\"sendBase\\\", nodeAddress)```.\\n\\n## 5. Wait for the transaction to be mined\\n\\n```exchange.IO(\\\"waitReceipt\\\", txHash, {timeout, confirmations})``` waits until the transaction is mined with the required confirmations and returns the receipt: ```status``` is ```1``` for success and ```0``` for failure (with the reason in ```revertReason```), and ```events``` holds the events decoded with the registered ABIs. It returns an empty value on timeout.\\n\\n## 6. Nonce management, speeding up and cancelling\\n\\n- ```exchange.IO(\\\"nonce\\\")``` shows the on-chain and local nonce counts; ```exchange.IO(\\\"nonce\\\", \\\"sync\\\")``` resyncs from the chain (use it after the same wallet has sent transactions elsewhere).\\n- When a transaction stays unmined for a long time, ```exchange.IO(\\\"speedUp\\\", txHash)``` resends it with the same nonce and a higher fee, and ```exchange.IO(\\\"cancelTx\\\", txHash)``` replaces it with a zero-value transaction to yourself using the same nonce. Both only work before the original transaction is mined.\\n- The local nonce record only exists inside the current live trading instance: instances that share one wallet cannot see each other's records and may still collide, so give each instance its own wallet.\\n\\n## Other commands\\n\\n- Encoding and decoding: ```exchange.IO(\\\"encode\\\", ...)``` encodes contract call data or values by type (like Solidity's ```abi.encode```), ```exchange.IO(\\\"encodePacked\\\", ...)``` does packed encoding (for example a Uniswap V3 swap path), and ```exchange.IO(\\\"decode\\\", ...)``` decodes by type.\\n- Signing: ```exchange.IO(\\\"sign\\\", ...)``` signs a 32-byte hash, ```exchange.IO(\\\"signTypedData\\\", ...)``` signs EIP-712 typed data (such as ERC-20 Permit), and ```exchange.IO(\\\"signMessage\\\", ...)``` signs a message with EIP-191.\\n- Uniswap V3 math: ```exchange.IO(\\\"uniswapV3\\\", ...)``` converts between ticks, prices and sqrtPrice, and between liquidity and token amounts.\\n- Hashing: ```exchange.IO(\\\"hash\\\", \\\"keccak256\\\", \\\"raw\\\", \\\"hex\\\", text)``` computes keccak256 and other digests, for example method selectors and EIP-712 digests; its parameters are the same as those of the ```Encode()``` function.\\n- Complete examples: a swap through an aggregator (quote, build the transaction, rehearse it with ```exchange.IO(\\\"call\\\", ...)```, send it with ```data```) is in the examples of ```exchange.IO(\\\"call\\\", ...)``` in the syntax manual; an ERC-20 Permit signature verified by the contract is in the examples of ```exchange.IO(\\\"sign\\\", ...)``` and ```exchange.IO(\\\"signTypedData\\\", ...)```.\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var usdc = \\\"0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48\\\" // USDC on Ethereum mainnet\\n var spender = \\\"0x68b3465833fb72A70ecDF485E0e4C7bD8665Fc45\\\" // the contract to approve, Uniswap SwapRouter02 here\\n var wallet = exchange.IO(\\\"address\\\")\\n\\n // balances: standard ERC20 methods need no ABI registration\\n var eth = exchange.IO(\\\"fromUnits\\\", exchange.IO(\\\"api\\\", \\\"eth\\\", \\\"eth_getBalance\\\", wallet, \\\"latest\\\"), 18)\\n var usdcBalance = exchange.IO(\\\"fromUnits\\\", exchange.IO(\\\"api\\\", usdc, \\\"balanceOf\\\", wallet), usdc)\\n Log(\\\"ETH:\\\", eth, \\\"USDC:\\\", usdcBalance)\\n\\n // read a contract: current allowance\\n var allowance = exchange.IO(\\\"api\\\", usdc, \\\"allowance\\\", wallet, spender)\\n Log(\\\"current allowance:\\\", exchange.IO(\\\"fromUnits\\\", allowance, usdc))\\n\\n // approve 100 USDC: rehearse first, then send\\n var amount = exchange.IO(\\\"toUnits\\\", \\\"100\\\", usdc)\\n if (!exchange.IO(\\\"call\\\", usdc, \\\"approve\\\", spender, amount)) {\\n Log(\\\"rehearsal failed:\\\", GetLastError())\\n return\\n }\\n var txHash = exchange.IO(\\\"api\\\", usdc, \\\"approve\\\", spender, amount)\\n Log(\\\"tx hash:\\\", txHash)\\n\\n // wait at most 3 minutes for the transaction to be mined\\n var receipt = exchange.IO(\\\"waitReceipt\\\", txHash, {timeout: 180000})\\n if (receipt && receipt.status == 1) {\\n Log(\\\"approved in block:\\\", receipt.blockNumber)\\n } else if (receipt) {\\n Log(\\\"transaction failed:\\\", receipt.revertReason)\\n } else {\\n // not mined yet: speedUp resends with a higher fee, cancelTx cancels it\\n Log(\\\"not mined before timeout:\\\", GetLastError())\\n }\\n}\", \"lang\": \"javascript\"}], \"value\": \"## Example: query balances, approve and wait for the transaction\\n\\nUses USDC on Ethereum mainnet. Note that this code sends a real transaction and spends gas.\"}], \"seeAlso\": [\"{@fun/Web3 Web3}, {@fun/IO/exchange.IO exchange.IO}\"], \"title\": \"Ethereum (EVM)\"}, {\"_src_hash\": \"6cd095aba18e68729e7e7a725301488a2c15df8c318e32cf7ac94b634ee33d95\", \"desc\": \"With ```ChainType``` set to ```TRON```, the Web3 exchange object connects to a TRON node. Usage is largely the same as on Ethereum (see Advanced Topics → Web3 → Ethereum (EVM)): the ```exchange.IO()``` commands for registering ABIs, calling contracts, encoding and decoding, signing and switching private keys are the same, addresses use the TRON format (starting with ```T```), and TRX amounts are in sun (1 TRX = 1000000 sun). This page covers the configuration and the TRON-specific parts.\\n\\n## Configure the exchange object\\n\\n| Field | Description |\\n| - | - |\\n| ChainType | Choose ```TRON``` |\\n| Private Key | Wallet private key (hex string). The key can be deployed locally on the docker, see Getting Started → Key Security |\\n| Rpc Address | HTTP address of a TRON full node, for example the official node ```https://api.trongrid.io``` (testnets: ```https://nile.trongrid.io```, ```https://api.shasta.trongrid.io```) |\\n| Rpc Api Key | TronGrid API key. Enter only the key itself; it is sent as the ```TRON-PRO-API-KEY``` request header. It works without a key, but TronGrid rate-limits keyless requests more strictly |\\n\\nThe docker accesses TRON through the full node's HTTP API (```/wallet/...```) and no longer uses gRPC. The old gRPC address ```grpc.trongrid.io:50051``` that the form fills in by default for TRON is replaced automatically with ```https://api.trongrid.io``` (```grpc.nile.trongrid.io:50051``` and ```grpc.shasta.trongrid.io:50051``` likewise become the HTTP addresses of the corresponding testnets); any other gRPC address is rejected, so enter the node's HTTP address instead.\\n\\nAt runtime, ```exchange.IO(\\\"base\\\", nodeAddress)``` switches nodes, ```exchange.IO(\\\"key\\\", privateKey)``` switches wallets, and ```exchange.IO(\\\"address\\\")``` returns the current wallet address (starting with ```T```). The standard functions ```exchange.GetAccount()``` and ```exchange.GetAssets()``` return the wallet's TRX balance. An account that has not been activated yet (no on-chain record) reads as 0 TRX.\\n\\n## Calling smart contracts\\n\\nAs on Ethereum, use ```exchange.IO(\\\"api\\\", contractAddress, method, ...args)```: read-only methods return results directly, write methods sign and broadcast a transaction and return the transaction ID. Standard TRC20 methods are built in; for other contracts without a registered ABI, the ABI is read from the chain automatically, and only when that fails do you need to register it with ```exchange.IO(\\\"abi\\\", contractAddress, abi)```. The last argument of a write method can be ```{gasLimit: amount}``` to set the fee limit (feeLimit, in sun).\\n\\n```js\\n// USDT (TRC20) contract\\nvar usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\nLog(exchange.IO(\\\"api\\\", usdt, \\\"balanceOf\\\", exchange.IO(\\\"address\\\"))) // on-chain integer, USDT has 6 decimals\\n```\\n\\nEncoding and decoding work as on Ethereum; address arguments can be written directly as ```T``` addresses:\\n\\n```js\\nexchange.IO(\\\"encode\\\", \\\"address\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\")\\n// 000000000000000000000000a614f803b6fd780986a42c78ec9c7f77e6ded13c\\nexchange.IO(\\\"encodePacked\\\", \\\"address\\\", \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\")\\n// a614f803b6fd780986a42c78ec9c7f77e6ded13c\\nexchange.IO(\\\"decode\\\", \\\"string\\\", \\\"0000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000000a5465746865722055534400000000000000000000000000000000000000000000\\\")\\n// Tether USD\\n```\\n\\n## Calling TRON node methods\\n\\n```exchange.IO(\\\"api\\\", \\\"tron\\\", method, ...args)``` calls TRON node methods; method names are case-insensitive. Methods that need a signature (transfers, triggering contracts, etc.) are signed and broadcast automatically. Common methods:\\n\\n| Method | Arguments | Description |\\n| - | - | - |\\n| ```send``` | to address, amount (sun) | Send TRX from the current wallet |\\n| ```Transfer``` | from address, to address, amount (sun) | Send TRX; the from address must be the current wallet |\\n| ```GetAccount``` | address | Account information |\\n| ```GetAccountResource``` | address | The account's energy and bandwidth resources |\\n| ```GetContractABI``` | contract address | The contract's on-chain ABI |\\n| ```GetAssetIssueByName``` | name | TRC10 asset information |\\n| ```GetNowBlock``` | none | Current block |\\n| ```GetBlockByNum``` | block height | A given block |\\n| ```GetTransactionByID``` | transaction ID | Transaction content |\\n| ```GetTransactionInfoByID``` | transaction ID | Execution result of a transaction (fees, energy used, logs, etc.) |\\n| ```GetChainParameters``` | none | Chain parameters |\\n| ```TriggerConstantContract``` | caller address (may be empty), contract address, method, encoded arguments | Read-only contract call; the result is in ```constant_result``` (hex strings, decode them with ```exchange.IO(\\\"decode\\\", ...)```) |\\n| ```TRC20ContractBalance``` | address, contract address | TRC20 balance (on-chain integer) |\\n| ```TRC20GetName```, ```TRC20GetSymbol```, ```TRC20GetDecimals``` | contract address | Name, symbol and decimals of a TRC20 token |\\n| ```TRC20Send```, ```TRC20Approve``` | from address, to or spender address, contract address, amount, feeLimit | TRC20 transfer and approval |\\n| ```TRC20Call``` | caller address (may be empty), contract address, call data, read-only flag, feeLimit | Call a contract with raw call data |\\n| ```ParseTRC20NumericProperty```, ```ParseTRC20StringProperty``` | hex data | Parse numbers and strings returned by TRC20 |\\n\\nNode endpoints not in the table can be called with a path and a request body: ```exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"/wallet/endpointName\\\", {body})```.\\n\\n## Differences from Ethereum\\n\\nThe following commands only work on Ethereum (EVM) and report an error on TRON: ```call```, ```multicall```, ```logs```, ```waitReceipt```, ```nonce```, ```speedUp```, ```cancelTx``` and ```contracts```; ```sendBase``` and multiple fallback nodes also only apply to Ethereum. On TRON, simulate a contract call with the node method ```TriggerConstantContract```, and query a transaction's execution result with ```GetTransactionInfoByID```.\\n\\n```toUnits```, ```fromUnits```, ```uniswapV3```, the encoding and decoding commands and the signing commands work on TRON as well, and a TRC20 contract address can be passed as the decimals:\\n\\n```js\\nvar usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\nvar raw = exchange.IO(\\\"api\\\", usdt, \\\"balanceOf\\\", exchange.IO(\\\"address\\\"))\\nLog(exchange.IO(\\\"fromUnits\\\", raw, usdt)) // converted to a readable amount with the contract's decimals()\\n```\\n\\nWhen the node rejects a contract call at validation time (for example because the contract does not exist), the error carries the node's reason, such as ```tron contract call rejected (CONTRACT_VALIDATE_ERROR): Smart contract is not exist.```; a contract execution failure (revert) reports ```tron contract execution failed``` with the reason.\\n\\n## Signing\\n\\n```exchange.IO(\\\"hash\\\", \\\"sign\\\", \\\"hex\\\", \\\"hex\\\", txHash)``` signs a 32-byte hash with the current private key and returns the 65-byte signature ```r‖s‖v``` (v is 0 or 1); other ```hash``` algorithms (such as ```\\\"sha256\\\"```) compute digests, the same as the ```Encode()``` function. When r, s and v (v being 27 or 28) are needed separately for contract verification, use ```exchange.IO(\\\"sign\\\", ...)```, see the {@fun/Web3 Web3} category of the syntax manual.\", \"examples\": [{\"examples\": [{\"code\": \"function main() {\\n var usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\n var wallet = exchange.IO(\\\"address\\\")\\n\\n // TRX balance (standard function, in TRX)\\n Log(\\\"account:\\\", exchange.GetAccount())\\n\\n // USDT balance: an on-chain integer, scale it by the decimals\\n var raw = exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"TRC20ContractBalance\\\", wallet, usdt)\\n var decimals = exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"TRC20GetDecimals\\\", usdt)\\n Log(\\\"USDT:\\\", raw / Math.pow(10, decimals))\\n\\n // read-only call of name() (selector 0x06fdde03) with TRC20Call, then parse the returned string\\n var ret = exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"TRC20Call\\\", \\\"\\\", usdt, \\\"0x06fdde03\\\", true, 0)\\n // constant_result holds hex strings, parse them directly\\n Log(\\\"name:\\\", exchange.IO(\\\"api\\\", \\\"tron\\\", \\\"ParseTRC20StringProperty\\\", ret.constant_result[0]))\\n}\", \"lang\": \"javascript\"}], \"value\": \"## Examples\\n\\n### Query TRX and USDT balances and read token information\"}, {\"examples\": [{\"code\": \"function main() {\\n var usdt = \\\"TR7NHqjeKQxGTCi8q8ZY4pL8otSzgjLj6t\\\"\\n var multicall = \\\"TGXuuKAb4bnrn137u39EKbYzKNXvdCes98\\\"\\n var wallet = exchange.IO(\\\"address\\\")\\n\\n var calls = [\\n [usdt, exchange.IO(\\\"encode\\\", usdt, \\\"name\\\")],\\n [usdt, exchange.IO(\\\"encode\\\", usdt, \\\"decimals\\\")],\\n [usdt, exchange.IO(\\\"encode\\\", usdt, \\\"balanceOf\\\", wallet)]\\n ]\\n // register the aggregate method of the Multicall contract\\n exchange.IO(\\\"abi\\\", multicall, `[{\\\"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 var ret = exchange.IO(\\\"api\\\", multicall, \\\"aggregate\\\", calls)\\n Log(\\\"name:\\\", exchange.IO(\\\"decode\\\", \\\"string\\\", ret.returnData[0]))\\n Log(\\\"decimals:\\\", exchange.IO(\\\"decode\\\", \\\"uint8\\\", ret.returnData[1]))\\n Log(\\\"balanceOf:\\\", exchange.IO(\\\"decode\\\", \\\"uint256\\\", ret.returnData[2]))\\n}\", \"lang\": \"javascript\"}], \"value\": \"### Read several contract methods at once with a Multicall contract\"}], \"seeAlso\": [\"{@fun/Web3 Web3}, {@fun/IO/exchange.IO exchange.IO}\"], \"title\": \"TRON\"}], \"desc\": \"To swap tokens on the decentralized exchanges Uniswap and PancakeSwap, use the Uniswap exchange object (see Uniswap and PancakeSwap below). To read on-chain data, call smart contracts and send custom transactions, use the Web3 exchange object, which supports Ethereum and other EVM-compatible chains as well as TRON.\", \"title\": \"Web3\"}], \"desc\": \"Advanced usage: JavaScript multi-threading, communication between live tradings, API rate limiting, options trading and on-chain trading with Web3.\", \"title\": \"Advanced Topics\"}, {\"_src_hash\": \"ae6a45caba47ac9bfb485536fbb33bfd7de87522ee8daf0484881e23000abbe5\", \"children\": [{\"_src_hash\": \"88d3a2f4534fb85bb8d1530d77b6eb0b7e67c8123ff1df0ce89e1fbb64ef875a\", \"children\": [], \"desc\": \"**datadata**, developed by FMZ Quant, is a quantitative financial data platform. The [Data Explorer](https://www.fmz.com/m/database) module of FMZ integrates its services and features, and FMZ users can use it without registering a separate **datadata** account. Analyze large amounts of data with SQL, build various charts through a visual interface and share them with your team. For examples, see the [Data Explorer articles](https://www.fmz.com/digest-topic/10370).\\n\\n- Data sources: the data sources provided by datadata are updated continuously in real time and cover many kinds of data; you can also upload CSV files as private data sources and preview them on the Data Explorer page.\\n- Queries: query data with SQL, with query parameters; results can be downloaded as CSV or JSON files.\\n- Saving research: click \\\"Save\\\" at the top right to save the current SQL query to the resource list of your Data Explorer (the resource list button is to the left of \\\"Save\\\").\\n- Visualization: query results can be shown as tables or with various visualization components.\\n- Sharing research: as a public link, embed code (e.g. in a community post), an embedded web page, a data link or a preview image link. A \\\"data link\\\" also feeds the data straight to strategies, in both backtests and live robots.\", \"title\": \"Data Explorer\"}, {\"_src_hash\": \"460de3d197e0b07f1e0de016b08cecaba358c95e0d63a98e1e93a4219288d22b\", \"children\": [{\"_src_hash\": \"b17cbede810f9ad36a8b8f64fdba523f2b83ec26df197e8e730a78db4c6316d5\", \"desc\": \"**The ```{}``` below represents placeholders, all expressions are case-insensitive, x represents data time series**\\n\\n- ```abs(x), log(x), sign(x)```: absolute value, logarithm and sign function respectively.\\n\\nThe following operators ``` +, -, *, /, >, < ``` also conform to their standard meanings, ```==```: equality check, ```||```: logical OR, ```x ? y : z```: ternary conditional operator.\\n\\n- ```rank(x)``` : Cross-sectional ranking, returns the percentile position. Requires a candidate pool of several instruments; with a single instrument nothing can be ranked and the raw value is returned.\\n- ```delay(x, d)``` : Returns the value of series x from d periods ago.\\n- ```sma(x, d)``` : Calculates the simple moving average of series x over d periods.\\n- ```correlation(x, y, d)```: Calculates the correlation coefficient between time series x and y over the past d periods.\\n- ```covariance(x, y, d)``` : Calculates the covariance between time series x and y over the past d periods.\\n- ```scale(x, a)``` : Normalizes data such that ```sum(abs(x))=a``` (a defaults to 1).\\n- ```delta(x, d)``` : Calculates the current value of time series x minus the value from d periods ago.\\n- ```signedpower(x, a)``` : ```x^a```.\\n- ```decay_linear(x, d)``` : Calculates the d-period weighted moving average of time series x, with weights d,d-1,d-2....1 (normalized).\\n- ```indneutralize(x, g)``` : Industry neutralization based on industry classification g, currently not supported.\\n- ```ts_{O}(x, d)``` : Performs operation O on the past d periods of time series x (O can specifically represent min, max, etc., see below), d will be converted to integer.\\n- ```ts_min(x, d)``` : Minimum value over the past d periods.\\n- ```ts_max(x, d)``` : Maximum value over the past d periods.\\n- ```ts_argmax(x, d)``` : Position of ```ts_max(x, d)```.\\n- ```ts_argmin(x, d)``` : Position of ```ts_min(x, d)```.\\n- ```ts_rank(x, d)``` : Ranking of time series x over the past d periods (percentile ranking).\\n- ```min(x, d)``` : ```ts_min(x, d)```.\\n- ```max(x, d)```: ```ts_max(x, d)```.\\n- ```sum(x, d)``` : Cumulative sum over the past d periods.\\n- ```product(x, d)``` : Cumulative product over the past d periods.\\n- ```stddev(x, d)``` : Standard deviation over the past d periods.\", \"title\": \"Functions and Operators\"}, {\"_src_hash\": \"ac505911169f4faf7566181dbb22cca5e98b7a7c2c284eaf6e536355bf8ca2db\", \"desc\": \"**Input data is case-insensitive. Default data is the instrument selected on the webpage, but can also be specified directly, for example: ```binance.ada_bnb```**\\n\\n- ```returns```: Close price returns.\\n- ```open, close, high, low, volume```: Open price, close price, high price, low price and volume within the period.\\n- ```vwap```: Volume-weighted average price (not yet implemented, currently using close price).\\n- ```cap```: Total market capitalization (not yet implemented).\\n- ```IndClass```: Industry classification (not yet implemented).\", \"title\": \"Input Data\"}, {\"_src_hash\": \"876d030faec40e7f09ab724b035f7d132110eed92bd6d4c20469442e5917cbf3\", \"desc\": \"Supports outputting multiple results at once, represented as a list. For example, ```[sma(close, 10), sma(high, 30)]``` will plot two lines on the chart. Besides inputting time series data, it can also be used as a simple calculator.\", \"title\": \"Others\"}], \"desc\": \"The analysis formulas reference the market calculation methods from ```worldquant```'s publicly available [```alpha101```](https://github.com/yli188/WorldQuant_alpha101_code/blob/master/101%20Formulaic%20Alphas.pdf), with basic compatibility for its syntax (unimplemented features are noted), and have been enhanced. This tool is used for rapid time series computation and validation of trading ideas. [Alpha Factor Analysis Tool Page](https://www.fmz.com/m/alpha).\", \"title\": \"Alpha Factor Analysis Tool\"}], \"desc\": \"The data explorer and the alpha factor analysis tool.\", \"title\": \"Data and Research\"}, {\"_src_hash\": \"25985b8b13357cb7a743297539ba3e0c224a70a176936d7b504772a7b3cca85b\", \"children\": [{\"_src_hash\": \"44bbaf44a152677d136222a7ccd12c89e42ef3aed3f36629b5fb89df4ce4c8bf\", \"desc\": [\"Connect FMZ to an AI coding assistant (AI agent) such as Claude Code, Codex or Cursor, and you can write strategies, run backtests, create and manage live trading, and read logs and profit just by talking to it. The assistant reaches these functions through the platform's MCP (Model Context Protocol) service, with an API KEY created for it alone; you choose its permissions when you approve it and can change or revoke them at any time.\\n\\n**Connect with one sentence**\\n\\nTell your AI assistant:\\n\\n```\\nRead https://www.fmz.com/agent/setup.md and connect to FMZ\\n```\\n\\nThe assistant follows that page; your only step is one click in the browser:\\n\\n1. The assistant requests authorization and shows you a link such as ```https://www.fmz.com/agent/authorize?code=XXXX-XXXX```, valid for 10 minutes.\\n2. Open it in a browser where you are logged in to FMZ, check the requester's name and the permissions, and approve. You can untick permissions you do not want to grant.\\n3. The assistant receives an API KEY, writes it into its own MCP configuration and connects. From then on you can simply ask it to \\\"list my live trading\\\" or \\\"backtest this strategy\\\".\\n\\nThe assistant names the key \\\"name @ machine\\\" (for example ```Claude Code @ MacBook```). When a request with the same name is approved again, the old key is revoked and replaced, so connecting again does not pile up keys.\\n\\n**Permissions**\\n\\n| Permission | Allows | Default |\\n| - | - | - |\\n| read | Lists and details of strategies, live trading, nodes and exchange accounts; logs, messages, account summary (never any secret) | Yes |\\n| backtest | Start, query and stop backtests | Yes |\\n| write | Save strategies and versions, groups, alert switches; change the configuration of stopped live trading | Yes |\\n| trade | Create, start and stop live trading, send interactive commands (costs balance and places real orders) | Yes |\\n| danger | Delete strategies, live trading and nodes; publish strategies | No |\\n\\n```danger``` is never granted by default: the assistant has to request it explicitly and you have to tick it on the approval page. Before calling a ```[trade]``` or ```[danger]``` tool the assistant should ask you first.\\n\\n**Manual configuration**\\n\\nClients that cannot run commands (for example Cherry Studio) can be configured by hand:\\n\\n1. Create an API KEY under Account settings → API KEY (```https://www.fmz.com/m/account#apikey```) and note its Access Key and Secret Key.\\n2. Add an MCP server of type Streamable HTTP to the client:\\n - URL: ```https://www.fmz.com/api/mcp/```\\n - Header: ```Authorization: Bearer ```\\n\\nThe Secret Key goes in the header only, never in the URL. Examples:\\n\\n```bash\\n# Claude Code\\nclaude mcp add --transport http fmz \\\"https://www.fmz.com/api/mcp/\\\" --header \\\"Authorization: Bearer \\\"\\n```\\n\\n```json\\n{\\\"mcpServers\\\": {\\\"fmz\\\": {\\\"url\\\": \\\"https://www.fmz.com/api/mcp/\\\", \\\"headers\\\": {\\\"Authorization\\\": \\\"Bearer \\\"}}}}\\n```\\n\\nThe JSON is for Cursor (```~/.cursor/mcp.json```) and other clients that speak Streamable HTTP; Claude Desktop needs the ```npx mcp-remote``` bridge described in the setup page.\\n\\n**Install the skills (recommended)**\\n\\nThe skills are knowledge packs written for AI assistants: platform workflow, the full API reference, how to write strategies in each language, backtesting and indicators. With them installed the assistant writes noticeably more accurate strategies. In a terminal:\\n\\n```bash\\nnpx skills add fmzquant/skills --global --yes -a claude-code\\n```\\n\\nPut your assistant's name after ```-a``` (claude-code, codex, cursor, gemini-cli, ...). They can also be read on GitHub: ```https://github.com/fmzquant/skills```.\\n\\n**Available tools**\\n\\nOnce connected the assistant can use the tools below; the list the assistant sees is authoritative:\\n\\n| Permission | Tools |\\n| - | - |\\n| read | ```ping```, ```get_account_summary```, ```list_exchanges```, ```list_platforms```, ```list_nodes```, ```list_strategies```, ```get_strategy```, ```list_strategy_versions```, ```get_strategy_version```, ```list_robots```, ```get_robot```, ```get_robot_logs```, ```get_robot_profit```, ```get_robot_output```, ```list_messages```, ```list_groups```, ```revoke_my_key``` |\\n| backtest | ```run_backtest```, ```get_backtest```, ```list_backtests```, ```stop_backtest``` |\\n| write | ```check_strategy```, ```save_strategy```, ```save_strategy_version```, ```delete_strategy_version```, ```update_robot```, ```save_group```, ```move_to_group```, ```delete_group```, ```set_robot_alert```, ```set_node_alert```, ```delete_messages``` |\\n| trade | ```create_robot```, ```start_robot```, ```stop_robot```, ```restart_robot```, ```send_robot_command```, and the trading terminal plugin tools ```plugin_*``` (market data, orders, ...) |\\n| danger | ```delete_strategy```, ```delete_robot```, ```delete_node```, ```publish_strategy``` |\\n\\nA typical session: ```list_platforms``` and ```list_nodes``` to see which exchange accounts and nodes the account has; ```save_strategy``` to save a strategy and ```check_strategy``` to check it; ```run_backtest``` and ```get_backtest``` to backtest; then ```create_robot``` to go live and ```get_robot``` / ```get_robot_logs``` to watch it.\\n\\n**Security and management**\\n\\n- Exchange API KEYs never pass through the assistant: add them on the Exchanges page of the website and the assistant picks them by id. No tool result ever contains a secret.\\n- At ```https://www.fmz.com/m/account#apikey``` you can see the key the assistant uses, change its permissions or lock it. Besides the permission names above, permissions can list tool names, and ```!tool_name``` excludes one tool.\\n- When you are done, ask the assistant to call ```revoke_my_key``` to revoke its own key, or delete it on that page.\\n- ```stop_robot``` stops live trading; it does not close positions.\\n- The first time the assistant creates live trading, backtest first and then run on a demo account or with a small amount.\\n\\n**Common problems**\\n\\n- No online node: live trading needs at least one online node, see Platform Basics → Nodes.\\n- Too many backtests: concurrent backtests are limited; have the assistant ```stop_backtest``` the ones it no longer needs.\\n- The assistant says a tool is missing or a call is refused: the key lacks that permission; change it on the API KEY page and reconnect.\\n\\nThe same API KEY also works with the Extended API (Integrations → Extended API Interface) for scripts and schedulers; prefer MCP wherever it can be used.\"], \"title\": \"AI Integration\"}, {\"_src_hash\": \"7b98581f7d584be00f92709c0a12498873ea8a9e010b4a4be75e8278892329f8\", \"children\": [{\"_src_hash\": \"a60b8073afc9f92edf83fa06079aa9db6732d90c30f20c92aeceaa5d0e681213\", \"desc\": \"On the [Account Settings → API KEY](https://www.fmz.com/m/account#apikey) page (```/m/account#apikey```), click \\\"Create New ApiKey\\\" to get an ```AccessKey``` and a ```SecretKey```. The ```SecretKey``` carries every permission of the key; keep it secret. The same page lets you change the permissions of existing keys, or disable and delete them.\\n\\n**Permissions**\\n\\nWhen creating or editing a key, enter a comma-separated list in the \\\"API Permissions\\\" field:\\n\\n- ```*```: allow all extended API methods.\\n- Method names: allow only the listed methods, e.g. ```GetRobotList,GetRobotDetail,CommandRobot```.\\n- ```!MethodName```: exclude a method, usually together with ```*```, e.g. ```*,!DeleteRobot,!DeleteNode```.\\n\\nThe same API KEY can also be used for AI Integration (the MCP service, see Integrations → AI Integration). Besides tool names, MCP tools can be authorized by permission category: ```read```, ```backtest```, ```write```, ```trade```, ```danger``` (see the AI Integration page), and ```!name``` excludes as well. Categories only apply to MCP tools; the extended API only recognizes method names and ```*```.\\n\\nWith an empty permission list the extended API does not restrict methods (MCP allows every tool except ```danger```). Grant only what each use needs, e.g. a key used only for TradingView alerts should get ```CommandRobot``` and nothing else.\", \"title\": \"Create ApiKey\"}, {\"_src_hash\": \"520115011d27c776aec3d0054c7a87174b0f21dfb3268ddf13fc2a773d477e66\", \"children\": [{\"_src_hash\": \"6a0c76c5c68177c8eb1766896135016fe3478b9b29b9876f8f76562b0fe4b261\", \"desc\": \"**Request format**\\n\\nSend a ```POST``` request to ```https://www.fmz.com/api/v1``` with the parameters as a form (```application/x-www-form-urlencoded```). The server also accepts the same parameters in the URL query string of a ```GET``` request, but then they end up in access logs along the way, so ```POST``` is recommended.\\n\\n| Parameter | Description |\\n| - | - |\\n| version | Version, always ```1.0```. |\\n| access_key | The ```AccessKey``` of the API KEY. |\\n| method | Method name, e.g. ```GetNodeList```. |\\n| args | Method parameters as a JSON string: an array in parameter order (e.g. ```[]```, ```[123, \\\"ok\\\"]```), or an object keyed by parameter name (e.g. ```{\\\"robotId\\\": 123}```), see Extended API Interface Details. Treated as ```[]``` when omitted. |\\n| nonce | Timestamp in milliseconds. It must be within 1 hour of server time and greater than the ```nonce``` of this API KEY's previous request. |\\n| sign | Signature, computed as described below. |\\n\\nThe request does not contain the ```SecretKey```.\\n\\n**Signature**\\n\\nConcatenate the string below, where ```args``` is the exact JSON string being submitted:\\n\\n```plaintext\\nversion + \\\"|\\\" + method + \\\"|\\\" + args + \\\"|\\\" + nonce + \\\"|\\\" + secretKey\\n```\\n\\nCompute the MD5 of the result and use its 32-character lowercase hexadecimal form as ```sign```.\\n\\n**Python example**\\n\\n```python\\nimport hashlib\\nimport json\\nimport time\\nimport urllib.parse\\nimport urllib.request\\n\\nACCESS_KEY = '' # AccessKey of the API KEY\\nSECRET_KEY = '' # SecretKey of the API KEY\\n\\ndef api(method, *args, **kwargs):\\n d = {\\n 'version': '1.0',\\n 'access_key': ACCESS_KEY,\\n 'method': method,\\n # Positional arguments are sent as an array, keyword arguments as an object (by name)\\n 'args': json.dumps(kwargs if kwargs else list(args)),\\n 'nonce': int(time.time() * 1000),\\n }\\n s = '%s|%s|%s|%d|%s' % (d['version'], d['method'], d['args'], d['nonce'], SECRET_KEY)\\n d['sign'] = hashlib.md5(s.encode('utf-8')).hexdigest()\\n body = urllib.parse.urlencode(d).encode('utf-8')\\n with urllib.request.urlopen('https://www.fmz.com/api/v1', body, timeout=10) as resp:\\n return json.loads(resp.read().decode('utf-8'))\\n\\nprint(api('GetNodeList')) # Docker list\\nprint(api('GetRobotList', appId='member2')) # By name: bots labeled member2\\nprint(api('CommandRobot', 123, 'ok')) # Send an interactive command to bot 123\\nprint(api('GetRobotDetail', 123)) # Details of bot 123\\n```\\n\\n**Go example**\\n\\n```go\\npackage main\\n\\nimport (\\n \\\"crypto/md5\\\"\\n \\\"encoding/hex\\\"\\n \\\"encoding/json\\\"\\n \\\"fmt\\\"\\n \\\"io\\\"\\n \\\"net/http\\\"\\n \\\"net/url\\\"\\n \\\"strconv\\\"\\n \\\"time\\\"\\n)\\n\\nconst (\\n accessKey = \\\"\\\" // AccessKey of the API KEY\\n secretKey = \\\"\\\" // SecretKey of the API KEY\\n baseAPI = \\\"https://www.fmz.com/api/v1\\\"\\n)\\n\\nvar client = &http.Client{Timeout: 10 * time.Second}\\n\\nfunc api(method string, args ...interface{}) (string, error) {\\n if args == nil {\\n args = []interface{}{}\\n }\\n b, err := json.Marshal(args)\\n if err != nil {\\n return \\\"\\\", err\\n }\\n nonce := strconv.FormatInt(time.Now().UnixMilli(), 10)\\n sum := md5.Sum([]byte(\\\"1.0|\\\" + method + \\\"|\\\" + string(b) + \\\"|\\\" + nonce + \\\"|\\\" + secretKey))\\n form := url.Values{\\n \\\"version\\\": {\\\"1.0\\\"},\\n \\\"access_key\\\": {accessKey},\\n \\\"method\\\": {method},\\n \\\"args\\\": {string(b)},\\n \\\"nonce\\\": {nonce},\\n \\\"sign\\\": {hex.EncodeToString(sum[:])},\\n }\\n resp, err := client.PostForm(baseAPI, form)\\n if err != nil {\\n return \\\"\\\", err\\n }\\n defer resp.Body.Close()\\n body, err := io.ReadAll(resp.Body)\\n return string(body), err\\n}\\n\\nfunc main() {\\n ret, err := api(\\\"GetNodeList\\\")\\n fmt.Println(ret, err)\\n\\n // Restart bot 123 with a new configuration; settings fields: see the bot configuration section in Extended API Interface Details\\n settings := map[string]interface{}{\\n \\\"name\\\": \\\"hedge test\\\",\\n \\\"strategy\\\": 456,\\n \\\"period\\\": 60,\\n \\\"node\\\": 789,\\n \\\"exchanges\\\": []interface{}{\\n map[string]interface{}{\\\"pid\\\": 1001, \\\"pair\\\": \\\"BTC_USDT\\\"},\\n },\\n }\\n ret, err = api(\\\"RestartRobot\\\", 123, settings)\\n fmt.Println(ret, err)\\n}\\n```\", \"title\": \"Signature Authentication\"}, {\"_src_hash\": \"84cd9b454df8d97a65aa0199e8e8427cedb19b83266b01ddd6a48d985e769b72\", \"desc\": \"Direct verification computes no signature; the ```secret_key``` is put into the request parameters instead. This produces a fixed URL that can be entered into webhooks such as TradingView that accept only a single URL.\\n\\n> **Security note**: a ```secret_key``` in a URL ends up in browser history, proxy and server access logs, and the webhook provider's configuration; anyone who obtains the URL can call the API with this key's permissions. Use direct verification only for ```CommandRobot``` webhooks, and create a dedicated API KEY for it that is granted ```CommandRobot``` only (see Create ApiKey). If it leaks, delete that API KEY immediately.\\n\\nThe request parameters are ```access_key```, ```secret_key```, ```method``` and ```args``` (a JSON array, URL-encoded); ```version```, ```nonce``` and ```sign``` are not needed. ```CommandRobot``` skips the ```nonce``` check; other methods are still checked: without a ```nonce``` the server uses the current time (to the second), so a second call within the same second returns a nonce error (```code``` 3).\\n\\nFor example, with an API KEY whose ```AccessKey``` is ```xxx``` and ```SecretKey``` is ```yyy```, opening the URL below sends the interactive command ```ok12345``` to the live trading bot with ID ```186515```:\\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**Receiving a webhook body**\\n\\nWhen the command argument of ```CommandRobot``` is an empty string and the request is a ```POST```, the server sends the request body to the bot as the interactive command. For example, set the TradingView webhook URL to:\\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\\nThe ```args``` value ```%5B186515%2C+%22%22%5D``` decodes to ```[186515, \\\"\\\"]``` (```+``` is a URL-encoded space): ```186515``` is the bot ID and the command is an empty string.\\n\\nSimulating a TradingView webhook alert:\\n\\n```js\\nfunction main() {\\n var options = {\\n method: \\\"POST\\\",\\n body: `{\\\"test\\\": 123}`,\\n headers: {\\\"Content-Type\\\": \\\"application/json\\\"}\\n }\\n\\n // A webhook alert sends a POST request with the required headers automatically\\n return HttpQuery(\\\"https://www.fmz.com/api/v1?access_key=xxx&secret_key=yyy&method=CommandRobot&args=%5B186515%2C+%22%22%5D\\\", options)\\n}\\n```\\n\\nThe content of the TradingView alert message box is the request body:\\n\\n- JSON format:\\n\\n ![](https://www.fmz.com/upload/asset/16d8a37ef80d9ccd0079.png)\\n\\n ```plaintext\\n {\\\"close\\\": {{close}}, \\\"name\\\": \\\"aaa\\\"}\\n ```\\n\\n The bot with ID ```186515``` receives the interactive command ```{\\\"close\\\": 39773.75, \\\"name\\\": \\\"aaa\\\"}```.\\n\\n- Text format:\\n\\n ![](https://www.fmz.com/upload/asset/16d8a506dfbb6c60a077.png)\\n\\n ```plaintext\\n BTCUSDTPERP Crossing 39700.00 close: {{close}}\\n ```\\n\\n The bot with ID ```186515``` receives the interactive command ```BTCUSDTPERP Crossing 39700.00 close: 39739.4```.\\n\\n**Python and Go examples**\\n\\n```python\\nimport json\\nimport urllib.parse\\nimport urllib.request\\n\\nACCESS_KEY = '' # AccessKey of an API KEY granted CommandRobot only\\nSECRET_KEY = '' # SecretKey\\n\\ndef api(method, *args):\\n query = urllib.parse.urlencode({\\n 'access_key': ACCESS_KEY,\\n 'secret_key': SECRET_KEY,\\n 'method': method,\\n 'args': json.dumps(list(args)),\\n })\\n with urllib.request.urlopen('https://www.fmz.com/api/v1?' + query, timeout=10) as resp:\\n return json.loads(resp.read().decode('utf-8'))\\n\\n# Without permission for the method the result is {'code': 4, 'data': None}\\nprint(api('CommandRobot', 186515, 'ok12345'))\\n```\\n\\n```go\\npackage main\\n\\nimport (\\n \\\"encoding/json\\\"\\n \\\"fmt\\\"\\n \\\"io\\\"\\n \\\"net/http\\\"\\n \\\"net/url\\\"\\n \\\"time\\\"\\n)\\n\\nconst (\\n accessKey = \\\"\\\" // AccessKey of an API KEY granted CommandRobot only\\n secretKey = \\\"\\\" // SecretKey\\n baseAPI = \\\"https://www.fmz.com/api/v1\\\"\\n)\\n\\nvar client = &http.Client{Timeout: 10 * time.Second}\\n\\nfunc api(method string, args ...interface{}) (string, error) {\\n if args == nil {\\n args = []interface{}{}\\n }\\n b, err := json.Marshal(args)\\n if err != nil {\\n return \\\"\\\", err\\n }\\n q := url.Values{\\n \\\"access_key\\\": {accessKey},\\n \\\"secret_key\\\": {secretKey},\\n \\\"method\\\": {method},\\n \\\"args\\\": {string(b)},\\n }\\n resp, err := client.Get(baseAPI + \\\"?\\\" + q.Encode())\\n if err != nil {\\n return \\\"\\\", err\\n }\\n defer resp.Body.Close()\\n body, err := io.ReadAll(resp.Body)\\n return string(body), err\\n}\\n\\nfunc main() {\\n ret, err := api(\\\"CommandRobot\\\", 186515, \\\"ok12345\\\")\\n fmt.Println(ret, err)\\n}\\n```\\n\\nReferences:\\n\\n- [Trading on TradingView alert signals with the FMZ extended API](https://www.fmz.com/digest-topic/5533)\\n- [Trading on TradingView alert signals with the FMZ extended API (video, Bilibili)](https://www.bilibili.com/video/BV1Wk4y1k7zz/)\", \"title\": \"Direct Verification\"}], \"desc\": \"The extended API supports two authentication methods:\\n\\n- Signature authentication: the request parameters are signed with the ```SecretKey```, which itself never travels over the network. Programs should use this method.\\n- Direct verification: the ```SecretKey``` is put into the request URL itself; meant for webhooks such as TradingView that accept only a single URL.\", \"title\": \"Authentication Methods\"}, {\"_src_hash\": \"3ff6c0aa1984e827377c05bae8c74acca74925bfbac0b8efb7c853f68fea3f4d\", \"children\": [{\"_src_hash\": \"f939c7a3be2d90843ede06cfcb0b50b30e9a1491eab08b2930a3605c1834d73e\", \"args\": \"No parameters\", \"desc\": [\"The ```GetAccount``` method is used to retrieve account information for the FMZ Quant Trading Platform account corresponding to the ```API KEY``` in the request.\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":{\\n \\\"balance\\\":22944702436,\\n \\\"concurrent\\\":0,\\n \\\"consumed\\\":211092719653,\\n \\\"email\\\":\\\"123@qq.com\\\",\\n \\\"openai\\\":false,\\n \\\"settings\\\":null,\\n \\\"sns\\\":{\\\"wechat\\\":true},\\n \\\"uid\\\":\\\"105ea6e51bcc177926a10fdbb7e2a1d6\\\",\\n \\\"username\\\":\\\"abc\\\"\\n },\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- balance: Account balance in USD, stored as an integer for precision; divide by 1e8 (10 to the power of 8) to get the actual value, 229.44702436 in this example.\\n- consumed: Total amount spent, same unit and conversion as ```balance```.\", \"title\": \"GetAccount\"}, {\"_src_hash\": \"33a31d2618fcd4073d0e3c4349ddc3669c6adc3213577b5f845d65d3241611d2\", \"args\": [{\"info\": \"Paging offset, default 0.\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"Page size; omitted or less than or equal to 0 returns everything.\", \"name\": \"limit\", \"required\": false, \"type\": \"number\"}], \"desc\": [\"The ```GetNodeList``` method returns the dockers available to the platform account of the ```API KEY``` in the request, including your own dockers and the platform's public dockers.\"], \"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\\nReturn value field descriptions (fields with obvious literal meanings are not elaborated):\\n- all: Total number of dockers (public dockers included).\\n- nodes: List of detailed information for docker nodes.\\n - build: Version number.\\n - city: City location.\\n - is_owner: true indicates private docker, false indicates public docker.\\n - loaded: Load amount, i.e., the number of currently running strategy instances.\\n - public: 0 indicates private docker, 1 indicates public docker.\\n - region: Geographic location.\\n - version: Detailed version information of the docker.\\n - wd: Offline alarm switch, 0 indicates not enabled.\\n\\nOne-click deployed dockers contain additional information, with related fields prefixed by ```ecs_``` and ```unit_```, recording information about the one-click deployed docker server (operator name, configuration, status, etc.), billing cycle, price, and other information, which will not be detailed here.\", \"title\": \"GetNodeList\"}, {\"_src_hash\": \"6574b45c01e1f74ef7d93340a798b4f1a90e73521f14638a1557850aee83d25d\", \"args\": [{\"info\": \"The ```nid``` parameter is used to specify the docker ID to be deleted. You can obtain the docker information under the account through the ```GetNodeList``` method.\", \"name\": \"nid\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"The ```DeleteNode``` method is used to delete a docker node under the FMZ Quant Trading Platform account corresponding to the ```API KEY``` in the request. The docker node ID to be deleted is specified by the ```nid``` parameter.\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":true,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: Whether the associated docker program was successfully deleted.\", \"title\": \"DeleteNode\"}, {\"_src_hash\": \"1c1bb082cea49fe67719ef42f6e0c86bbc5ebb315fb51806edd58787cff08f0c\", \"args\": [{\"info\": \"The ```isSummary``` parameter is used to specify whether the returned data is summary information.\", \"name\": \"isSummary\", \"required\": true, \"type\": \"bool\"}], \"desc\": [\"The ```GetExchangeList``` method is used to get the list of exchanges supported by the FMZ quantitative trading platform and their configuration information.\"], \"isChildren\": true, \"returns\": \"When the ```isSummary``` parameter is ```false```, the returned data:\\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\\nWhen the ```isSummary``` parameter is ```true```, the returned data:\\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: Exchange configuration metadata.\", \"title\": \"GetExchangeList\"}, {\"_src_hash\": \"0cc6ccb96239c72e3190299428381150cc8d0dbac7ec9faea0baa31fde2fb114\", \"args\": [{\"info\": \"Paging offset, default 0.\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"Page size; omitted or less than or equal to 0 returns everything.\", \"name\": \"limit\", \"required\": false, \"type\": \"number\"}], \"desc\": [\"The ```GetPlatformList``` method is used to get the list of configured exchanges under the FMZ Quant Trading Platform account corresponding to the ```API KEY``` in the request.\"], \"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: Total number of configured exchange objects.\\n- platforms: Exchange related information.\\n - eid: Exchange identifier on the FMZ Quant Trading Platform, ```eid``` is required in certain configurations and parameters.\", \"title\": \"GetPlatformList\"}, {\"_src_hash\": \"4fc22681ff55b9e970c2bdb8d88723673b77d955dba8bfd5c9f83873eb15fd4a\", \"args\": [{\"info\": \"Paging offset.\", \"name\": \"offset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Page size; less than or equal to 0 returns everything.\", \"name\": \"length\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Scope of the query:\\n- ```-1```: your own and rented strategies (official strategies included).\\n- ```0```: your own and rented strategies (official strategies excluded).\\n- ```-3```: only your own strategies.\\n- ```-6```: only rented strategies (expired ones included).\\n- ```-4```: official strategies.\\n- ```-2```: public and paid strategies in the Strategy Square.\\n- ```1```: published strategies.\\n- ```2```: strategies pending review.\", \"name\": \"strategyType\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Strategy type:\\n- ```-1```: all.\\n- ```0```: ordinary strategies.\\n- ```20```: template libraries.\\n- ```21```: trading plugins.\", \"name\": \"category\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Programming language of the strategy:\\n- ```-1```: all languages.\\n- ```0```: JavaScript (TypeScript strategies are stored as JavaScript with a ```//@ts-check``` line in the source).\\n- ```1```: Python.\\n- ```3```: Blockly.\\n- ```4```: MyLanguage.\\n- ```5```: PINE.\\n- ```6```: Workflow.\\n- ```7```: Rust.\", \"name\": \"language\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Keywords matched against strategy names, separated by spaces; an empty string means no filter. Starting with ```id:``` queries by strategy ID, e.g. ```id:123,456```.\", \"name\": \"kw\", \"required\": true, \"type\": \"string\"}, {\"info\": \"Strategy group: ```-1``` all (default), ```0``` ungrouped, greater than 0 a specific group. Only applies to your own strategies.\", \"name\": \"groupId\", \"required\": false, \"type\": \"number\"}, {\"info\": \"Sort field: ```name```, ```last_modified```, ```date```, optionally followed by ``` asc``` for ascending order (default descending); an empty string keeps the default order.\", \"name\": \"orderBy\", \"required\": false, \"type\": \"string\"}], \"desc\": [\"The ```GetStrategyList``` method is used to retrieve platform strategy information.\"], \"isChildren\": true, \"remarks\": [\"There is no ```needArgs``` parameter. Passing an extra parameter after ```category```, as older documentation did, shifts all following parameters; pass them in the order above, or by name:\\n\\n```plaintext\\napi('GetStrategyList', 0, 10, -3, -1, -1, '') # first 10 of your own strategies\\napi('GetStrategyList', strategyType=-3, language=7) # all of your own Rust strategies\\n```\"], \"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\\\": 0,\\n \\\"last_modified\\\": \\\"2024-11-11 17:23:52\\\",\\n \\\"name\\\": \\\"HedgeGridStrategy\\\",\\n \\\"profile\\\": {\\n \\\"avatar\\\": \\\"...\\\",\\n \\\"nickname\\\": \\\"abc\\\",\\n \\\"uid\\\": \\\"4ed225440db1eda23fe05ed10184113e\\\"\\n },\\n \\\"public\\\": 0,\\n \\\"tags\\\": \\\"\\\",\\n \\\"uid\\\": \\\"4ed225440db1eda23fe05ed10184113e\\\",\\n \\\"username\\\": \\\"abc\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- all: Total number of strategies matching the filter criteria.\\n- strategies: Detailed information of the strategies found; ```category``` and ```language``` take the values described in the parameters above.\", \"title\": \"GetStrategyList\"}, {\"_src_hash\": \"6c47ca726b1a25f4333a0f737017fde3c1e8a8c1d62e7f275aa14cb711ead40a\", \"args\": \"No parameters\", \"desc\": [\"The ```GetRobotGroupList``` method is used to get the list of live trading groups under the FMZ Quant Trading Platform account corresponding to the ```API KEY``` in the request.\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": {\\n \\\"items\\\": [{\\n \\\"id\\\": 3417,\\n \\\"name\\\": \\\"Test\\\"\\n }, {\\n \\\"id\\\": 3608,\\n \\\"name\\\": \\\"Live Trading Demo\\\"\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- items: Live trading group information.\\n - id: Live trading group ID.\\n - name: Live trading group name.\\n\\nThe ```items``` field only records newly created groups, the \\\"Default\\\" group is not included in ```items```.\", \"title\": \"GetRobotGroupList\"}, {\"_src_hash\": \"639225639d69f048b7f867490748f40aeec47381f744f9141104d112508504a9\", \"args\": [{\"info\": \"Paging offset, default 0.\", \"name\": \"offset\", \"required\": false, \"type\": \"number\"}, {\"info\": \"Page size; less than or equal to 0 returns everything (default).\", \"name\": \"length\", \"required\": false, \"type\": \"number\"}, {\"info\": \"Filter by live trading status code, see Live Trading Status Codes; ```-1``` returns all bots (default), ```-2``` returns all bots sorted by start time.\", \"name\": \"customStatus\", \"required\": false, \"type\": \"number\"}, {\"info\": \"Filter by the bot's custom label (```appid``` in ```settings``` when it was created); an empty string means no filter.\", \"name\": \"appId\", \"required\": false, \"type\": \"string\"}, {\"info\": \"Keyword matched against bot names; an empty string means no filter.\", \"name\": \"kw\", \"required\": false, \"type\": \"string\"}, {\"info\": \"Live trading group: ```-1``` all (default), ```0``` ungrouped, greater than 0 a specific group.\", \"name\": \"groupId\", \"required\": false, \"type\": \"number\"}, {\"info\": \"Sort field: ```name```, ```status```, ```node```, ```profit```, ```date```, ```refresh```, ```start_time```, ```strategy_name```, optionally followed by ``` asc``` for ascending order (default descending); an empty string keeps the default order.\", \"name\": \"orderBy\", \"required\": false, \"type\": \"string\"}, {\"info\": \"When greater than 0, only bots of this strategy are returned; default 0 (no filter).\", \"name\": \"strategyId\", \"required\": false, \"type\": \"number\"}], \"desc\": [\"The ```GetRobotList``` method returns the live trading bots of the platform account of the ```API KEY``` in the request. All parameters are optional.\"], \"isChildren\": true, \"remarks\": [\"Using ```api()``` from the Python example on the signature authentication page:\\n\\n- ```api('GetRobotList')```: all live trading bots.\\n- ```api('GetRobotList', 'member2')```: a single string is taken as the label; all bots labeled member2.\\n- ```api('GetRobotList', 0, 100, -1, 'member2', '')```: positional parameters; up to 100 bots labeled member2, starting at offset 0.\\n- ```api('GetRobotList', appId='member2', length=100)```: the same by parameter name.\"], \"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\\\": \\\"Test\\\",\\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\\\": \\\"Test\\\",\\n \\\"strategy_public\\\": 0,\\n \\\"uid\\\": \\\"105ed6e511cc977921610fdbb7e2a1d6\\\",\\n \\\"wd\\\": 0\\n }]\\n },\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n- all: Total number of bots matching the filters.\\n- robots: Live trading bot information; ```status``` is the live trading status code.\\n - group_id: Live trading bot group ID; if the live trading bot is in the default group, the ```group_id``` field is not included.\", \"title\": \"GetRobotList\"}, {\"_src_hash\": \"09cd05a7fbc0674f6150c259bfc21b2c0dcfa8113d66d796f3aab56693fe754a\", \"args\": [{\"info\": \"The ```robotId``` parameter is used to specify the ID of the live trading bot for which to retrieve detailed information. The live trading bot information under the account, including the bot ID, can be obtained through the ```GetRobotList``` method.\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"The ```GetRobotDetail``` method is used to get detailed information of a live trading bot under the FMZ Quant Trading Platform account corresponding to the ```API KEY``` in the request. The detailed information of the live trading bot to be retrieved is specified by the ```robotId``` parameter.\"], \"isChildren\": true, \"remarks\": [\"Explanation of the ```strategy_exchange_pairs``` attribute, using the following data as an example:\\n\\n```plaintext\\n\\\"[60,[44314,42960,15445,14703],[\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\"]]\\\"\\n```\\n\\nThe first data ```60``` indicates that the default K-line period set for the live trading bot is 1 minute, i.e., 60 seconds.\\n\\n```[44314,42960,15445,14703]``` are the ```pid``` values of the exchange objects configured for the live trading bot (arranged in the order they were added).\\n\\n```[\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"BTC_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\",\\\\\\\"ETH_USDT\\\\\\\"]``` are the trading pairs set for the exchange objects configured for the live trading bot (corresponding one-to-one with the pid values in the order they were added).\"], \"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\\\": \\\"Test\\\",\\n \\\"node_id\\\": 123,\\n \\\"pexchanges\\\": {\\n \\\"123\\\": \\\"Futures_OKX\\\"\\n },\\n \\\"phash\\\": {\\n \\\"123\\\": \\\"ca1aca74b9cf7d8624f2af2dac01e36d\\\"\\n },\\n \\\"plabels\\\": {\\n \\\"123\\\": \\\"OKX Futures\\\"\\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\\\": \\\"Test\\\",\\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: Next billing time (Unix timestamp in seconds), i.e. the end of the period already paid for.\\n- charged: Total billed time in seconds.\\n- consumed: Total amount charged in USD, stored as an integer scaled by 1e8; 5375000000 in the example is 53.75 USD.\\n- date: Creation date.\\n- fixed_id: Docker ID assigned during live trading. If auto-assigned, this value is -1.\\n- is_manager: Whether has permission to manage this live trading bot.\\n- is_sandbox: Whether it is a simulated trading bot.\\n- name: Live trading bot name.\\n- node_id: Docker ID.\\n- pexchanges: Exchange objects configured for the live trading bot, where 123 is the pid and \\\"Futures_OKX\\\" is the exchange ID (eid).\\n- plabels: Label information for the exchange objects configured for the live trading bot.\\n- profit: Live trading bot profit data.\\n- public: Whether the live trading bot is public.\\n- refresh: Last active time.\\n- strategy_exchange_pairs: Configured exchange objects and their trading pair information.\\n- wd: Whether offline alert is enabled.\", \"title\": \"GetRobotDetail\"}, {\"_src_hash\": \"2ab8cb45f46e27f899017babd236368395a8e47d1a1653f1129cb7c54f71ce79\", \"args\": [{\"info\": \"The ```robotId``` parameter is used to specify the live trading ID for which to get log information. You can use the ```GetRobotList``` method to get the live trading information under the account, which includes the live trading ID.\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```logMinId``` parameter is used to specify the minimum ID of log records.\", \"name\": \"logMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```logMaxId``` parameter is used to specify the maximum ID of log records.\", \"name\": \"logMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```logOffset``` parameter is used to set the offset. Within the range determined by ```logMinId``` and ```logMaxId```, skip the specified number of records according to ```logOffset``` to determine the starting position for data retrieval.\", \"name\": \"logOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```logLimit``` parameter is used to set the number of data records to retrieve starting from the initial position.\", \"name\": \"logLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```profitMinId``` parameter is used to set the minimum ID of profit logs.\", \"name\": \"profitMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```profitMaxId``` parameter is used to set the maximum ID of profit logs.\", \"name\": \"profitMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```profitOffset``` parameter is used to set the offset, i.e., skip the specified number of records as the starting position.\", \"name\": \"profitOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```profitLimit``` parameter is used to set the number of data records to retrieve starting from the initial position.\", \"name\": \"profitLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```chartMinId``` parameter is used to set the minimum ID of chart data records.\", \"name\": \"chartMinId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```chartMaxId``` parameter is used to set the maximum ID of chart data records.\", \"name\": \"chartMaxId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```chartOffset``` parameter is used to set the offset.\", \"name\": \"chartOffset\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```chartLimit``` parameter is used to set the number of records to retrieve.\", \"name\": \"chartLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```chartUpdateBaseId``` parameter is used to set the base ID for querying update records.\", \"name\": \"chartUpdateBaseId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```chartUpdateDate``` parameter is used to set the update timestamp of data records, and the system will filter out records greater than this timestamp.\", \"name\": \"chartUpdateDate\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The ```summaryLimit``` parameter is used to set the number of bytes of status bar data to query. This parameter is an integer used to query the status bar data of live trading.\\n\\nSetting it to 0 means not querying status bar information; setting it to a non-zero value indicates the number of bytes of status bar information to query (this interface does not limit the amount of data, you can specify a larger summaryLimit parameter to get all status bar information). The status bar data is stored in the ```summary``` field of the returned data.\", \"name\": \"summaryLimit\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Only logs of this exchange object (by label); an empty string means no filter.\", \"name\": \"logExchange\", \"required\": false, \"type\": \"string\"}, {\"info\": \"Only logs whose content contains this keyword; an empty string means no filter.\", \"name\": \"logKeyword\", \"required\": false, \"type\": \"string\"}, {\"info\": \"Only logs of these types, as comma-separated log type numbers, e.g. ```\\\"0,1,2\\\"``` for buy, sell and cancel logs; an empty string means all types.\", \"name\": \"logTypes\", \"required\": false, \"type\": \"string\"}], \"desc\": [\"The ```GetRobotLogs``` method is used to get the live trading log information under the FMZ Quant Trading Platform account corresponding to the ```API KEY``` in the request. The live trading ID for which to get log information is specified by the ```robotId``` parameter.\"], \"isChildren\": true, \"remarks\": [\"- Strategy log table in database\\n The description of the ```Arr``` attribute value in the first element (log data) of the ```logs``` attribute value (array structure) in the returned data is as follows:\\n\\n ```plaintext\\n \\\"Arr\\\": [\\n [3977, 3, \\\"Futures_OKX\\\", \\\"\\\", 0, 0, \\\"Sell(688.9, 2): 20016\\\", 1526954372591, \\\"\\\", \\\"\\\"],\\n [3976, 5, \\\"\\\", \\\"\\\", 0, 0, \\\"this_week Position too large, long: 2\\\", 1526954372410, \\\"\\\", \\\"\\\"]\\n ],\\n ```\\n\\n | id | logType | eid | orderId | price | amount | extra | date | contractType | direction |\\n | - | - | - | - | - | - | - | - | - | - |\\n | 3977 | 3 | \\\"Futures_OKX\\\" | \\\"\\\" | 0 | 0 | \\\"Sell(688.9, 2): 20016\\\" | 1526954372591 | \\\"\\\" | \\\"\\\" |\\n | 3976 | 5 | \\\"\\\" | \\\"\\\" | 0 | 0 | \\\"this_week Position too large, long: 2\\\" | 1526954372410 | \\\"\\\" | \\\"\\\" |\\n\\n ```extra``` is the additional information for the printed log.\\n\\n The log type descriptions corresponding to ```logType``` values are as follows:\\n\\n | logType: | 0 | 1 | 2 | 3 | 4 | 5 | 6 |\\n | - | - | - | - | - | - | - | - |\\n | logType meaning: | BUY | SALE | RETRACT | ERROR | PROFIT | MESSAGE | RESTART |\\n | English meaning | Buy order log | Sell order log | Cancel order | Error | Profit | Message | Restart |\\n\\n- Profit chart log table in database\\n The data in this chart log table is consistent with the profit logs in the strategy log table.\\n\\n ```plaintext\\n \\\"Arr\\\": [\\n [202, 2515.44, 1575896700315],\\n [201, 1415.44, 1575896341568]\\n ]\\n ```\\n\\n Taking one log data as an example:\\n\\n ```plaintext\\n [202, 2515.44, 1575896700315]\\n ```\\n\\n ```202``` is the log ID, ```2515.44``` is the profit value, ```1575896700315``` is the timestamp.\\n- Chart log table in database\\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 Taking one log data as an example:\\n\\n ```plaintext\\n [23637, 0, \\\"{\\\\\\\"close\\\\\\\":648,\\\\\\\"high\\\\\\\":650.5,\\\\\\\"low\\\\\\\":647,\\\\\\\"open\\\\\\\":650,\\\\\\\"x\\\\\\\":1575960300000}\\\"],\\n ```\\n\\n ```23637``` is the log ID, ```0``` is the chart data series index, and the final data ```\\\"{\\\\\\\"close\\\\\\\":648,\\\\\\\"high\\\\\\\":650.5,\\\\\\\"low\\\\\\\":647,\\\\\\\"open\\\\\\\":650,\\\\\\\"x\\\\\\\":1575960300000}\\\"``` is the log data, which is the K-line data on the chart.\"], \"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: Log information; the queried log data entries are stored in the Arr field.\\n The first data structure in logs contains log records from the strategy log table in the live trading database.\\n The second data structure in logs contains log records from the profit log table in the live trading database.\\n The third data structure in logs contains log records from the chart log table in the live trading database.\\n- summary: Live trading status bar data.\", \"title\": \"GetRobotLogs\"}, {\"_src_hash\": \"2fe229be22cf6b6fece47bdec5a97c97051fc82d9c7ea63403513b7eb45990c2\", \"args\": [{\"info\": \"Live trading configuration; for its fields see \\\"Live trading configuration (settings)\\\" in Extended API Interface Details. For example:\\n\\n```json\\n{\\n \\\"name\\\": \\\"test\\\",\\n \\\"strategy\\\": 123,\\n \\\"args\\\": [],\\n \\\"exchanges\\\": [\\n {\\\"pid\\\": 123, \\\"pair\\\": \\\"SOL_USDT\\\"}\\n ],\\n \\\"period\\\": 60,\\n \\\"node\\\": 123,\\n \\\"group\\\": 123,\\n \\\"appid\\\": \\\"test\\\"\\n}\\n```\", \"name\": \"settings\", \"required\": true, \"type\": \"JSON object\"}], \"desc\": [\"The ```NewRobot``` method creates a live trading bot under the platform account of the ```API KEY``` in the request and starts it; like creating a bot on the website, this charges fees.\"], \"isChildren\": true, \"remarks\": [\"When the exchange configuration is passed directly with ```eid```, the platform does not store the keys in ```meta```, so every later ```RestartRobot``` of this bot must pass ```settings``` again.\"], \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":591988,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: The ID of the new bot on success; a negative number on failure, with the meaning of the abnormal codes in Live Trading Status Codes (e.g. ```-2``` no docker found, ```-5``` insufficient balance).\", \"title\": \"NewRobot\"}, {\"_src_hash\": \"2ccdec24b92a2e89533f5d8635f599ef2a6d559837bd61158702d5b0a227d7d0\", \"args\": [{\"info\": \"Live trading bot ID, see the ```GetRobotList``` method.\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Live trading configuration; for its fields see \\\"Live trading configuration (settings)\\\" in Extended API Interface Details. When given, the bot's configuration (name, parameters, exchanges, K-line period, docker, group) is updated with it before starting; the strategy cannot be changed.\", \"name\": \"settings\", \"required\": false, \"type\": \"JSON object\"}], \"desc\": [\"The ```RestartRobot``` method starts (restarts) a live trading bot of the platform account of the ```API KEY``` in the request; the bot is given by ```robotId```. Starting a bot charges fees.\"], \"isChildren\": true, \"remarks\": [\"A bot created on the website with exchange accounts referenced by ```pid``` can be started with ```robotId``` alone, using its current configuration. A bot whose exchanges were passed directly with ```eid``` (usually created through the extended API) has no stored keys, so ```settings``` must be passed on every restart.\"], \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":1,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: Live trading status code, 1 indicates running.\", \"title\": \"RestartRobot\"}, {\"_src_hash\": \"70a2c804a9588410a65d6093fd2924a5f82651cfe79aca9f122734099dd391a6\", \"args\": [{\"info\": \"The ```robotId``` parameter is used to specify the bot Id to be stopped. You can obtain the bot information under the account through the ```GetRobotList``` method, which includes the bot Id.\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}], \"desc\": [\"The ```StopRobot``` method is used to stop a live trading bot under the FMZ Quant Trading Platform account corresponding to the ```API KEY``` in the request. The bot Id to be stopped is specified by the ```robotId``` parameter.\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":2,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: Bot status code, 2 indicates stopping.\", \"title\": \"StopRobot\"}, {\"_src_hash\": \"22b48c2074f43dc043ac01bc3d15544d0a36330d6e5292df9f08463803e18c1a\", \"args\": [{\"info\": \"The ```robotId``` parameter is used to specify the bot Id that receives the interactive command. You can use the ```GetRobotList``` method to get information about bots under the account, which includes the bot Id.\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"The interactive command sent to the bot; the strategy reads it with ```GetCommand()```, see {@fun/Global/GetCommand GetCommand}.\", \"name\": \"cmd\", \"required\": true, \"type\": \"string\"}], \"desc\": [\"The ```CommandRobot``` method is used to send interactive commands to a live trading bot under the FMZ Quant Trading Platform account corresponding to the ```API KEY``` in the request. The bot Id that receives the interactive command is specified by the ```robotId``` parameter, and the interactive command is captured and returned by the ```GetCommand()``` function called in the strategy.\"], \"isChildren\": true, \"remarks\": [\"Example of bot strategy (assuming this strategy bot is running with bot 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\\nCalling ```api(\\\"CommandRobot\\\", 123, \\\"test command\\\")``` with ```api()``` from the Python example on the signature authentication page, the bot with Id 123 will receive the interactive command: ```test command```, and output it through the Log function.\"], \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":true,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: Whether the interactive command was sent successfully. When sending a command to a bot that is not running, the result in the returned data will be false.\", \"title\": \"CommandRobot\"}, {\"_src_hash\": \"2a302ff84ae64550fb5a521d2d2ce496c5ad626788ef06d9058ed6c9a64f9d20\", \"args\": [{\"info\": \"ID of the bot to delete, see the ```GetRobotList``` method.\", \"name\": \"robotId\", \"required\": true, \"type\": \"number\"}, {\"info\": \"Whether to delete the bot's log data on the docker as well; default ```true```.\", \"name\": \"removeLog\", \"required\": false, \"type\": \"bool\"}], \"desc\": [\"The ```DeleteRobot``` method deletes a live trading bot of the platform account of the ```API KEY``` in the request; the bot is given by ```robotId```. A running bot must be stopped first. Deletion cannot be undone.\"], \"isChildren\": true, \"returns\": \"```json\\n{\\n \\\"code\\\":0,\\n \\\"data\\\":{\\n \\\"result\\\":0,\\n \\\"error\\\":null\\n }\\n}\\n```\\n\\n- result: Result of the deletion.\\n - 0: deleted.\\n - -1: not deleted: the bot does not exist, or it is still running, starting or stopping.\\n - -2: the bot was deleted, but its docker could not be reached, so the log data was not removed; delete it manually under ```logs/storage//``` in the docker's directory (e.g. ```123.db3```).\", \"title\": \"DeleteRobot\"}, {\"_src_hash\": \"647d749c4736095bd9bfd9c32ba4a5f7998ea28e1475bf53dd0e7ea90f5e182f\", \"args\": [{\"info\": \"Run configuration, for example:\\n\\n```json\\n{\\n \\\"source\\\": \\\"function main() {Log(\\\\\\\"Hello FMZ\\\\\\\")}\\\",\\n \\\"node\\\": 123,\\n \\\"period\\\": 60,\\n \\\"exchanges\\\": [{\\\"pid\\\": 123, \\\"pair\\\": \\\"SOL_USDT\\\"}]\\n}\\n```\\n\\n- source: the code to run. The entry point is ```main()```, whose return value is the result.\\n- strategy: when ```source``` is not given, run the account's strategy with this ID (e.g. a trading plugin).\\n- node: ID of the docker that runs the code; omitted or ```-1``` selects one automatically.\\n- exchanges: exchange object configuration, same as \\\"Live trading configuration (settings)\\\" in Extended API Interface Details.\", \"name\": \"settings\", \"required\": true, \"type\": \"JSON object\"}], \"desc\": [\"The ```PluginRun``` method runs a piece of JavaScript code on a docker and returns the result. It uses the same execution mechanism as the \\\"Debug Tool\\\" among the development tools and trading terminal plugins (see Integrations → Trading Terminal → Plugin Principle and Development). No live trading bot is created and nothing is charged; one run lasts at most 5 minutes.\"], \"isChildren\": true, \"remarks\": [\"```exchanges``` can also pass the exchange configuration directly instead of referencing an exchange account on the platform, for example:\\n\\n```plaintext\\n{\\\"eid\\\": \\\"Binance\\\", \\\"pair\\\": \\\"ETH_BTC\\\", \\\"meta\\\": {\\\"AccessKey\\\": \\\"...\\\", \\\"SecretKey\\\": \\\"...\\\"}}\\n```\\n\\nThe field names of ```meta``` are given by the ```meta``` returned by ```GetExchangeList```. Usually only one exchange object is set in ```exchanges``` (the debug tool page also supports only one); setting two causes no error, but accessing the second exchange object in the code does.\"], \"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: The result as a JSON string: ```logs``` holds the logs written with ```Log()```, ```result``` the JSON text of the value returned by ```main()```.\", \"title\": \"PluginRun\"}], \"desc\": \"All methods are called through ```https://www.fmz.com/api/v1```; for the request format and signature see Authentication Methods → Signature Authentication, for the response structure and error codes see Extended API Interface Return Codes. The ```api()``` used in the examples on the method pages is the function from the Python example on the signature authentication page.\\n\\n**Method overview**\\n\\n| Object | Method | Parameters (in order; bracketed ones may be omitted) | Description | Notes |\\n| - | - | - | - | - |\\n| Account | GetAccount | none | Account information | Read-only |\\n| Docker | GetNodeList | [offset, limit] | Docker list | Read-only |\\n| Docker | DeleteNode | nid | Delete a docker | Deletes, cannot be undone |\\n| Exchange | GetExchangeList | isSummary | Exchanges supported by the platform and their settings | Read-only |\\n| Exchange | GetPlatformList | [offset, limit] | Exchange accounts you added | Read-only |\\n| Strategy | GetStrategyList | offset, length, strategyType, category, language, kw[, groupId, orderBy] | Strategy list | Read-only |\\n| Live trading | GetRobotGroupList | none | Live trading groups | Read-only |\\n| Live trading | GetRobotList | [offset, length, customStatus, appId, kw, groupId, orderBy, strategyId] | Live trading list | Read-only |\\n| Live trading | GetRobotDetail | robotId | Live trading details | Read-only |\\n| Live trading | GetRobotLogs | robotId, logMinId, …, summaryLimit[, logExchange, logKeyword, logTypes] | Logs, profit, chart and status bar data | Read-only |\\n| Live trading | NewRobot | settings | Create and start a live trading bot | Charges fees; the bot trades for real |\\n| Live trading | RestartRobot | robotId[, settings] | Start (restart) a live trading bot | Charges fees; the bot trades for real |\\n| Live trading | StopRobot | robotId | Stop a live trading bot | Does not close positions |\\n| Live trading | CommandRobot | robotId, cmd | Send an interactive command | The strategy may place orders on it |\\n| Live trading | DeleteRobot | robotId[, removeLog] | Delete a live trading bot | Deletes, cannot be undone |\\n| Debugging | PluginRun | settings | Run a piece of code on a docker | The code can place real orders |\\n\\nThe API KEY needs permission for the method, see Create ApiKey.\\n\\n**Passing parameters**\\n\\n```args``` can be written in two ways:\\n\\n- Array: positional parameters in the order of the table above, e.g. ```[123, \\\"ok\\\"]```.\\n- Object: values by parameter name, e.g. ```{\\\"robotId\\\": 123, \\\"cmd\\\": \\\"ok\\\"}```. Names are case-insensitive and underscores are ignored; omitted parameters take their defaults. Recommended for methods with many optional parameters (GetRobotList, GetRobotLogs, GetStrategyList).\\n\\n**Live trading configuration (settings)**\\n\\nThe ```settings``` parameter of NewRobot, RestartRobot and PluginRun is a JSON object; common fields:\\n\\n| Field | Description |\\n| - | - |\\n| name | Name of the live trading bot. |\\n| strategy | Strategy ID, see GetStrategyList. RestartRobot cannot change a bot's strategy. |\\n| args | Strategy parameters, each element ```[\\\"name\\\", value]```, e.g. ```[[\\\"Interval\\\", 500]]```; ```[]``` if the strategy has none. |\\n| exchanges | Array of exchange object configurations, one element per exchange object, see below. |\\n| period | Default K-line period in seconds, e.g. ```60```, ```3600```. |\\n| node | ID of the docker that runs the bot, see GetNodeList; omitted or ```-1``` means automatic assignment. |\\n| group | Live trading group ID, see GetRobotGroupList. |\\n| appid | Custom label; GetRobotList can filter by it. |\\n\\nAn ```exchanges``` element takes one of two forms, which cannot be mixed in one array (the first element decides):\\n\\n- Reference an exchange account added on the platform: ```{\\\"pid\\\": 123, \\\"pair\\\": \\\"BTC_USDT\\\"}```. ```pid``` is the ```id``` returned by GetPlatformList.\\n- Pass the exchange configuration directly: ```{\\\"eid\\\": \\\"Binance\\\", \\\"label\\\": \\\"test\\\", \\\"pair\\\": \\\"BTC_USDT\\\", \\\"meta\\\": {\\\"AccessKey\\\": \\\"...\\\", \\\"SecretKey\\\": \\\"...\\\"}}```. ```eid``` is the exchange ID; the field names of ```meta``` are given by the ```meta``` returned by GetExchangeList; ```label``` is the exchange object's label, read in the strategy with ```exchange.GetLabel()```. The platform does not store the keys in ```meta``` but forwards them to the docker, so a bot created this way needs ```settings``` again on every restart.\\n\\nFor a custom-protocol exchange: ```{\\\"eid\\\": \\\"Exchange\\\", \\\"label\\\": \\\"test\\\", \\\"pair\\\": \\\"BTC_USDT\\\", \\\"meta\\\": {\\\"AccessKey\\\": \\\"...\\\", \\\"SecretKey\\\": \\\"...\\\", \\\"Front\\\": \\\"http://127.0.0.1:6666/test\\\"}}```, where ```Front``` is the address of the custom-protocol service.\", \"title\": \"Extended API Interface Details\"}, {\"_src_hash\": \"18a80d72b02ca32542a9b6e3476f59f57d295081300532ee22365225e59dea75\", \"desc\": \"The extended API returns this structure:\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": null,\\n \\\"error\\\": null\\n }\\n}\\n```\\n\\n```code``` is the status of the request itself:\\n\\n| Description | Code |\\n| - | - |\\n| Success | 0 |\\n| Invalid API KEY: the ```AccessKey``` does not exist or is disabled; or a wrong ```secret_key``` in direct verification | 1 |\\n| Invalid signature | 2 |\\n| Nonce error: the ```nonce``` is not greater than the previous one, or differs from server time by more than 1 hour | 3 |\\n| Invalid method: the method does not exist, is not public, or this API KEY has no permission for it | 4 |\\n| Invalid arguments: ```args``` is not valid JSON, or the call failed | 5 |\\n| Internal error | 6 |\\n| The request's source IP is not in this API KEY's IP whitelist | 7 |\\n\\n```code``` 0 only means the request was accepted. The method's result is in ```data.result```; when the method fails, ```data.error``` holds the error message (```null``` on success). For example, with the wrong number of arguments:\\n\\n```json\\n{\\n \\\"code\\\": 0,\\n \\\"data\\\": {\\n \\\"result\\\": null,\\n \\\"error\\\": \\\"Params number mismatch for StopRobot: expected 1, got 0\\\"\\n }\\n}\\n```\", \"title\": \"Extended API Interface Return Codes\"}, {\"_src_hash\": \"9bbd82c13510a6da060bc935a494d017528387f7a031da19c63c6595798bcbcd\", \"desc\": \"The ```status``` field in the data returned by ```GetRobotList```, ```GetRobotDetail```, and ```GetRobotLogs``` interfaces represents: Live Trading Status Code.\\n\\n- Normal Start\\n | Status | Code |\\n | - | - |\\n | Idle | 0 |\\n | Running | 1 |\\n | Stopping | 2 |\\n | Exited | 3 |\\n | Stopped | 4 |\\n | Strategy Error | 5 |\\n- Exception\\n | Status | Code |\\n | - | - |\\n | Strategy expired, please contact author to repurchase | -1 |\\n | Docker not found | -2 |\\n | Strategy compilation error | -3 |\\n | Live trading already running | -4 |\\n | Insufficient balance | -5 |\\n | Strategy concurrency limit exceeded | -6 |\", \"title\": \"Live Trading Status Codes\"}], \"desc\": \"The extended API is the platform's HTTP interface (```https://www.fmz.com/api/v1```) for scripts, scheduled jobs and other programs: query the account, dockers, strategies and live trading bots, create, restart and stop bots, send interactive commands to bots, and so on.\\n\\nTo operate the platform interactively from an AI assistant (Claude Code, Cursor, ...), prefer AI Integration (the MCP service, see Integrations → AI Integration): it has more tools, takes named parameters, and can be authorized by permission category. Both can use the same API KEY.\\n\\nSteps: create an API KEY (Create ApiKey), send requests as described in Authentication Methods, and look up methods and parameters in Extended API Interface Details.\", \"title\": \"Extended API Interface\"}, {\"_src_hash\": \"7a5b85bf5d5a5f0d94aec2949f2c768dc5071210d137ffb53efa29acf68d0b61\", \"children\": [{\"_src_hash\": \"fda0732a375c2f1c28417fc2271d7f6fef838ceb7d1f17d6276bde22d51282b3\", \"desc\": \"**How it works**\\n\\nA trading plugin is a short piece of code executed on a docker: when you click \\\"Execute\\\" on the trading terminal page, the platform sends the plugin code and the exchange account selected in the module to the selected docker, runs it, and shows the return value in the module. The following entry points share the same execution mechanism:\\n\\n| Entry point | Code that runs | Notes |\\n| - | - | - |\\n| Trading terminal plugin | A strategy of type \\\"Trading Plugin\\\" in your strategy library | Added and executed on the trading terminal page |\\n| Debug Tool (development tools) | JavaScript code written on the page | For testing API calls |\\n| Extended API PluginRun | ```source``` in the request, or an existing strategy of the account | For programs |\\n| MCP ```plugin_*``` tools | Built-in functions for market data, orders and so on | For AI assistants, authorized by the ```trade``` permission, see Integrations → AI Integration |\\n\\nNo live trading bot is created and nothing is charged; one run lasts at most 5 minutes and is interrupted on timeout. It suits simple tasks that assist manual trading, such as iceberg orders, placing or cancelling orders in bulk, or calculations; logic that has to run for a long time should be a live trading bot.\\n\\n**Writing a plugin**\\n\\nCreate a strategy and set its type to \\\"Trading Plugin\\\" on the new-strategy page. Trading plugins, the debugging tool and ```PluginRun``` support JavaScript only.\\n\\nThe plugin's entry point is ```main()```, and its return value is the result: a returned table or chart object is shown as a table or chart in the module (see Integrations → Trading Terminal → Plugin Examples). Logs written with ```Log()``` are not shown in the module.\\n\\n**Using a plugin**\\n\\n- Add: open the module menu on the trading terminal page; the trading plugins in your strategy library are listed there. Choose one to add it.\\n- Execute: click \\\"Execute\\\" in the plugin module to run it.\\n\\n**Data directory**\\n\\nWhen plugins and the debug tool run on a docker, their working directory is ```logs/storage/p/``` under the docker's running directory (one directory starting with ```p``` per platform account, created on the first run). If an exchange account used by the trading terminal configures its key as a key file path (```file:///xxx.txt```), put the key file in this directory.\", \"title\": \"Plugin Principle and Development\"}, {\"_src_hash\": \"0ffd303f43c1d65239876e2e663f2da49572486d75b22289ab2c857f965f32e7\", \"desc\": \"A plugin runs code for a limited time to do simple jobs such as iceberg orders, placing and cancelling orders, or calculations. It returns its result with ```return```; a returned table or chart object is displayed as a table or chart. Two examples follow; more can be found in the **Strategy Square**, e.g. buying or selling in small slices.\\n\\n**Order book snapshot**\\n\\nShow the top 15 levels of the current order book as a table:\\n\\n```js\\n// Return an order book snapshot\\nfunction main() {\\n var tbl = {\\n type: 'table',\\n title: 'Depth snapshot @ ' + _D(),\\n cols: ['#', 'Amount', 'Ask', 'Bid', 'Amount'],\\n rows: []\\n }\\n var d = exchange.GetDepth()\\n var n = Math.min(d.Asks.length, d.Bids.length, 15)\\n for (var i = 0; i < n; i++) {\\n tbl.rows.push([i, d.Asks[i].Amount, d.Asks[i].Price + '#ff0000', d.Bids[i].Price + '#0000ff', d.Bids[i].Amount])\\n }\\n return tbl\\n}\\n```\\n\\n\\n**Calendar spread chart**\\n\\nOn a futures exchange object, take 5-minute K-lines of the quarterly and the weekly contract and chart the difference of their closes:\\n\\n```js\\n// Chart the calendar spread\\nvar chart = {\\n __isStock: true,\\n title: {text: 'Spread analysis'},\\n xAxis: {type: 'datetime'},\\n yAxis: {\\n title: {text: 'Spread'},\\n opposite: false\\n },\\n series: [\\n {name: \\\"diff\\\", data: []}\\n ]\\n}\\n\\nfunction main() {\\n exchange.SetContractType('quarter')\\n var recordsA = exchange.GetRecords(PERIOD_M5)\\n exchange.SetContractType('this_week')\\n var recordsB = exchange.GetRecords(PERIOD_M5)\\n\\n var n = Math.min(recordsA.length, recordsB.length)\\n for (var i = 0; i < n; i++) {\\n var a = recordsA[recordsA.length - n + i]\\n var b = recordsB[recordsB.length - n + i]\\n chart.series[0].data.push([a.Time, a.Close - b.Close])\\n }\\n return chart\\n}\\n```\", \"title\": \"Plugin Examples\"}], \"desc\": \"The platform provides a modular, customizable [Trading Terminal](https://www.fmz.com/m/trade) page: add market data, trading and other modules freely, drag and resize them, change the exchange and trading pair a module is bound to, and add several modules of the same kind, which makes manual and semi-automated trading convenient.\\n\\nThe trading terminal also supports trading plugins: code you write yourself that runs as a module on a selected docker to assist manual trading.\", \"title\": \"Trading Terminal\"}], \"desc\": \"Driving the platform from AI assistants or other programs: AI integration (the MCP service), the extended API and trading terminal plugins.\", \"title\": \"Integrations\"}]","language","en-US","languageMode","system","sessionData",{"_373":25,"_374":25,"_375":240,"_376":240,"_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.36","paymethod","balance,voucher","link","https://www.fmz.com/mobile","","min_version","v2.0.1","name","FMZ","Copyright © FMZ.COM 版权所有","voucher","https://www.fmz.com/dist/fmz.apk",{"_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","TRX","TRC20","Tron Network","ETH","ERC20","Ethereum Network","BNB","BSC","Binance Smart Chain","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"]

Status	Code
Strategy expired, please contact author to repurchase	-1
Docker not found	-2
Strategy compilation error	-3
Live trading already running	-4
Insufficient balance	-5
Strategy concurrency limit exceeded	-6